{"version":3,"file":"static/js/main.3a125882.js","mappings":"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CR,KAATA,GAAey0C,GAAmBz0C,GAE5BilE,EAAYjlE,IAErBm3C,GAAO,EACPvC,EAAQI,QAAQh1C,GACTglE,EACT,CAYA,SAASE,EAAoBllE,GAY3B,OAVa,KAATA,EACF8kE,GAA0B,GAK1BC,EAA8BD,EAC9BA,OAA0BxhF,GAE5BsxD,EAAQI,QAAQh1C,GACTglE,CACT,CAWA,SAASC,EAAYjlE,GAGnB,OAAI+kE,GAA+BD,IAA4B3tB,EACtDC,EAAIp3C,GAENzc,EAAGyc,EACZ,CACF,EA5iBEy3C,SAAS,GAELud,GAAO,CACX/f,SAsjBF,SAAsBL,EAASrxD,GAC7B,IAAIm+D,EAAW,EACXyjB,EAAY,EAChB,OAAOC,EAYP,SAASA,EAAWplE,GAClB,OAAa,KAATA,GACF0hD,IACA9M,EAAQI,QAAQh1C,GACTolE,GAMI,KAATplE,GAAemlE,EAAYzjB,EACtB2jB,EAAkBrlE,GAOhB,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,MAATA,EAEO40C,EAAQxwD,MAAM05E,GAAOv6E,EAAI8hF,EAAzBzwB,CAA4C50C,GAG1C,OAATA,GACAu0C,GAA0Bv0C,IAC1B00C,GAAkB10C,GAEXzc,EAAGyc,IAEZ40C,EAAQI,QAAQh1C,GACTolE,EACT,CAYA,SAASC,EAAkBrlE,GAMzB,OAJa,KAATA,GACFmlE,IAEFvwB,EAAQI,QAAQh1C,GACTolE,CACT,CACF,EAroBE3tB,SAAS,GAELqmB,GAAQ,CACZ7oB,SAmpBF,SAAuBL,EAASrxD,EAAI6zD,GAClC,OAAO0mB,EAYP,SAASA,EAAM99D,GAEb,OACW,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,MAATA,GAEA40C,EAAQI,QAAQh1C,GACT89D,GAMI,KAAT99D,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ACA,SACA,QACA,SACA,OACA,KACA,SACA,SACA,QACA,SACA,SACA,SACA,OACA,OACA,MACA,QACA,SACA,QACA,SACA,OACA,SACA,SACA,QACA,QACA,QACA,SACA,MACA,QACA,SACA,OACA,SACA,SACA,QACA,OACA,OACA,SACA,MACA,SACA,SACA,QACA,SACA,MACA,OACA,SACA,SACA,SACA,KACA,SACA,QACA,QACA,SACA,SACA,OACA,QACA,KACA,OACA,QACA,SACA,OACA,MACA,SACA,SACA,QACA,SACA,OACA,OACA,SACA,SACA,OACA,OACA,SACA,QACA,OACA,QACA,MACA,OACA,MACA,OACA,OACA,OACA,QACA,QACA,QACA,SACA,QACA,SACA,MACA,OACA,SACA,MACA,QC1GWC,EAA4B,CACvC,EAAG,SACH,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,UC1BA,SAASC,EAAU1vF,GACxB,MAAM0L,EACiB,kBAAd1L,EAAyBA,EAAUiG,WAAW,GAAKjG,EAE5D,OAAO0L,GAAQ,IAAMA,GAAQ,EAC/B,CCLO,SAASikF,EAAc3vF,GAC5B,MAAM0L,EACiB,kBAAd1L,EAAyBA,EAAUiG,WAAW,GAAKjG,EAE5D,OACG0L,GAAQ,IAAcA,GAAQ,KAC9BA,GAAQ,IAAcA,GAAQ,IAC9BA,GAAQ,IAAcA,GAAQ,EAEnC,CCNO,SAASkkF,EAAiB5vF,GAC/B,OCJK,SAAwBA,GAC7B,MAAM0L,EACiB,kBAAd1L,EAAyBA,EAAUiG,WAAW,GAAKjG,EAE5D,OACG0L,GAAQ,IAAMA,GAAQ,KACtBA,GAAQ,IAAMA,GAAQ,EAE3B,CDJSmkF,CAAe7vF,IAAc0vF,EAAU1vF,EAChD,eEAA,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","sources":["../node_modules/@babel/runtime/helpers/esm/extends.js","../node_modules/unist-util-is/lib/index.js","../node_modules/unist-util-visit-parents/lib/index.js","../node_modules/unist-util-visit/lib/index.js","../node_modules/hast-util-to-string/lib/index.js","../node_modules/unist-util-filter/lib/index.js","../../src/generator.js","../../src/all.js","../../src/common.js","../node_modules/css-selector-parser/dist/mjs/indexes.js","../node_modules/css-selector-parser/dist/mjs/pseudo-signatures.js","../node_modules/css-selector-parser/dist/mjs/syntax-definitions.js","../node_modules/css-selector-parser/dist/mjs/utils.js","../node_modules/css-selector-parser/dist/mjs/parser.js","../node_modules/css-selector-parser/dist/mjs/ast.js","../node_modules/hast-util-select/lib/parse.js","../node_modules/direction/index.js","../node_modules/hast-util-select/lib/enter-state.js","../node_modules/hast-util-select/lib/attribute.js","../node_modules/hast-util-select/lib/class-name.js","../node_modules/hast-util-select/lib/id.js","../node_modules/hast-util-select/lib/name.js","../node_modules/bcp-47-match/index.js","../node_modules/hast-util-has-property/lib/index.js","../node_modules/hast-util-whitespace/lib/index.js","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/parse.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/index.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/compile.ts","../node_modules/zwitch/index.js","../node_modules/hast-util-select/lib/pseudo.js","../node_modules/hast-util-select/lib/test.js","../node_modules/hast-util-select/lib/walk.js","../node_modules/hast-util-select/lib/index.js","../node_modules/rehype-rewrite/src/index.ts","../node_modules/rehype-attr/src/utils.ts","../node_modules/rehype-attr/src/index.ts","../node_modules/@ungap/structured-clone/esm/deserialize.js","../node_modules/@ungap/structured-clone/esm/types.js","../node_modules/@ungap/structured-clone/esm/serialize.js","../node_modules/@ungap/structured-clone/esm/index.js","../node_modules/hast-util-from-parse5/node_modules/hast-util-parse-selector/lib/index.js","../node_modules/hast-util-from-parse5/node_modules/hastscript/lib/create-h.js","../node_modules/hast-util-from-parse5/node_modules/hastscript/lib/svg-case-sensitive-tag-names.js","../node_modules/hast-util-from-parse5/node_modules/hastscript/lib/index.js","../node_modules/vfile-location/lib/index.js","../node_modules/web-namespaces/index.js","../node_modules/hast-util-from-parse5/lib/index.js","../node_modules/hast-util-to-parse5/lib/index.js","../node_modules/html-void-elements/index.js","../node_modules/hast-util-raw/node_modules/parse5/dist/common/unicode.js","../node_modules/hast-util-raw/node_modules/parse5/dist/common/error-codes.js","../node_modules/hast-util-raw/node_modules/parse5/dist/tokenizer/preprocessor.js","../node_modules/hast-util-raw/node_modules/parse5/dist/common/token.js","../https:/raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-html.ts","../https:/raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-xml.ts","../https:/raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode_codepoint.ts","../https:/raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode.ts","../node_modules/hast-util-raw/node_modules/parse5/dist/common/html.js","../node_modules/hast-util-raw/node_modules/parse5/dist/tokenizer/index.js","../node_modules/hast-util-raw/node_modules/parse5/dist/parser/open-element-stack.js","../node_modules/hast-util-raw/node_modules/parse5/dist/parser/formatting-element-list.js","../node_modules/hast-util-raw/node_modules/parse5/dist/tree-adapters/default.js","../node_modules/hast-util-raw/node_modules/parse5/dist/common/doctype.js","../node_modules/hast-util-raw/node_modules/parse5/dist/common/foreign-content.js","../node_modules/hast-util-raw/node_modules/parse5/dist/parser/index.js","../https:/raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/escape.ts","../node_modules/hast-util-raw/node_modules/parse5/dist/serializer/index.js","../node_modules/unist-util-position/lib/index.js","../node_modules/hast-util-raw/lib/index.js","../node_modules/rehype-raw/lib/index.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../node_modules/estree-util-is-identifier-name/lib/index.js","../node_modules/property-information/lib/hast-to-react.js","../node_modules/style-to-object/esm/index.mjs","../node_modules/unist-util-stringify-position/lib/index.js","../node_modules/vfile-message/lib/index.js","../node_modules/hast-util-to-jsx-runtime/lib/index.js","../node_modules/html-url-attributes/lib/index.js","../node_modules/mdast-util-to-string/lib/index.js","../node_modules/micromark-util-chunked/index.js","../node_modules/micromark-util-subtokenize/lib/splice-buffer.js","../node_modules/micromark-util-subtokenize/index.js","../node_modules/micromark-util-combine-extensions/index.js","../node_modules/micromark-util-character/index.js","../node_modules/micromark-factory-space/index.js","../node_modules/micromark/lib/initialize/content.js","../node_modules/micromark/lib/initialize/document.js","../node_modules/micromark-core-commonmark/lib/blank-line.js","../node_modules/micromark-core-commonmark/lib/content.js","../node_modules/micromark/lib/initialize/flow.js","../node_modules/micromark/lib/initialize/text.js","../node_modules/micromark-util-resolve-all/index.js","../node_modules/micromark/lib/create-tokenizer.js","../node_modules/micromark-core-commonmark/lib/thematic-break.js","../node_modules/micromark-core-commonmark/lib/list.js","../node_modules/micromark-core-commonmark/lib/block-quote.js","../node_modules/micromark-factory-destination/index.js","../node_modules/micromark-factory-label/index.js","../node_modules/micromark-factory-title/index.js","../node_modules/micromark-factory-whitespace/index.js","../node_modules/micromark-util-normalize-identifier/index.js","../node_modules/micromark-core-commonmark/lib/definition.js","../node_modules/micromark-core-commonmark/lib/code-indented.js","../node_modules/micromark-core-commonmark/lib/heading-atx.js","../node_modules/micromark-core-commonmark/lib/setext-underline.js","../node_modules/micromark-util-html-tag-name/index.js","../node_modules/micromark-core-commonmark/lib/html-flow.js","../node_modules/micromark-core-commonmark/lib/code-fenced.js","../node_modules/micromark-core-commonmark/lib/character-reference.js","../node_modules/micromark-core-commonmark/lib/character-escape.js","../node_modules/micromark-core-commonmark/lib/line-ending.js","../node_modules/micromark-core-commonmark/lib/label-end.js","../node_modules/micromark-core-commonmark/lib/label-start-image.js","../node_modules/micromark-util-classify-character/index.js","../node_modules/micromark-core-commonmark/lib/attention.js","../node_modules/micromark-core-commonmark/lib/autolink.js","../node_modules/micromark-core-commonmark/lib/html-text.js","../node_modules/micromark-core-commonmark/lib/label-start-link.js","../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../node_modules/micromark-core-commonmark/lib/code-text.js","../node_modules/micromark/lib/constructs.js","../node_modules/micromark/lib/preprocess.js","../node_modules/micromark-util-decode-numeric-character-reference/index.js","../node_modules/micromark-util-decode-string/index.js","../node_modules/mdast-util-from-markdown/lib/index.js","../node_modules/micromark/lib/postprocess.js","../node_modules/micromark/lib/parse.js","../node_modules/remark-parse/lib/index.js","../node_modules/micromark-util-sanitize-uri/index.js","../node_modules/mdast-util-to-hast/lib/footer.js","../node_modules/mdast-util-to-hast/lib/revert.js","../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../node_modules/trim-lines/index.js","../node_modules/mdast-util-to-hast/lib/handlers/index.js","../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../node_modules/mdast-util-to-hast/lib/handlers/break.js","../node_modules/mdast-util-to-hast/lib/handlers/code.js","../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../node_modules/mdast-util-to-hast/lib/handlers/html.js","../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/image.js","../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/link.js","../node_modules/mdast-util-to-hast/lib/handlers/list.js","../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../node_modules/mdast-util-to-hast/lib/handlers/root.js","../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../node_modules/mdast-util-to-hast/lib/handlers/table.js","../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","../node_modules/mdast-util-to-hast/lib/handlers/text.js","../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../node_modules/mdast-util-to-hast/lib/state.js","../node_modules/mdast-util-to-hast/lib/index.js","../node_modules/remark-rehype/lib/index.js","../node_modules/bail/index.js","../node_modules/unified/node_modules/is-plain-obj/index.js","../node_modules/trough/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/unified/lib/callable-instance.js","../node_modules/unified/lib/index.js","../node_modules/react-markdown/lib/index.js","../node_modules/ccount/index.js","../node_modules/mdast-util-find-and-replace/lib/index.js","../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","../node_modules/mdast-util-gfm-autolink-literal/lib/index.js","../node_modules/mdast-util-gfm-footnote/lib/index.js","../node_modules/mdast-util-gfm-strikethrough/lib/index.js","../node_modules/markdown-table/index.js","../node_modules/mdast-util-to-markdown/lib/handle/blockquote.js","../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","../node_modules/mdast-util-to-markdown/lib/handle/break.js","../node_modules/mdast-util-to-markdown/lib/handle/code.js","../node_modules/mdast-util-to-markdown/lib/util/check-quote.js","../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js","../node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js","../node_modules/mdast-util-to-markdown/lib/handle/html.js","../node_modules/mdast-util-to-markdown/lib/handle/image.js","../node_modules/mdast-util-to-markdown/lib/handle/image-reference.js","../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","../node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js","../node_modules/mdast-util-to-markdown/lib/handle/link.js","../node_modules/mdast-util-to-markdown/lib/handle/link-reference.js","../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","../node_modules/mdast-util-to-markdown/lib/util/check-rule.js","../node_modules/mdast-util-phrasing/lib/index.js","../node_modules/mdast-util-to-markdown/lib/handle/strong.js","../node_modules/mdast-util-to-markdown/lib/util/check-strong.js","../node_modules/mdast-util-to-markdown/lib/handle/index.js","../node_modules/mdast-util-to-markdown/lib/util/check-fence.js","../node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js","../node_modules/longest-streak/index.js","../node_modules/mdast-util-to-markdown/lib/handle/definition.js","../node_modules/mdast-util-to-markdown/lib/handle/heading.js","../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js","../node_modules/mdast-util-to-markdown/lib/handle/list.js","../node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js","../node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js","../node_modules/mdast-util-to-markdown/lib/handle/list-item.js","../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","../node_modules/mdast-util-to-markdown/lib/handle/paragraph.js","../node_modules/mdast-util-to-markdown/lib/handle/root.js","../node_modules/mdast-util-to-markdown/lib/handle/text.js","../node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js","../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js","../node_modules/mdast-util-gfm-table/lib/index.js","../node_modules/mdast-util-gfm-task-list-item/lib/index.js","../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","../node_modules/micromark-extension-gfm-footnote/lib/syntax.js","../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","../node_modules/micromark-extension-gfm-table/lib/edit-map.js","../node_modules/micromark-extension-gfm-table/lib/infer.js","../node_modules/micromark-extension-gfm-table/lib/syntax.js","../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","../node_modules/remark-gfm/lib/index.js","../node_modules/micromark-extension-gfm/index.js","../node_modules/mdast-util-gfm/lib/index.js","../node_modules/remark-github-blockquote-alert/src/index.ts","../node_modules/@uiw/react-markdown-preview/esm/plugins/useCopied.js","../node_modules/@uiw/react-markdown-preview/esm/preview.js","../node_modules/@uiw/react-markdown-preview/esm/plugins/reservedMeta.js","../node_modules/@uiw/react-markdown-preview/esm/plugins/retrieveMeta.js","../node_modules/github-slugger/regex.js","../node_modules/github-slugger/index.js","../node_modules/hast-util-heading-rank/lib/index.js","../node_modules/rehype-slug/lib/index.js","../node_modules/hast-util-is-element/lib/index.js","../node_modules/rehype-autolink-headings/lib/index.js","../node_modules/rehype-ignore/src/index.ts","../node_modules/@uiw/react-markdown-preview/esm/nodes/octiconLink.js","../node_modules/@uiw/react-markdown-preview/esm/rehypePlugins.js","../node_modules/@uiw/react-markdown-preview/esm/index.js","../node_modules/@uiw/react-markdown-preview/esm/nodes/copy.js","../node_modules/@uiw/github-corners/src/index.ts","../node_modules/@uiw/react-github-corners/esm/index.js","../README.md","webpack://@wcjiang/notify/./website/components/GithubShields.module.less?45a4","components/GithubShields.js","webpack://@wcjiang/notify/./website/components/Button/index.module.less?6f17","components/Button/index.js","webpack://@wcjiang/notify/./website/components/Footer.module.less?cff4","components/Footer.js","webpack://@wcjiang/notify/./website/styles/index.module.less?2aeb","../src/main.js","App.js","index.js","../../src/main.js","../node_modules/@wcj/dark-mode/dist/dark-mode.min.js","../node_modules/boolbase/index.js","../node_modules/classnames/index.js","../node_modules/extend/index.js","../node_modules/inline-style-parser/index.js","../node_modules/parse-numeric-range/index.js","../node_modules/scheduler/cjs/scheduler.production.min.js","../node_modules/scheduler/index.js","../node_modules/style-to-object/src/index.ts","../node_modules/@babel/runtime/helpers/defineProperty.js","../node_modules/@babel/runtime/helpers/toPrimitive.js","../node_modules/@babel/runtime/helpers/toPropertyKey.js","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/comma-separated-tokens/index.js","../node_modules/decode-named-character-reference/index.dom.js","../node_modules/hast-util-parse-selector/lib/index.js","../node_modules/hastscript/lib/core.js","../node_modules/hastscript/lib/html.js","../node_modules/character-entities-legacy/index.js","../node_modules/character-reference-invalid/index.js","../node_modules/is-decimal/index.js","../node_modules/is-hexadecimal/index.js","../node_modules/is-alphanumerical/index.js","../node_modules/is-alphabetical/index.js","../node_modules/parse-entities/lib/index.js","../node_modules/property-information/lib/util/schema.js","../node_modules/property-information/lib/util/merge.js","../node_modules/property-information/lib/util/create.js","../node_modules/property-information/lib/xlink.js","../node_modules/property-information/lib/xml.js","../node_modules/property-information/lib/util/case-sensitive-transform.js","../node_modules/property-information/lib/util/case-insensitive-transform.js","../node_modules/property-information/lib/xmlns.js","../node_modules/property-information/lib/aria.js","../node_modules/property-information/lib/html.js","../node_modules/property-information/lib/svg.js","../node_modules/property-information/index.js","../node_modules/property-information/lib/find.js","../node_modules/property-information/lib/normalize.js","../node_modules/property-information/lib/util/defined-info.js","../node_modules/property-information/lib/util/info.js","../node_modules/property-information/lib/util/types.js","../node_modules/space-separated-tokens/index.js","../webpack/bootstrap","../webpack/runtime/chunk loaded","../webpack/runtime/compat get default export","../webpack/runtime/define property getters","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/make namespace object","../webpack/runtime/publicPath","../webpack/runtime/jsonp chunk loading","../webpack/startup"],"sourcesContent":["function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","/**\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} 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","/**\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n */\n\n/**\n * Get the plain-text value of a hast node.\n *\n * @param {Nodes} node\n *   Node to serialize.\n * @returns {string}\n *   Serialized node.\n */\nexport function toString(node) {\n  // “The concatenation of data of all the Text node descendants of the context\n  // object, in tree order.”\n  if ('children' in node) {\n    return all(node)\n  }\n\n  // “Context object’s data.”\n  return 'value' in node ? node.value : ''\n}\n\n/**\n * @param {Nodes} node\n *   Node.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(node) {\n  if (node.type === 'text') {\n    return node.value\n  }\n\n  return 'children' in node ? all(node) : ''\n}\n\n/**\n * @param {Parents} node\n *   Node.\n * @returns {string}\n *   Serialized node.\n */\nfunction all(node) {\n  let index = -1\n  /** @type {Array<string>} */\n  const result = []\n\n  while (++index < node.children.length) {\n    result[index] = one(node.children[index])\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\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 Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [cascade=true]\n *   Whether to drop parent nodes if they had children, but all their children\n *   were filtered out (default: `true`).\n */\n\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Create a new `tree` of copies of all nodes that pass `test`.\n *\n * The tree is walked in *preorder* (NLR), visiting the node itself, then its\n * head, etc.\n *\n * @template {Node} Tree\n * @template {Test} Check\n *\n * @overload\n * @param {Tree} tree\n * @param {Options | null | undefined} options\n * @param {Check} test\n * @returns {import('./complex-types.js').Matches<Tree, Check>}\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} test\n * @returns {import('./complex-types.js').Matches<Tree, Check>}\n *\n * @overload\n * @param {Tree} tree\n * @param {null | undefined} [options]\n * @returns {Tree}\n *\n * @param {Node} tree\n *   Tree to filter.\n * @param {Options | Test} [options]\n *   Configuration (optional).\n * @param {Test} [test]\n *   `unist-util-is` compatible test.\n * @returns {Node | undefined}\n *   New filtered tree.\n *\n *   `undefined` is returned if `tree` itself didn’t pass the test, or is\n *   cascaded away.\n */\nexport function filter(tree, options, test) {\n  const is = convert(test || options)\n  const cascadeRaw =\n    options && typeof options === 'object' && 'cascade' in options\n      ? /** @type {boolean | null | undefined} */ (options.cascade)\n      : undefined\n  const cascade =\n    cascadeRaw === undefined || cascadeRaw === null ? true : cascadeRaw\n\n  return preorder(tree)\n\n  /**\n   * @param {Node} node\n   *   Current node.\n   * @param {number | undefined} [index]\n   *   Index of `node` in `parent`.\n   * @param {Parent | undefined} [parentNode]\n   *   Parent node.\n   * @returns {Node | undefined}\n   *   Shallow copy of `node`.\n   */\n  function preorder(node, index, parentNode) {\n    /** @type {Array<Node>} */\n    const children = []\n\n    if (!is(node, index, parentNode)) return undefined\n\n    if (parent(node)) {\n      let childIndex = -1\n\n      while (++childIndex < node.children.length) {\n        const result = preorder(node.children[childIndex], childIndex, node)\n\n        if (result) {\n          children.push(result)\n        }\n      }\n\n      if (cascade && node.children.length > 0 && children.length === 0) {\n        return undefined\n      }\n    }\n\n    // Create a shallow clone, using the new children.\n    /** @type {typeof node} */\n    // @ts-expect-error all the fields will be copied over.\n    const next = {}\n    /** @type {string} */\n    let key\n\n    for (key in node) {\n      if (own.call(node, key)) {\n        // @ts-expect-error: Looks like a record.\n        next[key] = key === 'children' ? children : node[key]\n      }\n    }\n\n    return next\n  }\n}\n\n/**\n * @param {Node} node\n * @returns {node is Parent}\n */\nfunction parent(node) {\n  return 'children' in node && node.children !== undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef Options options\n *   Configuration.\n * @property {boolean} [showLineNumbers]\n *   Set `showLineNumbers` to `true` to always display line number\n * @property {boolean} [ignoreMissing]\n *   Set `ignoreMissing` to `true` to ignore unsupported languages and line highlighting when no language is specified\n * @property {string} [defaultLanguage]\n *   Uses the specified language as the default if none is specified. Takes precedence over `ignoreMissing`.\n *   Note: The language must be registered with refractor.\n */\n\nimport { visit } from 'unist-util-visit'\nimport { toString } from 'hast-util-to-string'\nimport { filter } from 'unist-util-filter'\nimport rangeParser from 'parse-numeric-range'\n\nconst getLanguage = (node) => {\n  const className = node.properties.className\n  //@ts-ignore\n  for (const classListItem of className) {\n    if (classListItem.slice(0, 9) === 'language-') {\n      return classListItem.slice(9).toLowerCase()\n    }\n  }\n  return null\n}\n\n/**\n * @param {import('refractor/lib/core').Refractor} refractor\n * @param {string} defaultLanguage\n * @return {void}\n */\nconst checkIfLanguageIsRegistered = (refractor, defaultLanguage) => {\n  if (defaultLanguage && !refractor.registered(defaultLanguage)) {\n    throw new Error(`The default language \"${defaultLanguage}\" is not registered with refractor.`)\n  }\n}\n\n/**\n * Create a closure that determines if we have to highlight the given index\n *\n * @param {string} meta\n * @return { (index:number) => boolean }\n */\nconst calculateLinesToHighlight = (meta) => {\n  const RE = /{([\\d,-]+)}/\n  // Remove space between {} e.g. {1, 3}\n  const parsedMeta = meta\n    .split(',')\n    .map((str) => str.trim())\n    .join()\n  if (RE.test(parsedMeta)) {\n    const strlineNumbers = RE.exec(parsedMeta)[1]\n    const lineNumbers = rangeParser(strlineNumbers)\n    return (index) => lineNumbers.includes(index + 1)\n  } else {\n    return () => false\n  }\n}\n\n/**\n * Check if we want to start the line numbering from a given number or 1\n * showLineNumbers=5, will start the numbering from 5\n * @param {string} meta\n * @returns {number}\n */\nconst calculateStartingLine = (meta) => {\n  const RE = /showLineNumbers=(?<lines>\\d+)/i\n  // pick the line number after = using a named capturing group\n  if (RE.test(meta)) {\n    const {\n      groups: { lines },\n    } = RE.exec(meta)\n    return Number(lines)\n  }\n  return 1\n}\n\n/**\n * Create container AST for node lines\n *\n * @param {number} number\n * @return {Element[]}\n */\nconst createLineNodes = (number) => {\n  const a = new Array(number)\n  for (let i = 0; i < number; i++) {\n    a[i] = {\n      type: 'element',\n      tagName: 'span',\n      properties: { className: [] },\n      children: [],\n    }\n  }\n  return a\n}\n\n/**\n * Split multiline text nodes into individual nodes with positioning\n * Add a node start and end line position information for each text node\n *\n * @return { (ast:Element['children']) => Element['children'] }\n *\n */\nconst addNodePositionClosure = () => {\n  let startLineNum = 1\n  /**\n   * @param {Element['children']} ast\n   * @return {Element['children']}\n   */\n  const addNodePosition = (ast) => {\n    return ast.reduce((result, node) => {\n      if (node.type === 'text') {\n        const value = /** @type {string} */ (node.value)\n        const numLines = (value.match(/\\n/g) || '').length\n        if (numLines === 0) {\n          node.position = {\n            // column: 1 is needed to avoid error with @next/mdx\n            // https://github.com/timlrx/rehype-prism-plus/issues/44\n            start: { line: startLineNum, column: 1 },\n            end: { line: startLineNum, column: 1 },\n          }\n          result.push(node)\n        } else {\n          const lines = value.split('\\n')\n          for (const [i, line] of lines.entries()) {\n            result.push({\n              type: 'text',\n              value: i === lines.length - 1 ? line : line + '\\n',\n              position: {\n                start: { line: startLineNum + i, column: 1 },\n                end: { line: startLineNum + i, column: 1 },\n              },\n            })\n          }\n        }\n        startLineNum = startLineNum + numLines\n\n        return result\n      }\n\n      if (Object.prototype.hasOwnProperty.call(node, 'children')) {\n        const initialLineNum = startLineNum\n        // @ts-ignore\n        node.children = addNodePosition(node.children, startLineNum)\n        result.push(node)\n        node.position = {\n          start: { line: initialLineNum, column: 1 },\n          end: { line: startLineNum, column: 1 },\n        }\n        return result\n      }\n\n      result.push(node)\n      return result\n    }, [])\n  }\n  return addNodePosition\n}\n\n/**\n * Rehype prism plugin generator that highlights code blocks with refractor (prismjs)\n *\n * Pass in your own refractor object with the required languages registered:\n * https://github.com/wooorm/refractor#refractorregistersyntax\n *\n * @param {import('refractor/lib/core').Refractor} refractor\n * @return {import('unified').Plugin<[Options?], Root>}\n */\nconst rehypePrismGenerator = (refractor) => {\n  return (options = {}) => {\n    checkIfLanguageIsRegistered(refractor, options.defaultLanguage)\n    return (tree) => {\n      visit(tree, 'element', visitor)\n    }\n\n    /**\n     * @param {Element} node\n     * @param {number} index\n     * @param {Element} parent\n     */\n    function visitor(node, index, parent) {\n      if (!parent || parent.tagName !== 'pre' || node.tagName !== 'code') {\n        return\n      }\n\n      // @ts-ignore meta is a custom code block property\n      let meta = /** @type {string} */ (node?.data?.meta || node?.properties?.metastring || '')\n      // Coerce className to array\n      if (node.properties.className) {\n        if (typeof node.properties.className === 'boolean') {\n          node.properties.className = []\n        } else if (!Array.isArray(node.properties.className)) {\n          node.properties.className = [node.properties.className]\n        }\n      } else {\n        node.properties.className = []\n      }\n\n      let lang = getLanguage(node)\n      // If no language is set on the code block, use defaultLanguage if specified\n      if (!lang && options.defaultLanguage) {\n        lang = options.defaultLanguage\n        node.properties.className.push(`language-${lang}`)\n      }\n      node.properties.className.push('code-highlight')\n\n      /** @type {Element} */\n      let refractorRoot\n\n      // Syntax highlight\n      if (lang) {\n        try {\n          let rootLang\n          if (lang?.includes('diff-')) {\n            rootLang = lang.split('-')[1]\n          } else {\n            rootLang = lang\n          }\n          // @ts-ignore\n          refractorRoot = refractor.highlight(toString(node), rootLang)\n          // @ts-ignore className is already an array\n          parent.properties.className = (parent.properties.className || []).concat(\n            'language-' + rootLang\n          )\n        } catch (err) {\n          if (options.ignoreMissing && /Unknown language/.test(err.message)) {\n            refractorRoot = node\n          } else {\n            throw err\n          }\n        }\n      } else {\n        refractorRoot = node\n      }\n\n      refractorRoot.children = addNodePositionClosure()(refractorRoot.children)\n\n      // Add position info to root\n      if (refractorRoot.children.length > 0) {\n        refractorRoot.position = {\n          start: { line: refractorRoot.children[0].position.start.line, column: 0 },\n          end: {\n            line: refractorRoot.children[refractorRoot.children.length - 1].position.end.line,\n            column: 0,\n          },\n        }\n      } else {\n        refractorRoot.position = {\n          start: { line: 0, column: 0 },\n          end: { line: 0, column: 0 },\n        }\n      }\n\n      const shouldHighlightLine = calculateLinesToHighlight(meta)\n      const startingLineNumber = calculateStartingLine(meta)\n      const codeLineArray = createLineNodes(refractorRoot.position.end.line)\n\n      const falseShowLineNumbersStr = [\n        'showlinenumbers=false',\n        'showlinenumbers=\"false\"',\n        'showlinenumbers={false}',\n      ]\n      for (const [i, line] of codeLineArray.entries()) {\n        // Default class name for each line\n        line.properties.className = ['code-line']\n\n        // Syntax highlight\n        const treeExtract = filter(\n          refractorRoot,\n          (node) => node.position.start.line <= i + 1 && node.position.end.line >= i + 1\n        )\n        line.children = treeExtract.children\n\n        // Line number\n        if (\n          (meta.toLowerCase().includes('showLineNumbers'.toLowerCase()) ||\n            options.showLineNumbers) &&\n          !falseShowLineNumbersStr.some((str) => meta.toLowerCase().includes(str))\n        ) {\n          line.properties.line = [(i + startingLineNumber).toString()]\n          line.properties.className.push('line-number')\n        }\n\n        // Line highlight\n        if (shouldHighlightLine(i)) {\n          line.properties.className.push('highlight-line')\n        }\n\n        // Diff classes\n        if (\n          (lang === 'diff' || lang?.includes('diff-')) &&\n          toString(line).substring(0, 1) === '-'\n        ) {\n          line.properties.className.push('deleted')\n        } else if (\n          (lang === 'diff' || lang?.includes('diff-')) &&\n          toString(line).substring(0, 1) === '+'\n        ) {\n          line.properties.className.push('inserted')\n        }\n      }\n\n      // Remove possible trailing line when splitting by \\n which results in empty array\n      if (\n        codeLineArray.length > 0 &&\n        toString(codeLineArray[codeLineArray.length - 1]).trim() === ''\n      ) {\n        codeLineArray.pop()\n      }\n\n      node.children = codeLineArray\n    }\n  }\n}\n\nexport default rehypePrismGenerator\n","import { refractor as refractorAll } from 'refractor/lib/all.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * This supports all the languages and should be used on the server side.\n *\n * Consider using rehypePrismCommon or rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismAll = rehypePrismGenerator(refractorAll)\n\nexport default rehypePrismAll\n","import { refractor as refractorCommon } from 'refractor/lib/common.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * Supported languages: https://github.com/wooorm/refractor#data\n *\n * Consider using rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismCommon = rehypePrismGenerator(refractorCommon)\n\nexport default rehypePrismCommon\n","export var emptyMulticharIndex = {};\nexport var emptyRegularIndex = {};\nfunction extendIndex(item, index) {\n    var currentIndex = index;\n    for (var pos = 0; pos < item.length; pos++) {\n        var isLast = pos === item.length - 1;\n        var char = item.charAt(pos);\n        var charIndex = currentIndex[char] || (currentIndex[char] = { chars: {} });\n        if (isLast) {\n            charIndex.self = item;\n        }\n        currentIndex = charIndex.chars;\n    }\n}\nexport function createMulticharIndex(items) {\n    if (items.length === 0) {\n        return emptyMulticharIndex;\n    }\n    var index = {};\n    for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {\n        var item = items_1[_i];\n        extendIndex(item, index);\n    }\n    return index;\n}\nexport function createRegularIndex(items) {\n    if (items.length === 0) {\n        return emptyRegularIndex;\n    }\n    var result = {};\n    for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {\n        var item = items_2[_i];\n        result[item] = true;\n    }\n    return result;\n}\n","export var emptyPseudoSignatures = {};\nexport var defaultPseudoSignature = {\n    type: 'String',\n    optional: true\n};\nfunction calculatePseudoSignature(types) {\n    var result = {\n        type: 'NoArgument',\n        optional: false\n    };\n    function setResultType(type) {\n        if (result.type && result.type !== type && result.type !== 'NoArgument') {\n            throw new Error(\"Conflicting pseudo-class argument type: \\\"\".concat(result.type, \"\\\" vs \\\"\").concat(type, \"\\\".\"));\n        }\n        result.type = type;\n    }\n    for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {\n        var type = types_1[_i];\n        if (type === 'NoArgument') {\n            result.optional = true;\n        }\n        if (type === 'Formula') {\n            setResultType('Formula');\n        }\n        if (type === 'FormulaOfSelector') {\n            setResultType('Formula');\n            result.ofSelector = true;\n        }\n        if (type === 'String') {\n            setResultType('String');\n        }\n        if (type === 'Selector') {\n            setResultType('Selector');\n        }\n    }\n    return result;\n}\nexport function inverseCategories(obj) {\n    var result = {};\n    for (var _i = 0, _a = Object.keys(obj); _i < _a.length; _i++) {\n        var category = _a[_i];\n        var items = obj[category];\n        if (items) {\n            for (var _b = 0, _c = items; _b < _c.length; _b++) {\n                var item = _c[_b];\n                (result[item] || (result[item] = [])).push(category);\n            }\n        }\n    }\n    return result;\n}\nexport function calculatePseudoSignatures(definitions) {\n    var pseudoClassesToArgumentTypes = inverseCategories(definitions);\n    var result = {};\n    for (var _i = 0, _a = Object.keys(pseudoClassesToArgumentTypes); _i < _a.length; _i++) {\n        var pseudoClass = _a[_i];\n        var argumentTypes = pseudoClassesToArgumentTypes[pseudoClass];\n        if (argumentTypes) {\n            result[pseudoClass] = calculatePseudoSignature(argumentTypes);\n        }\n    }\n    return result;\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar emptyXmlOptions = {};\nvar defaultXmlOptions = { wildcard: true };\nexport function getXmlOptions(param) {\n    if (param) {\n        if (typeof param === 'boolean') {\n            return defaultXmlOptions;\n        }\n        else {\n            return param;\n        }\n    }\n    else {\n        return emptyXmlOptions;\n    }\n}\nfunction withMigration(migration, merge) {\n    return function (base, extension) { return merge(migration(base), migration(extension)); };\n}\nfunction withNoNegative(merge) {\n    return function (base, extension) {\n        var result = merge(base, extension);\n        if (!result) {\n            throw new Error(\"Syntax definition cannot be null or undefined.\");\n        }\n        return result;\n    };\n}\nfunction withPositive(positive, merge) {\n    return function (base, extension) {\n        if (extension === true) {\n            return positive;\n        }\n        return merge(base === true ? positive : base, extension);\n    };\n}\nfunction mergeSection(values) {\n    return function (base, extension) {\n        if (!extension || !base) {\n            return extension;\n        }\n        if (typeof extension !== 'object' || extension === null) {\n            throw new Error(\"Unexpected syntax definition extension type: \".concat(extension, \".\"));\n        }\n        var result = __assign({}, base);\n        for (var _i = 0, _a = Object.entries(extension); _i < _a.length; _i++) {\n            var _b = _a[_i], key = _b[0], value = _b[1];\n            var mergeSchema = values[key];\n            result[key] = mergeSchema(base[key], value);\n        }\n        return result;\n    };\n}\nfunction replaceValueIfSpecified(base, extension) {\n    if (extension !== undefined) {\n        return extension;\n    }\n    return base;\n}\nfunction concatArray(base, extension) {\n    if (!extension) {\n        return base;\n    }\n    if (!base) {\n        return extension;\n    }\n    return base.concat(extension);\n}\nfunction mergeDefinitions(base, extension) {\n    if (!extension) {\n        return base;\n    }\n    if (!base) {\n        return extension;\n    }\n    var result = __assign({}, base);\n    for (var _i = 0, _a = Object.entries(extension); _i < _a.length; _i++) {\n        var _b = _a[_i], key = _b[0], value = _b[1];\n        if (!value) {\n            delete result[key];\n            continue;\n        }\n        var baseValue = base[key];\n        if (!baseValue) {\n            result[key] = value;\n            continue;\n        }\n        result[key] = baseValue.concat(value);\n    }\n    return result;\n}\nexport var extendSyntaxDefinition = withNoNegative(mergeSection({\n    baseSyntax: replaceValueIfSpecified,\n    tag: withPositive(defaultXmlOptions, mergeSection({\n        wildcard: replaceValueIfSpecified\n    })),\n    ids: replaceValueIfSpecified,\n    classNames: replaceValueIfSpecified,\n    namespace: withPositive(defaultXmlOptions, mergeSection({\n        wildcard: replaceValueIfSpecified\n    })),\n    combinators: concatArray,\n    attributes: mergeSection({\n        operators: concatArray,\n        caseSensitivityModifiers: concatArray,\n        unknownCaseSensitivityModifiers: replaceValueIfSpecified\n    }),\n    pseudoClasses: mergeSection({\n        unknown: replaceValueIfSpecified,\n        definitions: mergeDefinitions\n    }),\n    pseudoElements: mergeSection({\n        unknown: replaceValueIfSpecified,\n        notation: replaceValueIfSpecified,\n        definitions: withMigration(function (definitions) { return (Array.isArray(definitions) ? { NoArgument: definitions } : definitions); }, mergeDefinitions)\n    })\n}));\nvar css1SyntaxDefinition = {\n    tag: {},\n    ids: true,\n    classNames: true,\n    combinators: [],\n    pseudoElements: {\n        unknown: 'reject',\n        notation: 'singleColon',\n        definitions: ['first-letter', 'first-line']\n    },\n    pseudoClasses: {\n        unknown: 'reject',\n        definitions: {\n            NoArgument: ['link', 'visited', 'active']\n        }\n    }\n};\nvar css2SyntaxDefinition = extendSyntaxDefinition(css1SyntaxDefinition, {\n    tag: { wildcard: true },\n    combinators: ['>', '+'],\n    attributes: {\n        unknownCaseSensitivityModifiers: 'reject',\n        operators: ['=', '~=', '|=']\n    },\n    pseudoElements: {\n        definitions: ['before', 'after']\n    },\n    pseudoClasses: {\n        unknown: 'reject',\n        definitions: {\n            NoArgument: ['hover', 'focus', 'first-child'],\n            String: ['lang']\n        }\n    }\n});\nvar selectors3SyntaxDefinition = extendSyntaxDefinition(css2SyntaxDefinition, {\n    namespace: {\n        wildcard: true\n    },\n    combinators: ['~'],\n    attributes: {\n        operators: ['^=', '$=', '*=']\n    },\n    pseudoElements: {\n        notation: 'both'\n    },\n    pseudoClasses: {\n        definitions: {\n            NoArgument: [\n                'root',\n                'last-child',\n                'first-of-type',\n                'last-of-type',\n                'only-child',\n                'only-of-type',\n                'empty',\n                'target',\n                'enabled',\n                'disabled',\n                'checked',\n                'indeterminate'\n            ],\n            Formula: ['nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type'],\n            Selector: ['not']\n        }\n    }\n});\nvar selectors4SyntaxDefinition = extendSyntaxDefinition(selectors3SyntaxDefinition, {\n    combinators: ['||'],\n    attributes: {\n        caseSensitivityModifiers: ['i', 'I', 's', 'S']\n    },\n    pseudoClasses: {\n        definitions: {\n            NoArgument: [\n                'any-link',\n                'local-link',\n                'target-within',\n                'scope',\n                'current',\n                'past',\n                'future',\n                'focus-within',\n                'focus-visible',\n                'read-write',\n                'read-only',\n                'placeholder-shown',\n                'default',\n                'valid',\n                'invalid',\n                'in-range',\n                'out-of-range',\n                'required',\n                'optional',\n                'blank',\n                'user-invalid'\n            ],\n            Formula: ['nth-col', 'nth-last-col'],\n            String: ['dir'],\n            FormulaOfSelector: ['nth-child', 'nth-last-child'],\n            Selector: ['current', 'is', 'where', 'has']\n        }\n    }\n});\nvar progressiveSyntaxDefinition = extendSyntaxDefinition(selectors4SyntaxDefinition, {\n    pseudoElements: {\n        unknown: 'accept'\n    },\n    pseudoClasses: {\n        unknown: 'accept'\n    },\n    attributes: {\n        unknownCaseSensitivityModifiers: 'accept'\n    }\n});\nexport var cssSyntaxDefinitions = {\n    css1: css1SyntaxDefinition,\n    css2: css2SyntaxDefinition,\n    css3: selectors3SyntaxDefinition,\n    'selectors-3': selectors3SyntaxDefinition,\n    'selectors-4': selectors4SyntaxDefinition,\n    latest: selectors4SyntaxDefinition,\n    progressive: progressiveSyntaxDefinition\n};\n","export function isIdentStart(c) {\n    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '-' || c === '_' || c === '\\\\' || c >= '\\u00a0';\n}\nexport function isIdent(c) {\n    return ((c >= 'a' && c <= 'z') ||\n        (c >= 'A' && c <= 'Z') ||\n        (c >= '0' && c <= '9') ||\n        c === '-' ||\n        c === '_' ||\n        c >= '\\u00a0');\n}\nexport function isHex(c) {\n    return (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9');\n}\nexport var identEscapeChars = {\n    '!': true,\n    '\"': true,\n    '#': true,\n    $: true,\n    '%': true,\n    '&': true,\n    \"'\": true,\n    '(': true,\n    ')': true,\n    '*': true,\n    '+': true,\n    ',': true,\n    '.': true,\n    '/': true,\n    ';': true,\n    '<': true,\n    '=': true,\n    '>': true,\n    '?': true,\n    '@': true,\n    '[': true,\n    '\\\\': true,\n    ']': true,\n    '^': true,\n    '`': true,\n    '{': true,\n    '|': true,\n    '}': true,\n    '~': true\n};\nexport var stringRenderEscapeChars = {\n    '\\n': true,\n    '\\r': true,\n    '\\t': true,\n    '\\f': true,\n    '\\v': true\n};\nexport var whitespaceChars = {\n    ' ': true,\n    '\\t': true,\n    '\\n': true,\n    '\\r': true,\n    '\\f': true\n};\nexport var quoteChars = {\n    '\"': true,\n    \"'\": true\n};\nexport var digitsChars = {\n    0: true,\n    1: true,\n    2: true,\n    3: true,\n    4: true,\n    5: true,\n    6: true,\n    7: true,\n    8: true,\n    9: true\n};\nexport var maxHexLength = 6;\nexport function escapeIdentifier(s) {\n    var len = s.length;\n    var result = '';\n    var i = 0;\n    while (i < len) {\n        var chr = s.charAt(i);\n        if (identEscapeChars[chr] || (chr === '-' && i === 1 && s.charAt(0) === '-')) {\n            result += '\\\\' + chr;\n        }\n        else {\n            if (chr === '-' ||\n                chr === '_' ||\n                (chr >= 'A' && chr <= 'Z') ||\n                (chr >= 'a' && chr <= 'z') ||\n                (chr >= '0' && chr <= '9' && i !== 0 && !(i === 1 && s.charAt(0) === '-'))) {\n                result += chr;\n            }\n            else {\n                var charCode = chr.charCodeAt(0);\n                if ((charCode & 0xf800) === 0xd800) {\n                    var extraCharCode = s.charCodeAt(i++);\n                    if ((charCode & 0xfc00) !== 0xd800 || (extraCharCode & 0xfc00) !== 0xdc00) {\n                        throw Error('UCS-2(decode): illegal sequence');\n                    }\n                    charCode = ((charCode & 0x3ff) << 10) + (extraCharCode & 0x3ff) + 0x10000;\n                }\n                result += '\\\\' + charCode.toString(16) + ' ';\n            }\n        }\n        i++;\n    }\n    return result.trim();\n}\nexport function escapeString(s) {\n    var len = s.length;\n    var result = '';\n    var i = 0;\n    while (i < len) {\n        var chr = s.charAt(i);\n        if (chr === '\"') {\n            chr = '\\\\\"';\n        }\n        else if (chr === '\\\\') {\n            chr = '\\\\\\\\';\n        }\n        else if (stringRenderEscapeChars[chr]) {\n            chr = '\\\\' + chr.charCodeAt(0).toString(16) + (i === len - 1 ? '' : ' ');\n        }\n        result += chr;\n        i++;\n    }\n    return \"\\\"\".concat(result, \"\\\"\");\n}\n","import { createMulticharIndex, createRegularIndex, emptyMulticharIndex, emptyRegularIndex } from './indexes.js';\nimport { calculatePseudoSignatures, defaultPseudoSignature, emptyPseudoSignatures } from './pseudo-signatures.js';\nimport { cssSyntaxDefinitions, extendSyntaxDefinition, getXmlOptions } from './syntax-definitions.js';\nimport { digitsChars, isHex, isIdent, isIdentStart, maxHexLength, quoteChars, whitespaceChars } from './utils.js';\nvar errorPrefix = \"css-selector-parser parse error: \";\n/**\n * Creates a parse function to be used later to parse CSS selectors.\n */\nexport function createParser(options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.syntax, syntax = _a === void 0 ? 'latest' : _a, substitutes = options.substitutes, _b = options.strict, strict = _b === void 0 ? true : _b;\n    var syntaxDefinition = typeof syntax === 'object' ? syntax : cssSyntaxDefinitions[syntax];\n    if (syntaxDefinition.baseSyntax) {\n        syntaxDefinition = extendSyntaxDefinition(cssSyntaxDefinitions[syntaxDefinition.baseSyntax], syntaxDefinition);\n    }\n    var _c = syntaxDefinition.tag\n        ? [true, Boolean(getXmlOptions(syntaxDefinition.tag).wildcard)]\n        : [false, false], tagNameEnabled = _c[0], tagNameWildcardEnabled = _c[1];\n    var idEnabled = Boolean(syntaxDefinition.ids);\n    var classNamesEnabled = Boolean(syntaxDefinition.classNames);\n    var namespaceEnabled = Boolean(syntaxDefinition.namespace);\n    var namespaceWildcardEnabled = syntaxDefinition.namespace &&\n        (syntaxDefinition.namespace === true || syntaxDefinition.namespace.wildcard === true);\n    if (namespaceEnabled && !tagNameEnabled) {\n        throw new Error(\"\".concat(errorPrefix, \"Namespaces cannot be enabled while tags are disabled.\"));\n    }\n    var substitutesEnabled = Boolean(substitutes);\n    var combinatorsIndex = syntaxDefinition.combinators\n        ? createMulticharIndex(syntaxDefinition.combinators)\n        : emptyMulticharIndex;\n    var _d = syntaxDefinition.attributes\n        ? [\n            true,\n            syntaxDefinition.attributes.operators\n                ? createMulticharIndex(syntaxDefinition.attributes.operators)\n                : emptyMulticharIndex,\n            syntaxDefinition.attributes.caseSensitivityModifiers\n                ? createRegularIndex(syntaxDefinition.attributes.caseSensitivityModifiers)\n                : emptyRegularIndex,\n            syntaxDefinition.attributes.unknownCaseSensitivityModifiers === 'accept'\n        ]\n        : [false, emptyMulticharIndex, emptyRegularIndex, false], attributesEnabled = _d[0], attributesOperatorsIndex = _d[1], attributesCaseSensitivityModifiers = _d[2], attributesAcceptUnknownCaseSensitivityModifiers = _d[3];\n    var attributesCaseSensitivityModifiersEnabled = attributesAcceptUnknownCaseSensitivityModifiers || Object.keys(attributesCaseSensitivityModifiers).length > 0;\n    var _e = syntaxDefinition.pseudoClasses\n        ? [\n            true,\n            syntaxDefinition.pseudoClasses.definitions\n                ? calculatePseudoSignatures(syntaxDefinition.pseudoClasses.definitions)\n                : emptyPseudoSignatures,\n            syntaxDefinition.pseudoClasses.unknown === 'accept'\n        ]\n        : [false, emptyPseudoSignatures, false], pseudoClassesEnabled = _e[0], pseudoClassesDefinitions = _e[1], pseudoClassesAcceptUnknown = _e[2];\n    var _f = syntaxDefinition.pseudoElements\n        ? [\n            true,\n            syntaxDefinition.pseudoElements.notation === 'singleColon' ||\n                syntaxDefinition.pseudoElements.notation === 'both',\n            !syntaxDefinition.pseudoElements.notation ||\n                syntaxDefinition.pseudoElements.notation === 'doubleColon' ||\n                syntaxDefinition.pseudoElements.notation === 'both',\n            syntaxDefinition.pseudoElements.definitions\n                ? calculatePseudoSignatures(Array.isArray(syntaxDefinition.pseudoElements.definitions)\n                    ? { NoArgument: syntaxDefinition.pseudoElements.definitions }\n                    : syntaxDefinition.pseudoElements.definitions)\n                : emptyPseudoSignatures,\n            syntaxDefinition.pseudoElements.unknown === 'accept'\n        ]\n        : [false, false, false, emptyPseudoSignatures, false], pseudoElementsEnabled = _f[0], pseudoElementsSingleColonNotationEnabled = _f[1], pseudoElementsDoubleColonNotationEnabled = _f[2], pseudoElementsDefinitions = _f[3], pseudoElementsAcceptUnknown = _f[4];\n    var str = '';\n    var l = str.length;\n    var pos = 0;\n    var chr = '';\n    var is = function (comparison) { return chr === comparison; };\n    var isTagStart = function () { return is('*') || isIdentStart(chr); };\n    var rewind = function (newPos) {\n        pos = newPos;\n        chr = str.charAt(pos);\n    };\n    var next = function () {\n        pos++;\n        chr = str.charAt(pos);\n    };\n    var readAndNext = function () {\n        var current = chr;\n        pos++;\n        chr = str.charAt(pos);\n        return current;\n    };\n    /** @throws ParserError */\n    function fail(errorMessage) {\n        var position = Math.min(l - 1, pos);\n        var error = new Error(\"\".concat(errorPrefix).concat(errorMessage, \" Pos: \").concat(position, \".\"));\n        error.position = position;\n        error.name = 'ParserError';\n        throw error;\n    }\n    function assert(condition, errorMessage) {\n        if (!condition) {\n            return fail(errorMessage);\n        }\n    }\n    var assertNonEof = function () {\n        assert(pos < l, 'Unexpected end of input.');\n    };\n    var isEof = function () { return pos >= l; };\n    var pass = function (character) {\n        assert(pos < l, \"Expected \\\"\".concat(character, \"\\\" but end of input reached.\"));\n        assert(chr === character, \"Expected \\\"\".concat(character, \"\\\" but \\\"\").concat(chr, \"\\\" found.\"));\n        pos++;\n        chr = str.charAt(pos);\n    };\n    function matchMulticharIndex(index) {\n        var match = matchMulticharIndexPos(index, pos);\n        if (match) {\n            pos += match.length;\n            chr = str.charAt(pos);\n            return match;\n        }\n    }\n    function matchMulticharIndexPos(index, subPos) {\n        var char = str.charAt(subPos);\n        var charIndex = index[char];\n        if (charIndex) {\n            var subMatch = matchMulticharIndexPos(charIndex.chars, subPos + 1);\n            if (subMatch) {\n                return subMatch;\n            }\n            if (charIndex.self) {\n                return charIndex.self;\n            }\n        }\n    }\n    /**\n     * @see https://www.w3.org/TR/css-syntax/#hex-digit-diagram\n     */\n    function parseHex() {\n        var hex = readAndNext();\n        var count = 1;\n        while (isHex(chr) && count < maxHexLength) {\n            hex += readAndNext();\n            count++;\n        }\n        skipSingleWhitespace();\n        return String.fromCharCode(parseInt(hex, 16));\n    }\n    /**\n     * @see https://www.w3.org/TR/css-syntax/#string-token-diagram\n     */\n    function parseString(quote) {\n        var result = '';\n        pass(quote);\n        while (pos < l) {\n            if (is(quote)) {\n                next();\n                return result;\n            }\n            else if (is('\\\\')) {\n                next();\n                if (is(quote)) {\n                    result += quote;\n                    next();\n                }\n                else if (chr === '\\n' || chr === '\\f') {\n                    next();\n                }\n                else if (chr === '\\r') {\n                    next();\n                    if (is('\\n')) {\n                        next();\n                    }\n                }\n                else if (isHex(chr)) {\n                    result += parseHex();\n                }\n                else {\n                    result += chr;\n                    next();\n                }\n            }\n            else {\n                result += chr;\n                next();\n            }\n        }\n        return result;\n    }\n    /**\n     * @see https://www.w3.org/TR/css-syntax/#ident-token-diagram\n     */\n    function parseIdentifier() {\n        if (!isIdentStart(chr)) {\n            return null;\n        }\n        var result = '';\n        while (is('-')) {\n            result += chr;\n            next();\n        }\n        if (result === '-' && !isIdent(chr) && !is('\\\\')) {\n            fail('Identifiers cannot consist of a single hyphen.');\n        }\n        if (strict && result.length >= 2) {\n            // Checking this only for strict mode since browsers work fine with these identifiers.\n            fail('Identifiers cannot start with two hyphens with strict mode on.');\n        }\n        if (digitsChars[chr]) {\n            fail('Identifiers cannot start with hyphens followed by digits.');\n        }\n        while (pos < l) {\n            if (isIdent(chr)) {\n                result += readAndNext();\n            }\n            else if (is('\\\\')) {\n                next();\n                assertNonEof();\n                if (isHex(chr)) {\n                    result += parseHex();\n                }\n                else {\n                    result += readAndNext();\n                }\n            }\n            else {\n                break;\n            }\n        }\n        return result;\n    }\n    function parsePseudoClassString() {\n        var result = '';\n        while (pos < l) {\n            if (is(')')) {\n                break;\n            }\n            else if (is('\\\\')) {\n                next();\n                if (isEof() && !strict) {\n                    return (result + '\\\\').trim();\n                }\n                assertNonEof();\n                if (isHex(chr)) {\n                    result += parseHex();\n                }\n                else {\n                    result += readAndNext();\n                }\n            }\n            else {\n                result += readAndNext();\n            }\n        }\n        return result.trim();\n    }\n    function skipSingleWhitespace() {\n        if (chr === ' ' || chr === '\\t' || chr === '\\f' || chr === '\\n') {\n            next();\n            return;\n        }\n        if (chr === '\\r') {\n            next();\n        }\n        if (chr === '\\n') {\n            next();\n        }\n    }\n    function skipWhitespace() {\n        while (whitespaceChars[chr]) {\n            next();\n        }\n    }\n    function parseSelector(relative) {\n        if (relative === void 0) { relative = false; }\n        skipWhitespace();\n        var rules = [parseRule(relative)];\n        while (is(',')) {\n            next();\n            skipWhitespace();\n            rules.push(parseRule(relative));\n        }\n        return {\n            type: 'Selector',\n            rules: rules\n        };\n    }\n    function parseAttribute() {\n        pass('[');\n        skipWhitespace();\n        var attr;\n        if (is('|')) {\n            assert(namespaceEnabled, 'Namespaces are not enabled.');\n            next();\n            var name_1 = parseIdentifier();\n            assert(name_1, 'Expected attribute name.');\n            attr = {\n                type: 'Attribute',\n                name: name_1,\n                namespace: { type: 'NoNamespace' }\n            };\n        }\n        else if (is('*')) {\n            assert(namespaceEnabled, 'Namespaces are not enabled.');\n            assert(namespaceWildcardEnabled, 'Wildcard namespace is not enabled.');\n            next();\n            pass('|');\n            var name_2 = parseIdentifier();\n            assert(name_2, 'Expected attribute name.');\n            attr = {\n                type: 'Attribute',\n                name: name_2,\n                namespace: { type: 'WildcardNamespace' }\n            };\n        }\n        else {\n            var identifier = parseIdentifier();\n            assert(identifier, 'Expected attribute name.');\n            attr = {\n                type: 'Attribute',\n                name: identifier\n            };\n            if (is('|')) {\n                var savedPos = pos;\n                next();\n                if (isIdentStart(chr)) {\n                    assert(namespaceEnabled, 'Namespaces are not enabled.');\n                    var name_3 = parseIdentifier();\n                    assert(name_3, 'Expected attribute name.');\n                    attr = {\n                        type: 'Attribute',\n                        name: name_3,\n                        namespace: { type: 'NamespaceName', name: identifier }\n                    };\n                }\n                else {\n                    rewind(savedPos);\n                }\n            }\n        }\n        assert(attr.name, 'Expected attribute name.');\n        skipWhitespace();\n        if (isEof() && !strict) {\n            return attr;\n        }\n        if (is(']')) {\n            next();\n        }\n        else {\n            attr.operator = matchMulticharIndex(attributesOperatorsIndex);\n            assert(attr.operator, 'Expected a valid attribute selector operator.');\n            skipWhitespace();\n            assertNonEof();\n            if (quoteChars[chr]) {\n                attr.value = {\n                    type: 'String',\n                    value: parseString(chr)\n                };\n            }\n            else if (substitutesEnabled && is('$')) {\n                next();\n                var name_4 = parseIdentifier();\n                assert(name_4, 'Expected substitute name.');\n                attr.value = {\n                    type: 'Substitution',\n                    name: name_4\n                };\n            }\n            else {\n                var value = parseIdentifier();\n                assert(value, 'Expected attribute value.');\n                attr.value = {\n                    type: 'String',\n                    value: value\n                };\n            }\n            skipWhitespace();\n            if (isEof() && !strict) {\n                return attr;\n            }\n            if (!is(']')) {\n                var caseSensitivityModifier = parseIdentifier();\n                assert(caseSensitivityModifier, 'Expected end of attribute selector.');\n                attr.caseSensitivityModifier = caseSensitivityModifier;\n                assert(attributesCaseSensitivityModifiersEnabled, 'Attribute case sensitivity modifiers are not enabled.');\n                assert(attributesAcceptUnknownCaseSensitivityModifiers ||\n                    attributesCaseSensitivityModifiers[attr.caseSensitivityModifier], 'Unknown attribute case sensitivity modifier.');\n                skipWhitespace();\n                if (isEof() && !strict) {\n                    return attr;\n                }\n            }\n            pass(']');\n        }\n        return attr;\n    }\n    function parseNumber() {\n        var result = '';\n        while (digitsChars[chr]) {\n            result += readAndNext();\n        }\n        assert(result !== '', 'Formula parse error.');\n        return parseInt(result);\n    }\n    var isNumberStart = function () { return is('-') || is('+') || digitsChars[chr]; };\n    function parseFormula() {\n        if (is('e') || is('o')) {\n            var ident = parseIdentifier();\n            if (ident === 'even') {\n                skipWhitespace();\n                return [2, 0];\n            }\n            if (ident === 'odd') {\n                skipWhitespace();\n                return [2, 1];\n            }\n        }\n        var firstNumber = null;\n        var firstNumberMultiplier = 1;\n        if (is('-')) {\n            next();\n            firstNumberMultiplier = -1;\n        }\n        if (isNumberStart()) {\n            if (is('+')) {\n                next();\n            }\n            firstNumber = parseNumber();\n            if (!is('\\\\') && !is('n')) {\n                return [0, firstNumber * firstNumberMultiplier];\n            }\n        }\n        if (firstNumber === null) {\n            firstNumber = 1;\n        }\n        firstNumber *= firstNumberMultiplier;\n        var identifier;\n        if (is('\\\\')) {\n            next();\n            if (isHex(chr)) {\n                identifier = parseHex();\n            }\n            else {\n                identifier = readAndNext();\n            }\n        }\n        else {\n            identifier = readAndNext();\n        }\n        assert(identifier === 'n', 'Formula parse error: expected \"n\".');\n        skipWhitespace();\n        if (is('+') || is('-')) {\n            var sign = is('+') ? 1 : -1;\n            next();\n            skipWhitespace();\n            return [firstNumber, sign * parseNumber()];\n        }\n        else {\n            return [firstNumber, 0];\n        }\n    }\n    function parsePseudoArgument(pseudoName, type, signature) {\n        var argument;\n        if (is('(')) {\n            next();\n            skipWhitespace();\n            if (substitutesEnabled && is('$')) {\n                next();\n                var name_5 = parseIdentifier();\n                assert(name_5, 'Expected substitute name.');\n                argument = {\n                    type: 'Substitution',\n                    name: name_5\n                };\n            }\n            else if (signature.type === 'String') {\n                argument = {\n                    type: 'String',\n                    value: parsePseudoClassString()\n                };\n                assert(argument.value, \"Expected \".concat(type, \" argument value.\"));\n            }\n            else if (signature.type === 'Selector') {\n                argument = parseSelector(true);\n            }\n            else if (signature.type === 'Formula') {\n                var _a = parseFormula(), a = _a[0], b = _a[1];\n                argument = {\n                    type: 'Formula',\n                    a: a,\n                    b: b\n                };\n                if (signature.ofSelector) {\n                    skipWhitespace();\n                    if (is('o') || is('\\\\')) {\n                        var ident = parseIdentifier();\n                        assert(ident === 'of', 'Formula of selector parse error.');\n                        skipWhitespace();\n                        argument = {\n                            type: 'FormulaOfSelector',\n                            a: a,\n                            b: b,\n                            selector: parseRule()\n                        };\n                    }\n                }\n            }\n            else {\n                return fail(\"Invalid \".concat(type, \" signature.\"));\n            }\n            skipWhitespace();\n            if (isEof() && !strict) {\n                return argument;\n            }\n            pass(')');\n        }\n        else {\n            assert(signature.optional, \"Argument is required for \".concat(type, \" \\\"\").concat(pseudoName, \"\\\".\"));\n        }\n        return argument;\n    }\n    function parseTagName() {\n        if (is('*')) {\n            assert(tagNameWildcardEnabled, 'Wildcard tag name is not enabled.');\n            next();\n            return { type: 'WildcardTag' };\n        }\n        else if (isIdentStart(chr)) {\n            assert(tagNameEnabled, 'Tag names are not enabled.');\n            var name_6 = parseIdentifier();\n            assert(name_6, 'Expected tag name.');\n            return {\n                type: 'TagName',\n                name: name_6\n            };\n        }\n        else {\n            return fail('Expected tag name.');\n        }\n    }\n    function parseTagNameWithNamespace() {\n        if (is('*')) {\n            var savedPos = pos;\n            next();\n            if (!is('|')) {\n                rewind(savedPos);\n                return parseTagName();\n            }\n            next();\n            if (!isTagStart()) {\n                rewind(savedPos);\n                return parseTagName();\n            }\n            assert(namespaceEnabled, 'Namespaces are not enabled.');\n            assert(namespaceWildcardEnabled, 'Wildcard namespace is not enabled.');\n            var tagName = parseTagName();\n            tagName.namespace = { type: 'WildcardNamespace' };\n            return tagName;\n        }\n        else if (is('|')) {\n            assert(namespaceEnabled, 'Namespaces are not enabled.');\n            next();\n            var tagName = parseTagName();\n            tagName.namespace = { type: 'NoNamespace' };\n            return tagName;\n        }\n        else if (isIdentStart(chr)) {\n            var identifier = parseIdentifier();\n            assert(identifier, 'Expected tag name.');\n            if (!is('|')) {\n                assert(tagNameEnabled, 'Tag names are not enabled.');\n                return {\n                    type: 'TagName',\n                    name: identifier\n                };\n            }\n            var savedPos = pos;\n            next();\n            if (!isTagStart()) {\n                rewind(savedPos);\n                return {\n                    type: 'TagName',\n                    name: identifier\n                };\n            }\n            assert(namespaceEnabled, 'Namespaces are not enabled.');\n            var tagName = parseTagName();\n            tagName.namespace = { type: 'NamespaceName', name: identifier };\n            return tagName;\n        }\n        else {\n            return fail('Expected tag name.');\n        }\n    }\n    function parseRule(relative) {\n        var _a, _b;\n        if (relative === void 0) { relative = false; }\n        var rule = { type: 'Rule', items: [] };\n        if (relative) {\n            var combinator = matchMulticharIndex(combinatorsIndex);\n            if (combinator) {\n                rule.combinator = combinator;\n                skipWhitespace();\n            }\n        }\n        while (pos < l) {\n            if (isTagStart()) {\n                assert(rule.items.length === 0, 'Unexpected tag/namespace start.');\n                rule.items.push(parseTagNameWithNamespace());\n            }\n            else if (is('|')) {\n                var savedPos = pos;\n                next();\n                if (isTagStart()) {\n                    assert(rule.items.length === 0, 'Unexpected tag/namespace start.');\n                    rewind(savedPos);\n                    rule.items.push(parseTagNameWithNamespace());\n                }\n                else {\n                    rewind(savedPos);\n                    break;\n                }\n            }\n            else if (is('.')) {\n                assert(classNamesEnabled, 'Class names are not enabled.');\n                next();\n                var className = parseIdentifier();\n                assert(className, 'Expected class name.');\n                rule.items.push({ type: 'ClassName', name: className });\n            }\n            else if (is('#')) {\n                assert(idEnabled, 'IDs are not enabled.');\n                next();\n                var idName = parseIdentifier();\n                assert(idName, 'Expected ID name.');\n                rule.items.push({ type: 'Id', name: idName });\n            }\n            else if (is('[')) {\n                assert(attributesEnabled, 'Attributes are not enabled.');\n                rule.items.push(parseAttribute());\n            }\n            else if (is(':')) {\n                var isDoubleColon = false;\n                var isPseudoElement = false;\n                next();\n                if (is(':')) {\n                    assert(pseudoElementsEnabled, 'Pseudo elements are not enabled.');\n                    assert(pseudoElementsDoubleColonNotationEnabled, 'Pseudo elements double colon notation is not enabled.');\n                    isDoubleColon = true;\n                    next();\n                }\n                var pseudoName = parseIdentifier();\n                assert(isDoubleColon || pseudoName, 'Expected pseudo-class name.');\n                assert(!isDoubleColon || pseudoName, 'Expected pseudo-element name.');\n                assert(pseudoName, 'Expected pseudo-class name.');\n                assert(!isDoubleColon ||\n                    pseudoElementsAcceptUnknown ||\n                    Object.prototype.hasOwnProperty.call(pseudoElementsDefinitions, pseudoName), \"Unknown pseudo-element \\\"\".concat(pseudoName, \"\\\".\"));\n                isPseudoElement =\n                    pseudoElementsEnabled &&\n                        (isDoubleColon ||\n                            (!isDoubleColon &&\n                                pseudoElementsSingleColonNotationEnabled &&\n                                Object.prototype.hasOwnProperty.call(pseudoElementsDefinitions, pseudoName)));\n                if (isPseudoElement) {\n                    var signature = (_a = pseudoElementsDefinitions[pseudoName]) !== null && _a !== void 0 ? _a : (pseudoElementsAcceptUnknown && defaultPseudoSignature);\n                    var pseudoElement = {\n                        type: 'PseudoElement',\n                        name: pseudoName\n                    };\n                    var argument = parsePseudoArgument(pseudoName, 'pseudo-element', signature);\n                    if (argument) {\n                        assert(argument.type !== 'Formula' && argument.type !== 'FormulaOfSelector', 'Pseudo-elements cannot have formula argument.');\n                        pseudoElement.argument = argument;\n                    }\n                    rule.items.push(pseudoElement);\n                }\n                else {\n                    assert(pseudoClassesEnabled, 'Pseudo-classes are not enabled.');\n                    var signature = (_b = pseudoClassesDefinitions[pseudoName]) !== null && _b !== void 0 ? _b : (pseudoClassesAcceptUnknown && defaultPseudoSignature);\n                    assert(signature, \"Unknown pseudo-class: \\\"\".concat(pseudoName, \"\\\".\"));\n                    var argument = parsePseudoArgument(pseudoName, 'pseudo-class', signature);\n                    var pseudoClass = {\n                        type: 'PseudoClass',\n                        name: pseudoName\n                    };\n                    if (argument) {\n                        pseudoClass.argument = argument;\n                    }\n                    rule.items.push(pseudoClass);\n                }\n            }\n            else {\n                break;\n            }\n        }\n        if (rule.items.length === 0) {\n            if (isEof()) {\n                return fail('Expected rule but end of input reached.');\n            }\n            else {\n                return fail(\"Expected rule but \\\"\".concat(chr, \"\\\" found.\"));\n            }\n        }\n        skipWhitespace();\n        if (!isEof() && !is(',') && !is(')')) {\n            var combinator = matchMulticharIndex(combinatorsIndex);\n            skipWhitespace();\n            rule.nestedRule = parseRule();\n            rule.nestedRule.combinator = combinator;\n        }\n        return rule;\n    }\n    return function (input) {\n        // noinspection SuspiciousTypeOfGuard\n        if (typeof input !== 'string') {\n            throw new Error(\"\".concat(errorPrefix, \"Expected string input.\"));\n        }\n        str = input;\n        l = str.length;\n        pos = 0;\n        chr = str.charAt(0);\n        return parseSelector();\n    };\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nfunction astMethods(type) {\n    return function (generatorName, checkerName) {\n        var _a;\n        return (_a = {},\n            _a[generatorName] = function (props) { return (__assign({ type: type }, props)); },\n            _a[checkerName] = function (entity) {\n                return typeof entity === 'object' && entity !== null && entity.type === type;\n            },\n            _a);\n    };\n}\n/**\n * AST structure generators and matchers.\n * For instance, `ast.selector({rules: [...]})` creates AstSelector and `ast.isSelector(...)` checks if\n * AstSelector was specified.\n *\n * @example\n *\n * // Represents CSS selector: ns|div#user-34.user.user-active[role=\"button\"]:lang(en)::before > *\n * const selector = ast.selector({\n *     rules: [\n *         ast.rule({\n *             items: [\n *                 ast.tagName({name: 'div', namespace: ast.namespaceName({name: 'ns'})}),\n *                 ast.id({name: 'user-34'}),\n *                 ast.className({name: 'user'}),\n *                 ast.className({name: 'user-active'}),\n *                 ast.attribute({\n *                     name: 'role',\n *                     operator: '=',\n *                     value: ast.string({value: 'button'})\n *                 }),\n *                 ast.pseudoClass({\n *                     name: 'lang',\n *                     argument: ast.string({value: 'en'})\n *                 }),\n *                 ast.pseudoElement({name: 'before'})\n *             ],\n *             nestedRule: ast.rule({combinator: '>', items: [ast.wildcardTag()]})\n *         })\n *     ]\n * });\n * console.log(ast.isSelector(selector)); // prints true\n * console.log(ast.isRule(selector)); // prints false\n */\nexport var ast = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, astMethods('Selector')('selector', 'isSelector')), astMethods('Rule')('rule', 'isRule')), astMethods('TagName')('tagName', 'isTagName')), astMethods('Id')('id', 'isId')), astMethods('ClassName')('className', 'isClassName')), astMethods('WildcardTag')('wildcardTag', 'isWildcardTag')), astMethods('NamespaceName')('namespaceName', 'isNamespaceName')), astMethods('WildcardNamespace')('wildcardNamespace', 'isWildcardNamespace')), astMethods('NoNamespace')('noNamespace', 'isNoNamespace')), astMethods('Attribute')('attribute', 'isAttribute')), astMethods('PseudoClass')('pseudoClass', 'isPseudoClass')), astMethods('PseudoElement')('pseudoElement', 'isPseudoElement')), astMethods('String')('string', 'isString')), astMethods('Formula')('formula', 'isFormula')), astMethods('FormulaOfSelector')('formulaOfSelector', 'isFormulaOfSelector')), astMethods('Substitution')('substitution', 'isSubstitution'));\n","/**\n * @typedef {import('css-selector-parser').AstSelector} AstSelector\n */\n\nimport {createParser} from 'css-selector-parser'\n\nconst cssSelectorParse = createParser({syntax: 'selectors-4'})\n\n/**\n * @param {string} selector\n *   Selector to parse.\n * @returns {AstSelector}\n *   Parsed selector.\n */\nexport function parse(selector) {\n  if (typeof selector !== 'string') {\n    throw new TypeError('Expected `string` as selector, not `' + selector + '`')\n  }\n\n  return cssSelectorParse(selector)\n}\n","const rtlRange = '\\u0591-\\u07FF\\uFB1D-\\uFDFD\\uFE70-\\uFEFC'\nconst ltrRange =\n  'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6' +\n  '\\u00F8-\\u02B8\\u0300-\\u0590\\u0800-\\u1FFF\\u200E\\u2C00-\\uFB1C' +\n  '\\uFE00-\\uFE6F\\uFEFD-\\uFFFF'\n\n/* eslint-disable no-misleading-character-class */\nconst rtl = new RegExp('^[^' + ltrRange + ']*[' + rtlRange + ']')\nconst ltr = new RegExp('^[^' + rtlRange + ']*[' + ltrRange + ']')\n/* eslint-enable no-misleading-character-class */\n\n/**\n * Detect the direction of text: left-to-right, right-to-left, or neutral\n *\n * @param {string} value\n * @returns {'rtl'|'ltr'|'neutral'}\n */\nexport function direction(value) {\n  const source = String(value || '')\n  return rtl.test(source) ? 'rtl' : ltr.test(source) ? 'ltr' : 'neutral'\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Nodes} Nodes\n *\n * @typedef {import('unist-util-visit').Visitor<ElementContent>} Visitor\n *\n * @typedef {import('./index.js').Direction} Direction\n * @typedef {import('./index.js').State} State\n */\n\nimport {direction} from 'direction'\nimport {toString} from 'hast-util-to-string'\nimport {svg} from 'property-information'\nimport {EXIT, SKIP, visit} from 'unist-util-visit'\n\n/**\n * Enter a node.\n *\n * The caller is responsible for calling the return value `exit`.\n *\n * @param {State} state\n *   Current state.\n *\n *   Will be mutated: `exit` undos the changes.\n * @param {Nodes} node\n *   Node to enter.\n * @returns {() => undefined}\n *   Call to exit.\n */\n// eslint-disable-next-line complexity\nexport function enterState(state, node) {\n  const schema = state.schema\n  const language = state.language\n  const currentDirection = state.direction\n  const editableOrEditingHost = state.editableOrEditingHost\n  /** @type {Direction | undefined} */\n  let dirInferred\n\n  if (node.type === 'element') {\n    const lang = node.properties.xmlLang || node.properties.lang\n    const type = node.properties.type || 'text'\n    const dir = dirProperty(node)\n\n    if (lang !== null && lang !== undefined) {\n      state.language = String(lang)\n    }\n\n    if (schema && schema.space === 'html') {\n      if (node.properties.contentEditable === 'true') {\n        state.editableOrEditingHost = true\n      }\n\n      if (node.tagName === 'svg') {\n        state.schema = svg\n      }\n\n      // See: <https://html.spec.whatwg.org/#the-directionality>.\n      // Explicit `[dir=rtl]`.\n      if (dir === 'rtl') {\n        dirInferred = dir\n      } else if (\n        // Explicit `[dir=ltr]`.\n        dir === 'ltr' ||\n        // HTML with an invalid or no `[dir]`.\n        (dir !== 'auto' && node.tagName === 'html') ||\n        // `input[type=tel]` with an invalid or no `[dir]`.\n        (dir !== 'auto' && node.tagName === 'input' && type === 'tel')\n      ) {\n        dirInferred = 'ltr'\n        // `[dir=auto]` or `bdi` with an invalid or no `[dir]`.\n      } else if (dir === 'auto' || node.tagName === 'bdi') {\n        if (node.tagName === 'textarea') {\n          // Check contents of `<textarea>`.\n          dirInferred = dirBidi(toString(node))\n        } else if (\n          node.tagName === 'input' &&\n          (type === 'email' ||\n            type === 'search' ||\n            type === 'tel' ||\n            type === 'text')\n        ) {\n          // Check value of `<input>`.\n          dirInferred = node.properties.value\n            ? dirBidi(String(node.properties.value))\n            : 'ltr'\n        } else {\n          // Check text nodes in `node`.\n          visit(node, inferDirectionality)\n        }\n      }\n\n      if (dirInferred) {\n        state.direction = dirInferred\n      }\n    }\n    // Turn off editing mode in non-HTML spaces.\n    else if (state.editableOrEditingHost) {\n      state.editableOrEditingHost = false\n    }\n  }\n\n  return reset\n\n  /**\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function reset() {\n    state.schema = schema\n    state.language = language\n    state.direction = currentDirection\n    state.editableOrEditingHost = editableOrEditingHost\n  }\n\n  /** @type {Visitor} */\n  function inferDirectionality(child) {\n    if (child.type === 'text') {\n      dirInferred = dirBidi(child.value)\n      return dirInferred ? EXIT : undefined\n    }\n\n    if (\n      child !== node &&\n      child.type === 'element' &&\n      (child.tagName === 'bdi' ||\n        child.tagName === 'script' ||\n        child.tagName === 'style' ||\n        child.tagName === 'textare' ||\n        dirProperty(child))\n    ) {\n      return SKIP\n    }\n  }\n}\n\n/**\n * See `wooorm/direction`.\n *\n * @param {string} value\n *   Value to check.\n * @returns {Exclude<Direction, 'auto'> | undefined}\n *   Directionality.\n */\nfunction dirBidi(value) {\n  const result = direction(value)\n  return result === 'neutral' ? undefined : result\n}\n\n/**\n * @param {ElementContent} node\n *   Node to check.\n * @returns {Direction | undefined}\n *   Directionality.\n */\nfunction dirProperty(node) {\n  const value =\n    node.type === 'element' && typeof node.properties.dir === 'string'\n      ? node.properties.dir.toLowerCase()\n      : undefined\n\n  return value === 'auto' || value === 'ltr' || value === 'rtl'\n    ? value\n    : undefined\n}\n","/**\n * @typedef {import('css-selector-parser').AstAttribute} AstAttribute\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n *\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {find} from 'property-information'\nimport * as spaces from 'space-separated-tokens'\n\n/**\n * @param {AstAttribute} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {Schema} schema\n *   Schema of element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nexport function attribute(query, element, schema) {\n  const info = find(schema, query.name)\n  const propertyValue = element.properties[info.property]\n  let value = normalizeValue(propertyValue, info)\n\n  // Exists.\n  if (!query.value) {\n    return value !== undefined\n  }\n\n  assert(query.value.type === 'String', 'expected plain string')\n  let key = query.value.value\n\n  // Case-sensitivity.\n  if (query.caseSensitivityModifier === 'i') {\n    key = key.toLowerCase()\n\n    if (value) {\n      value = value.toLowerCase()\n    }\n  }\n\n  if (value !== undefined) {\n    switch (query.operator) {\n      // Exact.\n      case '=': {\n        return key === value\n      }\n\n      // Ends.\n      case '$=': {\n        return key === value.slice(-key.length)\n      }\n\n      // Contains.\n      case '*=': {\n        return value.includes(key)\n      }\n\n      // Begins.\n      case '^=': {\n        return key === value.slice(0, key.length)\n      }\n\n      // Exact or prefix.\n      case '|=': {\n        return (\n          key === value ||\n          (key === value.slice(0, key.length) &&\n            value.charAt(key.length) === '-')\n        )\n      }\n\n      // Space-separated list.\n      case '~=': {\n        return (\n          // For all other values (including comma-separated lists), return whether this\n          // is an exact match.\n          key === value ||\n          // If this is a space-separated list, and the query is contained in it, return\n          // true.\n          spaces.parse(value).includes(key)\n        )\n      }\n      // Other values are not yet supported by CSS.\n      // No default\n    }\n  }\n\n  return false\n}\n\n/**\n *\n * @param {Properties[keyof Properties]} value\n * @param {Info} info\n * @returns {string | undefined}\n */\nfunction normalizeValue(value, info) {\n  if (value === null || value === undefined) {\n    // Empty.\n  } else if (typeof value === 'boolean') {\n    if (value) {\n      return info.attribute\n    }\n  } else if (Array.isArray(value)) {\n    if (value.length > 0) {\n      return (info.commaSeparated ? commas : spaces.stringify)(value)\n    }\n  } else {\n    return String(value)\n  }\n}\n","/**\n * @typedef {import('css-selector-parser').AstClassName} AstClassName\n * @typedef {import('hast').Element} Element\n */\n\n/** @type {Array<never>} */\nconst emptyClassNames = []\n\n/**\n * Check whether an element has all class names.\n *\n * @param {AstClassName} query\n *   AST rule (with `classNames`).\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nexport function className(query, element) {\n  // Assume array.\n  const value = /** @type {Readonly<Array<string>>} */ (\n    element.properties.className || emptyClassNames\n  )\n\n  return value.includes(query.name)\n}\n","/**\n * @typedef {import('css-selector-parser').AstId} AstId\n *\n * @typedef {import('hast').Element} Element\n */\n\n// Workaround to show references to above types in VS Code.\n''\n\n/**\n * Check whether an element has an ID.\n *\n * @param {AstId} query\n *   AST rule (with `ids`).\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nexport function id(query, element) {\n  return element.properties.id === query.name\n}\n","/**\n * @typedef {import('css-selector-parser').AstTagName} AstTagName\n *\n * @typedef {import('hast').Element} Element\n */\n\n// Workaround to show references to above types in VS Code.\n''\n\n/**\n * Check whether an element has a tag name.\n *\n * @param {AstTagName} query\n *   AST rule (with `tag`).\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nexport function name(query, element) {\n  return query.name === element.tagName\n}\n","/**\n * See <https://tools.ietf.org/html/rfc4647#section-3.1>\n * for more info on the algorithms.\n */\n\n/**\n * @typedef {string} Tag\n *   BCP-47 tag.\n * @typedef {Array<Tag>} Tags\n *   List of BCP-47 tags.\n * @typedef {string} Range\n *   RFC 4647 range.\n * @typedef {Array<Range>} Ranges\n *   List of RFC 4647 range.\n *\n * @callback Check\n *   An internal check.\n * @param {Tag} tag\n *   BCP-47 tag.\n * @param {Range} range\n *   RFC 4647 range.\n * @returns {boolean}\n *   Whether the range matches the tag.\n *\n * @typedef {FilterOrLookup<true>} Filter\n *   Filter: yields all tags that match a range.\n * @typedef {FilterOrLookup<false>} Lookup\n *   Lookup: yields the best tag that matches a range.\n */\n\n/**\n * @template {boolean} IsFilter\n *   Whether to filter or perform a lookup.\n * @callback FilterOrLookup\n *   A check.\n * @param {Tag|Tags} tags\n *   One or more BCP-47 tags.\n * @param {Range|Ranges|undefined} [ranges='*']\n *   One or more RFC 4647 ranges.\n * @returns {IsFilter extends true ? Tags : Tag|undefined}\n *   Result.\n */\n\n/**\n * Factory to perform a filter or a lookup.\n *\n * This factory creates a function that accepts a list of tags and a list of\n * ranges, and contains logic to exit early for lookups.\n * `check` just has to deal with one tag and one range.\n * This match function iterates over ranges, and for each range,\n * iterates over tags.\n * That way, earlier ranges matching any tag have precedence over later ranges.\n *\n * @template {boolean} IsFilter\n * @param {Check} check\n *   A check.\n * @param {IsFilter} filter\n *   Whether to filter or perform a lookup.\n * @returns {FilterOrLookup<IsFilter>}\n *   Filter or lookup.\n */\nfunction factory(check, filter) {\n  /**\n   * @param {Tag|Tags} tags\n   *   One or more BCP-47 tags.\n   * @param {Range|Ranges|undefined} [ranges='*']\n   *   One or more RFC 4647 ranges.\n   * @returns {IsFilter extends true ? Tags : Tag|undefined}\n   *   Result.\n   */\n  return function (tags, ranges) {\n    let left = cast(tags, 'tag')\n    const right = cast(\n      ranges === null || ranges === undefined ? '*' : ranges,\n      'range'\n    )\n    /** @type {Tags} */\n    const matches = []\n    let rightIndex = -1\n\n    while (++rightIndex < right.length) {\n      const range = right[rightIndex].toLowerCase()\n\n      // Ignore wildcards in lookup mode.\n      if (!filter && range === '*') continue\n\n      let leftIndex = -1\n      /** @type {Tags} */\n      const next = []\n\n      while (++leftIndex < left.length) {\n        if (check(left[leftIndex].toLowerCase(), range)) {\n          // Exit if this is a lookup and we have a match.\n          if (!filter) {\n            return /** @type {IsFilter extends true ? Tags : Tag|undefined} */ (\n              left[leftIndex]\n            )\n          }\n\n          matches.push(left[leftIndex])\n        } else {\n          next.push(left[leftIndex])\n        }\n      }\n\n      left = next\n    }\n\n    // If this is a filter, return the list.  If it’s a lookup, we didn’t find\n    // a match, so return `undefined`.\n    return /** @type {IsFilter extends true ? Tags : Tag|undefined} */ (\n      filter ? matches : undefined\n    )\n  }\n}\n\n/**\n * Basic Filtering (Section 3.3.1) matches a language priority list consisting\n * of basic language ranges (Section 2.1) to sets of language tags.\n *\n * @param {Tag|Tags} tags\n *   One or more BCP-47 tags.\n * @param {Range|Ranges|undefined} [ranges='*']\n *   One or more RFC 4647 ranges.\n * @returns {Tags}\n *   List of BCP-47 tags.\n */\nexport const basicFilter = factory(function (tag, range) {\n  return range === '*' || tag === range || tag.includes(range + '-')\n}, true)\n\n/**\n * Extended Filtering (Section 3.3.2) matches a language priority list\n * consisting of extended language ranges (Section 2.2) to sets of language\n * tags.\n *\n * @param {Tag|Tags} tags\n *   One or more BCP-47 tags.\n * @param {Range|Ranges|undefined} [ranges='*']\n *   One or more RFC 4647 ranges.\n * @returns {Tags}\n *   List of BCP-47 tags.\n */\nexport const extendedFilter = factory(function (tag, range) {\n  // 3.3.2.1\n  const left = tag.split('-')\n  const right = range.split('-')\n  let leftIndex = 0\n  let rightIndex = 0\n\n  // 3.3.2.2\n  if (right[rightIndex] !== '*' && left[leftIndex] !== right[rightIndex]) {\n    return false\n  }\n\n  leftIndex++\n  rightIndex++\n\n  // 3.3.2.3\n  while (rightIndex < right.length) {\n    // 3.3.2.3.A\n    if (right[rightIndex] === '*') {\n      rightIndex++\n      continue\n    }\n\n    // 3.3.2.3.B\n    if (!left[leftIndex]) return false\n\n    // 3.3.2.3.C\n    if (left[leftIndex] === right[rightIndex]) {\n      leftIndex++\n      rightIndex++\n      continue\n    }\n\n    // 3.3.2.3.D\n    if (left[leftIndex].length === 1) return false\n\n    // 3.3.2.3.E\n    leftIndex++\n  }\n\n  // 3.3.2.4\n  return true\n}, true)\n\n/**\n * Lookup (Section 3.4) matches a language priority list consisting of basic\n * language ranges to sets of language tags to find the one exact language tag\n * that best matches the range.\n *\n * @param {Tag|Tags} tags\n *   One or more BCP-47 tags.\n * @param {Range|Ranges|undefined} [ranges='*']\n *   One or more RFC 4647 ranges.\n * @returns {Tag|undefined}\n *   BCP-47 tag.\n */\nexport const lookup = factory(function (tag, range) {\n  let right = range\n\n  /* eslint-disable-next-line no-constant-condition */\n  while (true) {\n    if (right === '*' || tag === right) return true\n\n    let index = right.lastIndexOf('-')\n\n    if (index < 0) return false\n\n    if (right.charAt(index - 2) === '-') index -= 2\n\n    right = right.slice(0, index)\n  }\n}, false)\n\n/**\n * Validate tags or ranges, and cast them to arrays.\n *\n * @param {string|Array<string>} values\n * @param {string} name\n * @returns {Array<string>}\n */\nfunction cast(values, name) {\n  const value = values && typeof values === 'string' ? [values] : values\n\n  if (!value || typeof value !== 'object' || !('length' in value)) {\n    throw new Error(\n      'Invalid ' + name + ' `' + value + '`, expected non-empty string'\n    )\n  }\n\n  return value\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n */\n\nconst own = {}.hasOwnProperty\n\n/**\n * Check if `node` is an element and has a `name` property.\n *\n * @template {string} Key\n *   Type of key.\n * @param {Nodes} node\n *   Node to check (typically `Element`).\n * @param {Key} name\n *   Property name to check.\n * @returns {node is Element & {properties: Record<Key, Array<number | string> | number | string | true>}}}\n *   Whether `node` is an element that has a `name` property.\n *\n *   Note: see <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/27c9274/types/hast/index.d.ts#L37C29-L37C98>.\n */\nexport function hasProperty(node, name) {\n  const value =\n    node.type === 'element' &&\n    own.call(node.properties, name) &&\n    node.properties[name]\n\n  return value !== null && value !== undefined && value !== false\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",null,null,null,"/**\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('css-selector-parser').AstPseudoClass} AstPseudoClass\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Parents} Parents\n *\n * @typedef {import('./index.js').State} State\n */\n\nimport {extendedFilter} from 'bcp-47-match'\nimport {parse as commas} from 'comma-separated-tokens'\nimport {ok as assert, unreachable} from 'devlop'\nimport {hasProperty} from 'hast-util-has-property'\nimport {whitespace} from 'hast-util-whitespace'\nimport fauxEsmNthCheck from 'nth-check'\nimport {zwitch} from 'zwitch'\nimport {walk} from './walk.js'\n\n/** @type {import('nth-check').default} */\n// @ts-expect-error: types are broken.\nconst nthCheck = fauxEsmNthCheck.default || fauxEsmNthCheck\n\n/** @type {(rule: AstPseudoClass, element: Element, index: number | undefined, parent: Parents | undefined, state: State) => boolean} */\nexport const pseudo = zwitch('name', {\n  handlers: {\n    'any-link': anyLink,\n    blank,\n    checked,\n    dir,\n    disabled,\n    empty,\n    enabled,\n    'first-child': firstChild,\n    'first-of-type': firstOfType,\n    has,\n    is,\n    lang,\n    'last-child': lastChild,\n    'last-of-type': lastOfType,\n    not,\n    'nth-child': nthChild,\n    'nth-last-child': nthLastChild,\n    'nth-last-of-type': nthLastOfType,\n    'nth-of-type': nthOfType,\n    'only-child': onlyChild,\n    'only-of-type': onlyOfType,\n    optional,\n    'read-only': readOnly,\n    'read-write': readWrite,\n    required,\n    root,\n    scope\n  },\n  invalid: invalidPseudo,\n  unknown: unknownPseudo\n})\n\n/**\n * Check whether an element matches an `:any-link` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction anyLink(_, element) {\n  return (\n    (element.tagName === 'a' ||\n      element.tagName === 'area' ||\n      element.tagName === 'link') &&\n    hasProperty(element, 'href')\n  )\n}\n\n/**\n * @param {State} state\n *   State.\n * @param {AstPseudoClass} query\n *   Query.\n */\nfunction assertDeep(state, query) {\n  if (state.shallow) {\n    throw new Error('Cannot use `:' + query.name + '` without parent')\n  }\n}\n\n/**\n * Check whether an element matches a `:blank` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction blank(_, element) {\n  return !someChildren(element, check)\n\n  /**\n   * @param {ElementContent} child\n   * @returns {boolean}\n   */\n  function check(child) {\n    return (\n      child.type === 'element' || (child.type === 'text' && !whitespace(child))\n    )\n  }\n}\n\n/**\n * Check whether an element matches a `:checked` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction checked(_, element) {\n  if (element.tagName === 'input' || element.tagName === 'menuitem') {\n    return Boolean(\n      (element.properties.type === 'checkbox' ||\n        element.properties.type === 'radio') &&\n        hasProperty(element, 'checked')\n    )\n  }\n\n  if (element.tagName === 'option') {\n    return hasProperty(element, 'selected')\n  }\n\n  return false\n}\n\n/**\n * Check whether an element matches a `:dir()` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction dir(query, _1, _2, _3, state) {\n  assert(query.argument, 'expected `argument`')\n  assert(query.argument.type === 'String', 'expected plain text')\n  return state.direction === query.argument.value\n}\n\n/**\n * Check whether an element matches a `:disabled` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction disabled(_, element) {\n  return (\n    (element.tagName === 'button' ||\n      element.tagName === 'input' ||\n      element.tagName === 'select' ||\n      element.tagName === 'textarea' ||\n      element.tagName === 'optgroup' ||\n      element.tagName === 'option' ||\n      element.tagName === 'menuitem' ||\n      element.tagName === 'fieldset') &&\n    hasProperty(element, 'disabled')\n  )\n}\n\n/**\n * Check whether an element matches an `:empty` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction empty(_, element) {\n  return !someChildren(element, check)\n\n  /**\n   * @param {ElementContent} child\n   * @returns {boolean}\n   */\n  function check(child) {\n    return child.type === 'element' || child.type === 'text'\n  }\n}\n\n/**\n * Check whether an element matches an `:enabled` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction enabled(query, element) {\n  return !disabled(query, element)\n}\n\n/**\n * Check whether an element matches a `:first-child` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction firstChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.elementIndex === 0\n}\n\n/**\n * Check whether an element matches a `:first-of-type` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction firstOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.typeIndex === 0\n}\n\n/**\n * @param {AstPseudoClass} query\n *   Query.\n * @returns {(value: number) => boolean}\n *   N.\n */\nfunction getCachedNthCheck(query) {\n  /** @type {(value: number) => boolean} */\n  // @ts-expect-error: cache.\n  let fn = query._cachedFn\n\n  if (!fn) {\n    const value = query.argument\n    assert(value, 'expected `argument`')\n\n    if (value.type !== 'Formula') {\n      throw new Error(\n        'Expected `nth` formula, such as `even` or `2n+1` (`of` is not yet supported)'\n      )\n    }\n\n    fn = nthCheck(value.a + 'n+' + value.b)\n    // @ts-expect-error: cache.\n    query._cachedFn = fn\n  }\n\n  return fn\n}\n\n/**\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} _1\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _2\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction has(query, element, _1, _2, state) {\n  assert(query.argument, 'expected `argument`')\n  assert(query.argument.type === 'Selector', 'expected selector')\n\n  /** @type {State} */\n  const childState = {\n    ...state,\n    // Not found yet.\n    found: false,\n    // One result is enough.\n    one: true,\n    results: [],\n    rootQuery: query.argument,\n    scopeElements: [element],\n    // Do walk deep.\n    shallow: false\n  }\n\n  walk(childState, {type: 'root', children: element.children})\n\n  return childState.results.length > 0\n}\n\n// Shouldn’t be called, parser gives correct data.\n/* c8 ignore next 3 */\nfunction invalidPseudo() {\n  unreachable('Invalid pseudo-selector')\n}\n\n/**\n * Check whether an element `:is` further selectors.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} _1\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _2\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction is(query, element, _1, _2, state) {\n  assert(query.argument, 'expected `argument`')\n  assert(query.argument.type === 'Selector', 'expected selector')\n\n  /** @type {State} */\n  const childState = {\n    ...state,\n    // Not found yet.\n    found: false,\n    // One result is enough.\n    one: true,\n    results: [],\n    rootQuery: query.argument,\n    scopeElements: [element],\n    // Do walk deep.\n    shallow: false\n  }\n\n  walk(childState, element)\n\n  return childState.results[0] === element\n}\n\n/**\n * Check whether an element matches a `:lang()` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction lang(query, _1, _2, _3, state) {\n  assert(query.argument, 'expected `argument`')\n  assert(query.argument.type === 'String', 'expected string')\n\n  return (\n    state.language !== '' &&\n    state.language !== undefined &&\n    extendedFilter(state.language, commas(query.argument.value)).length > 0\n  )\n}\n\n/**\n * Check whether an element matches a `:last-child` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction lastChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return Boolean(\n    state.elementCount && state.elementIndex === state.elementCount - 1\n  )\n}\n\n/**\n * Check whether an element matches a `:last-of-type` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction lastOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return (\n    typeof state.typeIndex === 'number' &&\n    typeof state.typeCount === 'number' &&\n    state.typeIndex === state.typeCount - 1\n  )\n}\n\n/**\n * Check whether an element does `:not` match further selectors.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} index\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction not(query, element, index, parent, state) {\n  return !is(query, element, index, parent, state)\n}\n\n/**\n * Check whether an element matches an `:nth-child` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction nthChild(query, _1, _2, _3, state) {\n  const fn = getCachedNthCheck(query)\n  assertDeep(state, query)\n  return typeof state.elementIndex === 'number' && fn(state.elementIndex)\n}\n\n/**\n * Check whether an element matches an `:nth-last-child` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction nthLastChild(query, _1, _2, _3, state) {\n  const fn = getCachedNthCheck(query)\n  assertDeep(state, query)\n  return Boolean(\n    typeof state.elementCount === 'number' &&\n      typeof state.elementIndex === 'number' &&\n      fn(state.elementCount - state.elementIndex - 1)\n  )\n}\n\n/**\n * Check whether an element matches a `:nth-last-of-type` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction nthLastOfType(query, _1, _2, _3, state) {\n  const fn = getCachedNthCheck(query)\n  assertDeep(state, query)\n  return (\n    typeof state.typeCount === 'number' &&\n    typeof state.typeIndex === 'number' &&\n    fn(state.typeCount - 1 - state.typeIndex)\n  )\n}\n\n/**\n * Check whether an element matches an `:nth-of-type` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction nthOfType(query, _1, _2, _3, state) {\n  const fn = getCachedNthCheck(query)\n  assertDeep(state, query)\n  return typeof state.typeIndex === 'number' && fn(state.typeIndex)\n}\n\n/**\n * Check whether an element matches an `:only-child` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction onlyChild(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.elementCount === 1\n}\n\n/**\n * Check whether an element matches an `:only-of-type` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} _1\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction onlyOfType(query, _1, _2, _3, state) {\n  assertDeep(state, query)\n  return state.typeCount === 1\n}\n\n/**\n * Check whether an element matches an `:optional` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction optional(query, element) {\n  return !required(query, element)\n}\n\n/**\n * Check whether an element matches a `:read-only` pseudo.\n *\n * @param {AstPseudoClass} query\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} index\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction readOnly(query, element, index, parent, state) {\n  return !readWrite(query, element, index, parent, state)\n}\n\n/**\n * Check whether an element matches a `:read-write` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} _1\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _2\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction readWrite(_, element, _1, _2, state) {\n  return element.tagName === 'input' || element.tagName === 'textarea'\n    ? !hasProperty(element, 'readOnly') && !hasProperty(element, 'disabled')\n    : Boolean(state.editableOrEditingHost)\n}\n\n/**\n * Check whether an element matches a `:required` pseudo.\n *\n * @param {AstPseudoClass} _\n *   Query.\n * @param {Element} element\n *   Element.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction required(_, element) {\n  return (\n    (element.tagName === 'input' ||\n      element.tagName === 'textarea' ||\n      element.tagName === 'select') &&\n    hasProperty(element, 'required')\n  )\n}\n\n/**\n * Check whether an element matches a `:root` pseudo.\n *\n * @param {AstPseudoClass} _1\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction root(_1, element, _2, parent, state) {\n  return Boolean(\n    (!parent || parent.type === 'root') &&\n      state.schema &&\n      (state.schema.space === 'html' || state.schema.space === 'svg') &&\n      (element.tagName === 'html' || element.tagName === 'svg')\n  )\n}\n\n/**\n * Check whether an element matches a `:scope` pseudo.\n *\n * @param {AstPseudoClass} _1\n *   Query.\n * @param {Element} element\n *   Element.\n * @param {number | undefined} _2\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} _3\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nfunction scope(_1, element, _2, _3, state) {\n  return state.scopeElements.includes(element)\n}\n\n/**\n * Check children.\n *\n * @param {Element} element\n *   Element.\n * @param {(child: ElementContent) => boolean} check\n *   Check.\n * @returns {boolean}\n *   Whether a child of `element` matches `check`.\n */\nfunction someChildren(element, check) {\n  const children = element.children\n  let index = -1\n\n  while (++index < children.length) {\n    if (check(children[index])) return true\n  }\n\n  return false\n}\n\n/**\n * @param {unknown} query_\n *   Query-like value.\n * @returns {never}\n *   Nothing.\n * @throws\n *   Exception.\n */\nfunction unknownPseudo(query_) {\n  // Runtime JS guarantees it has a `name`.\n  const query = /** @type {AstPseudoClass} */ (query_)\n  throw new Error('Unknown pseudo-selector `' + query.name + '`')\n}\n","/**\n * @typedef {import('css-selector-parser').AstRule} AstRule\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Parents} Parents\n *\n * @typedef {import('./index.js').State} State\n */\n\nimport {attribute} from './attribute.js'\nimport {className} from './class-name.js'\nimport {id} from './id.js'\nimport {name} from './name.js'\nimport {pseudo} from './pseudo.js'\n\n/**\n * Test a rule.\n *\n * @param {AstRule} query\n *   AST rule (with `pseudoClasses`).\n * @param {Element} element\n *   Element.\n * @param {number | undefined} index\n *   Index of `element` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `element`.\n * @param {State} state\n *   State.\n * @returns {boolean}\n *   Whether `element` matches `query`.\n */\nexport function test(query, element, index, parent, state) {\n  for (const item of query.items) {\n    // eslint-disable-next-line unicorn/prefer-switch\n    if (item.type === 'Attribute') {\n      if (!attribute(item, element, state.schema)) return false\n    } else if (item.type === 'Id') {\n      if (!id(item, element)) return false\n    } else if (item.type === 'ClassName') {\n      if (!className(item, element)) return false\n    } else if (item.type === 'PseudoClass') {\n      if (!pseudo(item, element, index, parent, state)) return false\n    } else if (item.type === 'PseudoElement') {\n      throw new Error('Invalid selector: `::' + item.name + '`')\n    } else if (item.type === 'TagName') {\n      if (!name(item, element)) return false\n    } else {\n      // Otherwise `item.type` is `WildcardTag`, which matches.\n    }\n  }\n\n  return true\n}\n","/**\n * @typedef {import('css-selector-parser').AstRule} AstRule\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n *\n * @typedef {import('./index.js').State} State\n */\n\n/**\n * @typedef Counts\n *   Info on elements in a parent.\n * @property {number} count\n *   Number of elements.\n * @property {Map<string, number>} types\n *   Number of elements by tag name.\n *\n * @typedef Nest\n *   Rule sets by nesting.\n * @property {Array<AstRule> | undefined} adjacentSibling\n *   `a + b`\n * @property {Array<AstRule> | undefined} descendant\n *   `a b`\n * @property {Array<AstRule> | undefined} directChild\n *   `a > b`\n * @property {Array<AstRule> | undefined} generalSibling\n *   `a ~ b`\n */\n\nimport {enterState} from './enter-state.js'\nimport {test} from './test.js'\n\n/** @type {Array<never>} */\nconst empty = []\n\n/**\n * Walk a tree.\n *\n * @param {State} state\n *   State.\n * @param {Nodes | undefined} tree\n *   Tree.\n */\nexport function walk(state, tree) {\n  if (tree) {\n    one(state, [], tree, undefined, undefined, tree)\n  }\n}\n\n/**\n * Add a rule to a nesting map.\n *\n * @param {Nest} nest\n *   Nesting.\n * @param {keyof Nest} field\n *   Field.\n * @param {AstRule} rule\n *   Rule.\n */\nfunction add(nest, field, rule) {\n  const list = nest[field]\n  if (list) {\n    list.push(rule)\n  } else {\n    nest[field] = [rule]\n  }\n}\n\n/**\n * Check in a parent.\n *\n * @param {State} state\n *   State.\n * @param {Nest} nest\n *   Nesting.\n * @param {Parents} node\n *   Parent.\n * @param {Nodes} tree\n *   Tree.\n * @returns {undefined}\n *   Nothing.\n */\nfunction all(state, nest, node, tree) {\n  const fromParent = combine(nest.descendant, nest.directChild)\n  /** @type {Array<AstRule> | undefined} */\n  let fromSibling\n  let index = -1\n  /**\n   * Total counts.\n   * @type {Counts}\n   */\n  const total = {count: 0, types: new Map()}\n  /**\n   * Counts of previous siblings.\n   * @type {Counts}\n   */\n  const before = {count: 0, types: new Map()}\n\n  while (++index < node.children.length) {\n    count(total, node.children[index])\n  }\n\n  index = -1\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n    // Uppercase to prevent prototype polution, injecting `constructor` or so.\n    // Normalize because HTML is insensitive.\n    const name =\n      child.type === 'element' ? child.tagName.toUpperCase() : undefined\n    // Before counting further elements:\n    state.elementIndex = before.count\n    state.typeIndex = name ? before.types.get(name) || 0 : 0\n    // After counting all elements.\n    state.elementCount = total.count\n    state.typeCount = name ? total.types.get(name) : 0\n\n    // Only apply if this is a parent, this should be an element, but we check\n    // for parents so that we delve into custom nodes too.\n    if ('children' in child) {\n      const forSibling = combine(fromParent, fromSibling)\n      const nest = one(\n        state,\n        forSibling,\n        node.children[index],\n        index,\n        node,\n        tree\n      )\n      fromSibling = combine(nest.generalSibling, nest.adjacentSibling)\n    }\n\n    // We found one thing, and one is enough.\n    if (state.one && state.found) {\n      break\n    }\n\n    count(before, node.children[index])\n  }\n}\n\n/**\n * Apply selectors to an element.\n *\n * @param {State} state\n *   Current state.\n * @param {Array<AstRule>} rules\n *   Rules to apply.\n * @param {Element} node\n *   Element to apply rules to.\n * @param {number | undefined} index\n *   Index of `node` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Nest}\n *   Further rules.\n */\nfunction applySelectors(state, rules, node, index, parent) {\n  /** @type {Nest} */\n  const nestResult = {\n    adjacentSibling: undefined,\n    descendant: undefined,\n    directChild: undefined,\n    generalSibling: undefined\n  }\n  let selectorIndex = -1\n\n  while (++selectorIndex < rules.length) {\n    const rule = rules[selectorIndex]\n\n    // We found one thing, and one is enough.\n    if (state.one && state.found) {\n      break\n    }\n\n    // When shallow, we don’t allow nested rules.\n    // Idea: we could allow a stack of parents?\n    // Might get quite complex though.\n    if (state.shallow && rule.nestedRule) {\n      throw new Error('Expected selector without nesting')\n    }\n\n    // If this rule matches:\n    if (test(rule, node, index, parent, state)) {\n      const nest = rule.nestedRule\n\n      // Are there more?\n      if (nest) {\n        /** @type {keyof Nest} */\n        const label =\n          nest.combinator === '+'\n            ? 'adjacentSibling'\n            : nest.combinator === '~'\n            ? 'generalSibling'\n            : nest.combinator === '>'\n            ? 'directChild'\n            : 'descendant'\n        add(nestResult, label, nest)\n      } else {\n        // We have a match!\n        state.found = true\n\n        if (!state.results.includes(node)) {\n          state.results.push(node)\n        }\n      }\n    }\n\n    // Descendant.\n    if (rule.combinator === undefined) {\n      add(nestResult, 'descendant', rule)\n    }\n    // Adjacent.\n    else if (rule.combinator === '~') {\n      add(nestResult, 'generalSibling', rule)\n    }\n    // Drop direct child (`>`), adjacent sibling (`+`).\n  }\n\n  return nestResult\n}\n\n/**\n * Combine two lists, if needed.\n *\n * This is optimized to create as few lists as possible.\n *\n * @param {Array<AstRule> | undefined} left\n *   Rules.\n * @param {Array<AstRule> | undefined} right\n *   Rules.\n * @returns {Array<AstRule>}\n *   Rules.\n */\nfunction combine(left, right) {\n  return left && right && left.length > 0 && right.length > 0\n    ? [...left, ...right]\n    : left && left.length > 0\n    ? left\n    : right && right.length > 0\n    ? right\n    : empty\n}\n\n/**\n * Count a node.\n *\n * @param {Counts} counts\n *   Counts.\n * @param {Nodes} node\n *   Node (we’re looking for elements).\n * @returns {undefined}\n *   Nothing.\n */\nfunction count(counts, node) {\n  if (node.type === 'element') {\n    // Uppercase to prevent prototype polution, injecting `constructor` or so.\n    // Normalize because HTML is insensitive.\n    const name = node.tagName.toUpperCase()\n    const count = (counts.types.get(name) || 0) + 1\n    counts.count++\n    counts.types.set(name, count)\n  }\n}\n\n/**\n * Check a node.\n *\n * @param {State} state\n *   State.\n * @param {Array<AstRule>} currentRules\n *   Rules.\n * @param {Nodes} node\n *   Node.\n * @param {number | undefined} index\n *   Index of `node` in `parent`.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @param {Nodes} tree\n *   Tree.\n * @returns {Nest}\n *   Nesting.\n */\nfunction one(state, currentRules, node, index, parent, tree) {\n  /** @type {Nest} */\n  let nestResult = {\n    adjacentSibling: undefined,\n    descendant: undefined,\n    directChild: undefined,\n    generalSibling: undefined\n  }\n\n  const exit = enterState(state, node)\n\n  if (node.type === 'element') {\n    let rootRules = state.rootQuery.rules\n\n    // Remove direct child rules if this is the root.\n    // This only happens for a `:has()` rule, which can be like\n    // `a:has(> b)`.\n    if (parent && parent !== tree) {\n      rootRules = state.rootQuery.rules.filter(\n        (d) =>\n          d.combinator === undefined ||\n          (d.combinator === '>' && parent === tree)\n      )\n    }\n\n    nestResult = applySelectors(\n      state,\n      // Try the root rules for this element too.\n      combine(currentRules, rootRules),\n      node,\n      index,\n      parent\n    )\n  }\n\n  // If this is a parent, and we want to delve into them, and we haven’t found\n  // our single result yet.\n  if ('children' in node && !state.shallow && !(state.one && state.found)) {\n    all(state, nestResult, node, tree)\n  }\n\n  exit()\n\n  return nestResult\n}\n","/**\n * @typedef {import('css-selector-parser').AstSelector} AstSelector\n *\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').RootContent} RootContent\n *\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef {'html' | 'svg'} Space\n *   Name of namespace.\n *\n * @typedef {'auto' | 'ltr' | 'rtl'} Direction\n *   Direction.\n *\n * @typedef State\n *   Current state.\n * @property {Direction} direction\n *   Current direction.\n * @property {boolean} editableOrEditingHost\n *   Whether we’re in `contentEditable`.\n * @property {number | undefined} elementCount\n *   Track siblings: there are `n` siblings.\n * @property {number | undefined} elementIndex\n *   Track siblings: this current element has `n` elements before it.\n * @property {boolean} found\n *   Whether we found at least one match.\n * @property {string | undefined} language\n *   Current language.\n * @property {boolean} one\n *   Whether we can stop looking after we found one element.\n * @property {Array<Element>} results\n *   Matches.\n * @property {AstSelector} rootQuery\n *   Original root selectors.\n * @property {Schema} schema\n *   Current schema.\n * @property {Array<RootContent>} scopeElements\n *   Elements in scope.\n * @property {boolean} shallow\n *   Whether we only allow selectors without nesting.\n * @property {number | undefined} typeCount\n *   Track siblings: there are `n` siblings with this element’s tag name.\n * @property {number | undefined} typeIndex\n *   Track siblings: this current element has `n` elements with its tag name\n *   before it.\n */\n\nimport {html, svg} from 'property-information'\nimport {parse} from './parse.js'\nimport {walk} from './walk.js'\n\n/**\n * Check that the given `node` matches `selector`.\n *\n * This only checks the element itself, not the surrounding tree.\n * Thus, nesting in selectors is not supported (`p b`, `p > b`), neither are\n * selectors like `:first-child`, etc.\n * This only checks that the given element matches the selector.\n *\n * @param {string} selector\n *   CSS selector, such as (`h1`, `a, b`).\n * @param {Nodes | null | undefined} [node]\n *   Node that might match `selector`, should be an element (optional).\n * @param {Space | null | undefined} [space='html']\n *   Name of namespace (default: `'html'`).\n * @returns {boolean}\n *   Whether `node` matches `selector`.\n */\nexport function matches(selector, node, space) {\n  const state = createState(selector, node, space)\n  state.one = true\n  state.shallow = true\n  walk(state, node || undefined)\n  return state.results.length > 0\n}\n\n/**\n * Select the first element that matches `selector` in the given `tree`.\n * Searches the tree in *preorder*.\n *\n * @param {string} selector\n *   CSS selector, such as (`h1`, `a, b`).\n * @param {Nodes | null | undefined} [tree]\n *   Tree to search (optional).\n * @param {Space | null | undefined} [space='html']\n *   Name of namespace (default: `'html'`).\n * @returns {Element | undefined}\n *   First element in `tree` that matches `selector` or `undefined` if nothing\n *   is found; this could be `tree` itself.\n */\nexport function select(selector, tree, space) {\n  const state = createState(selector, tree, space)\n  state.one = true\n  walk(state, tree || undefined)\n  return state.results[0]\n}\n\n/**\n * Select all elements that match `selector` in the given `tree`.\n * Searches the tree in *preorder*.\n *\n * @param {string} selector\n *   CSS selector, such as (`h1`, `a, b`).\n * @param {Nodes | null | undefined} [tree]\n *   Tree to search (optional).\n * @param {Space | null | undefined} [space='html']\n *   Name of namespace (default: `'html'`).\n * @returns {Array<Element>}\n *   Elements in `tree` that match `selector`.\n *   This could include `tree` itself.\n */\nexport function selectAll(selector, tree, space) {\n  const state = createState(selector, tree, space)\n  walk(state, tree || undefined)\n  return state.results\n}\n\n/**\n * @param {string} selector\n *   CSS selector, such as (`h1`, `a, b`).\n * @param {Nodes | null | undefined} [tree]\n *   Tree to search (optional).\n * @param {Space | null | undefined} [space='html']\n *   Name of namespace (default: `'html'`).\n * @returns {State} State\n *   State.\n */\nfunction createState(selector, tree, space) {\n  return {\n    direction: 'ltr',\n    editableOrEditingHost: false,\n    elementCount: undefined,\n    elementIndex: undefined,\n    found: false,\n    language: undefined,\n    one: false,\n    // State of the query.\n    results: [],\n    rootQuery: parse(selector),\n    schema: space === 'svg' ? svg : html,\n    scopeElements: tree ? (tree.type === 'root' ? tree.children : [tree]) : [],\n    shallow: false,\n    typeIndex: undefined,\n    typeCount: undefined\n  }\n}\n","import { Plugin } from 'unified';\nimport { Root, Element, ElementContent, RootContent } from 'hast';\nimport { visit } from 'unist-util-visit';\nimport { selectAll } from 'hast-util-select';\nimport { Test } from 'unist-util-is';\n\n/** Get the node tree source code string */\nexport const getCodeString = (data: ElementContent[] = [], code: string = '') => {\n  data.forEach((node) => {\n    if (node.type === 'text') {\n      code += node.value;\n    } else if (node.type === 'element' && node.children && Array.isArray(node.children)) {\n      code += getCodeString(node.children);\n    }\n  });\n  return code;\n};\n\nexport type RehypeRewriteOptions = {\n  /**\n   * Select an element to be wrapped. Expects a string selector that can be passed to hast-util-select ([supported selectors](https://github.com/syntax-tree/hast-util-select/blob/master/readme.md#support)).\n   * If `selector` is not set then wrap will check for a body all elements.\n   */\n  selector?: string;\n  /** Rewrite Element. */\n  rewrite(node: Root | RootContent, index?: number, parent?: Root | Element): void;\n}\n\nconst remarkRewrite: Plugin<[RehypeRewriteOptions?], Root> = (options) => {\n  const { selector, rewrite } = options || {};\n  return (tree) => {\n    if (!rewrite || typeof rewrite !== 'function') return;\n    if (selector && typeof selector === 'string') {\n      const selected = selectAll(selector, tree);\n      if (selected && selected.length > 0) {\n        visit(tree, selected as unknown as Test, (node: Element, index, parent) => {\n          rewrite(node, index, parent);\n        });\n      }\n      return;\n    }\n\n    visit(tree, (node: Root | RootContent, index, parent) => {\n      rewrite(node, index, parent);\n    });\n  }\n}\n\nexport default remarkRewrite;\n","import type { Element, Comment, Literal, ElementContent, RootContent, Properties } from 'hast';\nimport type { RehypeAttrsOptions } from './index.js';\n\nexport const getURLParameters = (url: string = '') =>\n  ((url.match(/([^?=&]+)(=([^&]*))/g) || []) as string[]).reduce(\n      (a: Record<string, string | number | boolean>, v: string) => (\n        (a[v.slice(0, v.indexOf('=')) as keyof typeof a] = v.slice(v.indexOf('=') + 1)), a\n      ),\n      {}\n    )\n\nexport const prevChild = (data: Literal[] = [], index: number): Comment | undefined => {\n  let i = index;\n  while (i > -1) {\n    i--;\n    if (!data[i]) return\n    if ((data[i] && data[i].value && (data[i].value as string).replace(/(\\n|\\s)/g, '') !== '') || data[i].type !== 'text') {\n      if (!/^rehype:/.test(data[i].value as string) || (data[i].type as string) !== 'comment') return;\n      return data[i] as unknown as Comment;\n    }\n  }\n  return;\n}\n\nexport const nextChild = (data: RootContent[] | ElementContent[] = [], index: number, tagName?: string, codeBlockParames?: boolean): ElementContent | undefined => {\n  let i = index;\n  while (i < data.length) {\n    i++;\n    if (tagName) {\n      const element = data[i] as Literal & Element;\n      if (element && element.value && (element.value as string).replace(/(\\n|\\s)/g, '') !== '' || data[i] && (data[i].type as string) === 'element') {\n        return element.tagName === tagName ? element : undefined\n      }\n    } else {\n      const element = data[i] as ElementContent & Literal;\n      if (!element || element.type === 'element') return;\n      if (element.type === 'text' && element.value.replace(/(\\n|\\s)/g, '') !== '') return;\n      if (element.type && /^(comment|raw)$/ig.test(element.type)) {\n        if (element.value && !/^rehype:/.test(element.value.replace(/^(\\s+)?<!--(.*?)-->/, '$2') || '')) {\n          return\n        };\n        if (codeBlockParames) {\n          const nextNode = nextChild(data, i, 'pre', codeBlockParames)\n          if (nextNode) return;\n          element.value = (element.value || '').replace(/^(\\n|\\s)+/, '')\n          return element;\n        } else {\n          element.value = (element.value || '').replace(/^(\\n|\\s)+/, '')\n          return element;\n        }\n      }\n    }\n  }\n  return\n}\n\n/**\n * 获取代码注视的位置\n * @param data 数据\n * @param index 当前数据所在的位置\n * @returns 返回 当前参数数据 Object，`{}`\n */\nexport const getCommentObject = ({ value = '' }: Comment): Properties => {\n  const param = getURLParameters(value.replace(/^<!--(.*?)-->/, '$1').replace(/^rehype:/, ''));\n  Object.keys(param).forEach((keyName: string) => {\n    if (param[keyName] === 'true') {\n      param[keyName] = true;\n    }\n    if (param[keyName] === 'false') {\n      param[keyName] = false;\n    }\n    if (typeof param[keyName] === 'string' && !/^0/.test(param[keyName] as string) && !isNaN(+param[keyName])) {\n      param[keyName] = +param[keyName];\n    }\n  })\n  return param;\n}\n\nexport type DataConfig = {\n  'data-config': Properties\n}\n\nexport const propertiesHandle = (defaultAttrs?: Properties | null, attrs?: Properties, type?: RehypeAttrsOptions['properties']): Properties | DataConfig => {\n  if (type === 'string') {\n    return { ...defaultAttrs, 'data-config': JSON.stringify({ ...attrs, rehyp: true })}\n  } else if (type === 'attr') {\n    return { ...defaultAttrs, ...attrs}\n  }\n  return { ...defaultAttrs, 'data-config': { ...attrs, rehyp: true }}\n}","import type { Plugin } from 'unified';\nimport type { Root, Element, Comment, Properties, Literal } from 'hast';\nimport { visit } from 'unist-util-visit';\nimport { propertiesHandle, nextChild, prevChild, getCommentObject } from './utils.js';\n\nexport type RehypeAttrsOptions = {\n  /**\n   * ## `data`\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs&abc=2-->\n   * ```\n   * 👇👇👇👇👇\n   * ```html\n   * <p data-config=\"data-config='[object Object]'\">text</p>\n   * ```\n   * \n   * ## `string`\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs-->\n   * ```\n   * \n   * 👇👇👇👇👇\n   * \n   * ```html\n   * <p data-config=\"{&#x22;title&#x22;:&#x22;Rehype Attrs&#x22;,&#x22;rehyp&#x22;:true}\">text</p>\n   * ```\n   * \n   * ## attr\n   * \n   * ```markdown\n   * text\n   * <!--rehype:title=Rehype Attrs-->\n   * ```\n   * 👇👇👇👇👇\n   * ```html\n   * <p title=\"Rehype Attrs\">text</p>\n   * ```\n   * @default `data`\n   */\n  properties?: 'data' | 'string' | 'attr';\n  /**\n   * Code block passing parameters\n   */\n  codeBlockParames?: boolean;\n}\n\nconst rehypeAttrs: Plugin<[RehypeAttrsOptions?], Root> = (options = {}) => {\n  const { properties = 'data', codeBlockParames = true } = options;\n  return (tree) => {\n    visit(tree, 'element', (node, index, parent) => {\n      if (codeBlockParames && node.tagName === 'pre' && node && Array.isArray(node.children) && parent && Array.isArray(parent.children) && parent.children.length > 1) {\n        const firstChild = node.children[0] as Element;\n        if (firstChild && firstChild.tagName === 'code' && typeof index === 'number') {\n          const child = prevChild(parent.children as Literal[], index);\n          if (child) {\n            const attr = getCommentObject(child);\n            if (Object.keys(attr).length > 0) {\n              node.properties = { ...node.properties, ...{ 'data-type': 'rehyp' } }\n              firstChild.properties = propertiesHandle(firstChild.properties, attr, properties) as Properties\n            }\n          }\n        }\n      }\n\n      if (/^(em|strong|b|a|i|p|pre|kbd|blockquote|h(1|2|3|4|5|6)|code|table|img|del|ul|ol)$/.test(node.tagName) && parent && Array.isArray(parent.children) && typeof index === 'number') {\n        const child = nextChild(parent.children, index, '', codeBlockParames)\n        if (child) {\n          const attr = getCommentObject(child as Comment)\n          if (Object.keys(attr).length > 0) {\n            node.properties = propertiesHandle(node.properties, attr, properties) as Properties\n          }\n        }\n      }\n    });\n  }\n}\n\n\nexport default rehypeAttrs\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","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 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 {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 * @typedef {import('vfile').VFile} VFile\n * @typedef {import('vfile').Value} Value\n * @typedef {import('unist').Point} UnistPoint\n */\n\n/**\n *\n * @typedef PointLike\n *   unist point, allowed as input.\n * @property {number | null | undefined} [line]\n *   Line.\n * @property {number | null | undefined} [column]\n *   Column.\n * @property {number | null | undefined} [offset]\n *   Offset.\n *\n * @callback ToPoint\n *   Get the line/column based `Point` for `offset` in the bound indices.\n *\n *   Returns `undefined` when given out of bounds input.\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 * @param {number | null | undefined} [offset]\n *   Something that should be an `offset.\n * @returns {UnistPoint | undefined}\n *   Point, if `offset` is valid and in-bounds input.\n *\n * @callback ToOffset\n *   Get the `offset` from a line/column based `Point` in the bound indices.\n * @param {PointLike | null | undefined} [point]\n *   Something that should be a `point.\n * @returns {number | undefined}\n *   Offset (`number`) or `undefined` for invalid or out of bounds input.\n *\n * @typedef Location\n *   Accessors for index.\n * @property {ToPoint} toPoint\n *   Get the line/column based `Point` for `offset` in the bound indices.\n * @property {ToOffset} toOffset\n *   Get the `offset` from a line/column based `Point` in the bound indices.\n */\n\nconst search = /\\r?\\n|\\r/g\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  search.lastIndex = 0\n\n  while (search.test(value)) {\n    indices.push(search.lastIndex)\n  }\n\n  indices.push(value.length + 1)\n\n  return {toPoint, toOffset}\n\n  /** @type {ToPoint} */\n  function toPoint(offset) {\n    let index = -1\n\n    if (\n      typeof offset === 'number' &&\n      offset > -1 &&\n      offset < indices[indices.length - 1]\n    ) {\n      while (++index < indices.length) {\n        if (indices[index] > offset) {\n          return {\n            line: index + 1,\n            column: offset - (index > 0 ? indices[index - 1] : 0) + 1,\n            offset\n          }\n        }\n      }\n    }\n  }\n\n  /** @type {ToOffset} */\n  function toOffset(point) {\n    const line = point && point.line\n    const column = point && point.column\n\n    if (\n      typeof line === 'number' &&\n      typeof column === 'number' &&\n      !Number.isNaN(line) &&\n      !Number.isNaN(column) &&\n      line - 1 in indices\n    ) {\n      const offset = (indices[line - 2] || 0) + column - 1 || 0\n\n      if (offset > -1 && offset < indices[indices.length - 1]) {\n        return offset\n      }\n    }\n  }\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 * @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",null,null,null,null,"/** 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",null,"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","/**\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 * @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","function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (e.indexOf(n) >= 0) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","/**\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 * `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 * @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 * 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 * 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').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 * @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 * @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').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').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').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').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('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 * 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').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}","/**\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 */\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').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').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('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').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('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').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').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","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {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} 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').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').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('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","/**\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} 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","/**\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 path = {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} [ext]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.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 (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.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 (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === ext.codePointAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * 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 proc = {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 * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n * @typedef {import('vfile-message').Options} MessageOptions\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef {Options | URL | VFile | Value} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n *   Set multiple values.\n * @property {string | null | undefined} [basename]\n *   Set `basename` (name).\n * @property {string | null | undefined} [cwd]\n *   Set `cwd` (working directory).\n * @property {Data | null | undefined} [data]\n *   Set `data` (associated info).\n * @property {string | null | undefined} [dirname]\n *   Set `dirname` (path w/o basename).\n * @property {string | null | undefined} [extname]\n *   Set `extname` (extension with dot).\n * @property {Array<string> | null | undefined} [history]\n *   Set `history` (paths the file moved between).\n * @property {URL | string | null | undefined} [path]\n *   Set `path` (current path).\n * @property {string | null | undefined} [stem]\n *   Set `stem` (name without extension).\n * @property {Value | null | undefined} [value]\n *   Set `value` (the contents of the file).\n *\n * @typedef Map\n *   Raw source map.\n *\n *   See:\n *   <https://github.com/mozilla/source-map/blob/60adcb0/source-map.d.ts#L15-L23>.\n * @property {number} version\n *   Which version of the source map spec this map is following.\n * @property {Array<string>} sources\n *   An array of URLs to the original source files.\n * @property {Array<string>} names\n *   An array of identifiers which can be referenced by individual mappings.\n * @property {string | undefined} [sourceRoot]\n *   The URL root from which all sources are relative.\n * @property {Array<string> | undefined} [sourcesContent]\n *   An array of contents of the original source files.\n * @property {string} mappings\n *   A string of base64 VLQs which contain the actual mappings.\n * @property {string} file\n *   The generated file this source map is associated with.\n *\n * @typedef {Record<string, unknown> & VFileCoreOptions} Options\n *   Configuration.\n *\n *   A bunch of keys that will be shallow copied over to the new file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n *   Configuration for reporters.\n */\n\n/**\n * @template [Settings=ReporterSettings]\n *   Options type.\n * @callback Reporter\n *   Type for a reporter.\n * @param {Array<VFile>} files\n *   Files to report.\n * @param {Settings} options\n *   Configuration.\n * @returns {string}\n *   Report.\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {path} from 'vfile/do-not-use-conditional-minpath'\nimport {proc} from 'vfile/do-not-use-conditional-minproc'\nimport {urlToPath, isUrl} from 'vfile/do-not-use-conditional-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    this.cwd = proc.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 prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        prop in options &&\n        options[prop] !== undefined &&\n        options[prop] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) {\n        // @ts-expect-error: fine to set other things.\n        this[prop] = options[prop]\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' ? path.basename(this.path) : 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 = path.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' ? path.dirname(this.path) : 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 = path.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' ? path.extname(this.path) : 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 = path.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      ? path.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 = path.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(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   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 * 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').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","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').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 * @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').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('../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').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\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').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').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('../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","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('../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('../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 * 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').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('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').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').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['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\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('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('../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').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').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('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('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","/**\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').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('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Previous} Previous\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 {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiControl,\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} 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  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n}\nconst protocolAutolink = {\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n}\nconst 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\n  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 (\n      !gfmAtext(code) ||\n      !previousEmail.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\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(\n        emailDomainDotTrail,\n        emailDomainAfter,\n        emailDomainDot\n      )(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 (\n      (code !== 87 && code !== 119) ||\n      !previousWww.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\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(\n      wwwPrefix,\n      effects.attempt(domain, effects.attempt(path, wwwAfter), nok),\n      nok\n    )(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 (\n      (code === 72 || code === 104) &&\n      previousProtocol.call(self, self.previous) &&\n      !previousUnbalanced(self.events)\n    ) {\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 ||\n      asciiControl(code) ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)\n      ? nok(code)\n      : 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 (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      (code !== 45 && unicodePunctuation(code))\n    ) {\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 (\n      code === 33 ||\n      code === 34 ||\n      code === 38 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 60 ||\n      code === 63 ||\n      code === 93 ||\n      code === 95 ||\n      code === 126\n    ) {\n      return effects.check(trail, ok, pathAtPunctuation)(code)\n    }\n    if (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\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 (\n      code === 33 ||\n      code === 34 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 63 ||\n      code === 95 ||\n      code === 126\n    ) {\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 trailCharRefStart\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 ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\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 (\n      code === null ||\n      code === 40 ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\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 trailCharRefStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharRefInside(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 trailCharRefInside(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 trailCharRefInside\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 (\n    code === null ||\n    code === 40 ||\n    code === 42 ||\n    code === 95 ||\n    code === 91 ||\n    code === 93 ||\n    code === 126 ||\n    markdownLineEndingOrSpace(code)\n  )\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 (\n    code === 43 ||\n    code === 45 ||\n    code === 46 ||\n    code === 95 ||\n    asciiAlphanumeric(code)\n  )\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 (\n      (token.type === 'labelLink' || token.type === 'labelImage') &&\n      !token._balanced\n    ) {\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","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Extension} Extension\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 {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        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  }\n}\n\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 (\n      token.type === 'gfmFootnoteCall' ||\n      token.type === 'labelLink' ||\n      token.type === 'label' ||\n      token.type === 'image' ||\n      token.type === 'link'\n    ) {\n      break\n    }\n  }\n  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(\n      self.sliceSerialize({\n        start: labelStart.end,\n        end: self.now()\n      })\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 (\n      events[index][1].type === 'labelImage' &&\n      events[index][0] === 'enter'\n    ) {\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],\n    events[index + 2],\n    ['enter', call, context],\n    // The `[`\n    events[index + 3],\n    events[index + 4],\n    // The `^`.\n    ['enter', marker, context],\n    ['exit', marker, context],\n    // Everything in between.\n    ['enter', string, context],\n    ['enter', chunk, context],\n    ['exit', chunk, context],\n    ['exit', string, context],\n    // The ending (`]`, properly parsed and labelled).\n    events[events.length - 2],\n    events[events.length - 1],\n    ['exit', call, context]\n  ]\n  events.splice(index, events.length - index + 1, ...replacement)\n  return events\n}\n\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 ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\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 ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\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(\n        effects,\n        whitespaceAfter,\n        'gfmFootnoteDefinitionWhitespace'\n      )\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(\n    effects,\n    afterPrefix,\n    'gfmFootnoteDefinitionIndent',\n    4 + 1\n  )\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'gfmFootnoteDefinitionIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === 4\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\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 * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [singleTilde=true]\n *   Whether to support strikethrough with a single tilde (default: `true`).\n *\n *   Single tildes work on github.com, but are technically prohibited by the\n *   GFM spec.\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    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 (\n        events[index][0] === 'enter' &&\n        events[index][1].type === 'strikethroughSequenceTemporary' &&\n        events[index][1]._close\n      ) {\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 (\n            events[open][0] === 'exit' &&\n            events[open][1].type === 'strikethroughSequenceTemporary' &&\n            events[open][1]._open &&\n            // If the sizes are the same:\n            events[index][1].end.offset - events[index][1].start.offset ===\n              events[open][1].end.offset - events[open][1].start.offset\n          ) {\n            events[index][1].type = 'strikethroughSequence'\n            events[open][1].type = 'strikethroughSequence'\n\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 = [\n              ['enter', strikethrough, context],\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context],\n              ['enter', text, context]\n            ]\n            const insideSpan = context.parser.constructs.insideSpan.null\n            if (insideSpan) {\n              // Between.\n              splice(\n                nextEvents,\n                nextEvents.length,\n                0,\n                resolveAll(insideSpan, events.slice(open + 1, index), context)\n              )\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [\n              ['exit', text, context],\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context],\n              ['exit', strikethrough, context]\n            ])\n            splice(events, open - 1, index - open + 3, nextEvents)\n            index = open + nextEvents.length - 2\n            break\n          }\n        }\n      }\n    }\n    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 (\n        previous === 126 &&\n        events[events.length - 1][1].type !== 'characterEscape'\n      ) {\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","/**\n * @typedef {import('micromark-util-types').Event} Event\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    addImpl(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  //   addImpl(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(\n        events.slice(this.map[index][0] + this.map[index][1]),\n        this.map[index][2]\n      )\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 addImpl(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","/**\n * @typedef {import('micromark-util-types').Event} Event\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(\n            events[index + 1][1].type === 'tableDelimiterMarker'\n              ? 'left'\n              : 'none'\n          )\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","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\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\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 {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} 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        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 (\n        type === 'lineEnding' ||\n        // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n        type === 'linePrefix'\n      )\n        index--\n      else break\n    }\n    const tail = index > -1 ? self.events[index][1].type : null\n    const next =\n      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(\n        effects,\n        headDelimiterBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(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 (\n        token.type === 'tableRow' ||\n        token.type === 'tableDelimiterRow'\n      ) {\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 (\n        rowKind &&\n        (token.type === 'data' ||\n          token.type === 'tableDelimiterMarker' ||\n          token.type === 'tableDelimiterFiller')\n      ) {\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(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\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(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\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 (\n      token.type === 'tableRow' ||\n      token.type === 'tableDelimiterRow'\n    ) {\n      lastTableEnd = index\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1]\n        currentCell = flushCell(\n          map,\n          context,\n          lastCell,\n          rowKind,\n          index,\n          currentCell\n        )\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell)\n      }\n      rowKind = 0\n    } else if (\n      rowKind &&\n      (token.type === 'data' ||\n        token.type === 'tableDelimiterMarker' ||\n        token.type === 'tableDelimiterFiller')\n    ) {\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 =\n    rowKind === 1\n      ? 'tableHeader'\n      : rowKind === 2\n      ? 'tableDelimiter'\n      : '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","/**\n * @typedef {import('micromark-util-types').Extension} Extension\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 {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nconst 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    ) {\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        {\n          tokenize: spaceThenNonSpace\n        },\n        ok,\n        nok\n      )(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","/// <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 * @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","/**\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","import { visit } from 'unist-util-visit';\nimport type { Plugin } from 'unified';\nimport type { Root, PhrasingContent } from \"mdast\";\n\nconst alertRegex = /^\\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\\]/i;\nconst alertLegacyRegex = /^\\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)(\\/.*)?\\]/i;\n\ntype Option = {\n  /**\n   * Use the legacy title format, which includes a slash and a title after the alert type.\n   * \n   * Enabling legacyTitle allows modifying the title, but this is not GitHub standard.\n   */\n  legacyTitle?: boolean\n}\n\n/**\n * Alerts are a Markdown extension based on the blockquote syntax that you can use to emphasize critical information.\n * On GitHub, they are displayed with distinctive colors and icons to indicate the significance of the content.\n * https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts\n */\nexport const remarkAlert: Plugin<[Option?], Root> = ({ legacyTitle = false } = {}) => {\n  return (tree) => {\n    visit(tree, \"blockquote\", (node, index, parent) => {\n      let alertType = '';\n      let title = '';\n      let isNext = true;\n      let child = node.children.map((item) => {\n        if (isNext && item.type === \"paragraph\") {\n          const firstNode = item.children[0];\n          const text = firstNode.type === 'text' ? firstNode.value : '';\n          const reg = legacyTitle ? alertLegacyRegex : alertRegex;\n          const match = text.match(reg);\n          if (match) {\n            isNext = false;\n            alertType = match[1].toLocaleLowerCase();\n            title = legacyTitle ? match[2] || alertType.toLocaleUpperCase() : alertType.toLocaleUpperCase();\n            if (text.includes('\\n')) {\n              item.children[0] = {\n                type: 'text',\n                value: text.replace(reg, '').replace(/^\\n+/, ''),\n              };\n            }\n\n            if (!text.includes('\\n')) {\n              const itemChild: Array<PhrasingContent> = [];\n              item.children.forEach((item, idx) => {\n                if (idx == 0) return;\n                if (idx == 1 && item.type === 'break') {\n                  return;\n                }\n                itemChild.push(item);\n              });\n              item.children = [...itemChild];\n            }\n          }\n        }\n        return item;\n      })\n\n      if (!!alertType) {\n        node.data = {\n          hName: \"div\",\n          hProperties: {\n            class: `markdown-alert markdown-alert-${alertType}`,\n            dir: 'auto'\n          },\n        }\n        child.unshift({\n          type: \"paragraph\",\n          children: [\n            getAlertIcon(alertType as IconType),\n            {\n              type: \"text\",\n              value: title.replace(/^\\//, ''),\n            }\n          ],\n          data: {\n            hProperties: {\n              class: \"markdown-alert-title\",\n              dir: \"auto\"\n            }\n          }\n        })\n      }\n      node.children = [...child];\n    });\n  };\n};\n\nexport function getAlertIcon(type: IconType): PhrasingContent {\n  let pathD = pathData[type] ?? '';\n  return {\n    type: \"emphasis\",\n    data: {\n      hName: \"svg\",\n      hProperties: {\n        class: \"octicon\",\n        viewBox: '0 0 16 16',\n        width: '16',\n        height: '16',\n        ariaHidden: 'true',\n      },\n    },\n    children: [\n      {\n        type: \"emphasis\",\n        data: {\n          hName: \"path\",\n          hProperties: {\n            d: pathD\n          }\n        },\n        children: []\n      }\n    ]\n  }\n}\n\ntype IconType = 'note' | 'tip' | 'important' | 'warning' | 'caution';\n\nconst pathData: Record<IconType, string> = {\n  note: 'M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z',\n  tip: 'M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z',\n  important:\n    'M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z',\n  warning:\n    'M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z',\n  caution:\n    'M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z',\n};\n","import copyTextToClipboard from '@uiw/copy-to-clipboard';\nimport { useEffect } from 'react';\nfunction getParentElement(target) {\n  if (!target) return null;\n  var dom = target;\n  if (dom.dataset.code && dom.classList.contains('copied')) {\n    return dom;\n  }\n  if (dom.parentElement) {\n    return getParentElement(dom.parentElement);\n  }\n  return null;\n}\nexport function useCopied(container) {\n  var handle = event => {\n    var target = getParentElement(event.target);\n    if (!target) return;\n    target.classList.add('active');\n    copyTextToClipboard(target.dataset.code, function () {\n      setTimeout(() => {\n        target.classList.remove('active');\n      }, 2000);\n    });\n  };\n  useEffect(() => {\n    var _container$current, _container$current2;\n    (_container$current = container.current) == null || _container$current.removeEventListener('click', handle, false);\n    (_container$current2 = container.current) == null || _container$current2.addEventListener('click', handle, false);\n    return () => {\n      var _container$current3;\n      (_container$current3 = container.current) == null || _container$current3.removeEventListener('click', handle, false);\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [container]);\n}","import _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/objectWithoutPropertiesLoose\";\nvar _excluded = [\"prefixCls\", \"className\", \"source\", \"style\", \"disableCopy\", \"skipHtml\", \"onScroll\", \"onMouseOver\", \"pluginsFilter\", \"rehypeRewrite\", \"wrapperElement\", \"warpperElement\", \"urlTransform\"];\nimport React, { useImperativeHandle } from 'react';\nimport ReactMarkdown from 'react-markdown';\nimport gfm from 'remark-gfm';\nimport raw from 'rehype-raw';\nimport { remarkAlert } from 'remark-github-blockquote-alert';\nimport { useCopied } from './plugins/useCopied';\nimport \"./styles/markdown.css\";\n\n/**\n * https://github.com/uiwjs/react-md-editor/issues/607\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nvar defaultUrlTransform = url => url;\nexport default /*#__PURE__*/React.forwardRef((props, ref) => {\n  var {\n      prefixCls = 'wmde-markdown wmde-markdown-color',\n      className,\n      source,\n      style,\n      disableCopy = false,\n      skipHtml = true,\n      onScroll,\n      onMouseOver,\n      pluginsFilter,\n      wrapperElement = {},\n      warpperElement = {},\n      urlTransform\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  var mdp = React.useRef(null);\n  useImperativeHandle(ref, () => _extends({}, props, {\n    mdp\n  }), [mdp, props]);\n  var cls = (prefixCls || '') + \" \" + (className || '');\n  useCopied(mdp);\n  var rehypePlugins = [...(other.rehypePlugins || [])];\n  var customProps = {\n    allowElement: (element, index, parent) => {\n      if (other.allowElement) {\n        return other.allowElement(element, index, parent);\n      }\n      return /^[A-Za-z0-9]+$/.test(element.tagName);\n    }\n  };\n  if (skipHtml) {\n    rehypePlugins.push(raw);\n  }\n  var remarkPlugins = [remarkAlert, ...(other.remarkPlugins || []), gfm];\n  var wrapperProps = _extends({}, warpperElement, wrapperElement);\n  return /*#__PURE__*/_jsx(\"div\", _extends({\n    ref: mdp,\n    onScroll: onScroll,\n    onMouseOver: onMouseOver\n  }, wrapperProps, {\n    className: cls,\n    style: style,\n    children: /*#__PURE__*/_jsx(ReactMarkdown, _extends({}, customProps, other, {\n      skipHtml: skipHtml,\n      urlTransform: urlTransform || defaultUrlTransform,\n      rehypePlugins: pluginsFilter ? pluginsFilter('rehype', rehypePlugins) : rehypePlugins,\n      remarkPlugins: pluginsFilter ? pluginsFilter('remark', remarkPlugins) : remarkPlugins,\n      children: source || ''\n    }))\n  }));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport { visit } from 'unist-util-visit';\nexport var reservedMeta = function reservedMeta(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return tree => {\n    visit(tree, node => {\n      if (node.type === 'element' && node.tagName === 'code' && node.data && node.data.meta) {\n        node.properties = _extends({}, node.properties, {\n          'data-meta': String(node.data.meta)\n        });\n      }\n    });\n  };\n};","import { visit } from 'unist-util-visit';\nexport var retrieveMeta = function retrieveMeta(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return tree => {\n    visit(tree, node => {\n      if (node.type === 'element' && node.tagName === 'code' && node.properties && node.properties['dataMeta']) {\n        if (!node.data) {\n          node.data = {};\n        }\n        var metaString = node.properties['dataMeta'];\n        if (typeof metaString === 'string') {\n          node.data.meta = metaString;\n        }\n        delete node.properties['dataMeta'];\n      }\n    });\n  };\n};","// This module is generated by `script/`.\n/* eslint-disable no-control-regex, no-misleading-character-class, no-useless-escape */\nexport const regex = /[\\0-\\x1F!-,\\.\\/:-@\\[-\\^`\\{-\\xA9\\xAB-\\xB4\\xB6-\\xB9\\xBB-\\xBF\\xD7\\xF7\\u02C2-\\u02C5\\u02D2-\\u02DF\\u02E5-\\u02EB\\u02ED\\u02EF-\\u02FF\\u0375\\u0378\\u0379\\u037E\\u0380-\\u0385\\u0387\\u038B\\u038D\\u03A2\\u03F6\\u0482\\u0530\\u0557\\u0558\\u055A-\\u055F\\u0589-\\u0590\\u05BE\\u05C0\\u05C3\\u05C6\\u05C8-\\u05CF\\u05EB-\\u05EE\\u05F3-\\u060F\\u061B-\\u061F\\u066A-\\u066D\\u06D4\\u06DD\\u06DE\\u06E9\\u06FD\\u06FE\\u0700-\\u070F\\u074B\\u074C\\u07B2-\\u07BF\\u07F6-\\u07F9\\u07FB\\u07FC\\u07FE\\u07FF\\u082E-\\u083F\\u085C-\\u085F\\u086B-\\u089F\\u08B5\\u08C8-\\u08D2\\u08E2\\u0964\\u0965\\u0970\\u0984\\u098D\\u098E\\u0991\\u0992\\u09A9\\u09B1\\u09B3-\\u09B5\\u09BA\\u09BB\\u09C5\\u09C6\\u09C9\\u09CA\\u09CF-\\u09D6\\u09D8-\\u09DB\\u09DE\\u09E4\\u09E5\\u09F2-\\u09FB\\u09FD\\u09FF\\u0A00\\u0A04\\u0A0B-\\u0A0E\\u0A11\\u0A12\\u0A29\\u0A31\\u0A34\\u0A37\\u0A3A\\u0A3B\\u0A3D\\u0A43-\\u0A46\\u0A49\\u0A4A\\u0A4E-\\u0A50\\u0A52-\\u0A58\\u0A5D\\u0A5F-\\u0A65\\u0A76-\\u0A80\\u0A84\\u0A8E\\u0A92\\u0AA9\\u0AB1\\u0AB4\\u0ABA\\u0ABB\\u0AC6\\u0ACA\\u0ACE\\u0ACF\\u0AD1-\\u0ADF\\u0AE4\\u0AE5\\u0AF0-\\u0AF8\\u0B00\\u0B04\\u0B0D\\u0B0E\\u0B11\\u0B12\\u0B29\\u0B31\\u0B34\\u0B3A\\u0B3B\\u0B45\\u0B46\\u0B49\\u0B4A\\u0B4E-\\u0B54\\u0B58-\\u0B5B\\u0B5E\\u0B64\\u0B65\\u0B70\\u0B72-\\u0B81\\u0B84\\u0B8B-\\u0B8D\\u0B91\\u0B96-\\u0B98\\u0B9B\\u0B9D\\u0BA0-\\u0BA2\\u0BA5-\\u0BA7\\u0BAB-\\u0BAD\\u0BBA-\\u0BBD\\u0BC3-\\u0BC5\\u0BC9\\u0BCE\\u0BCF\\u0BD1-\\u0BD6\\u0BD8-\\u0BE5\\u0BF0-\\u0BFF\\u0C0D\\u0C11\\u0C29\\u0C3A-\\u0C3C\\u0C45\\u0C49\\u0C4E-\\u0C54\\u0C57\\u0C5B-\\u0C5F\\u0C64\\u0C65\\u0C70-\\u0C7F\\u0C84\\u0C8D\\u0C91\\u0CA9\\u0CB4\\u0CBA\\u0CBB\\u0CC5\\u0CC9\\u0CCE-\\u0CD4\\u0CD7-\\u0CDD\\u0CDF\\u0CE4\\u0CE5\\u0CF0\\u0CF3-\\u0CFF\\u0D0D\\u0D11\\u0D45\\u0D49\\u0D4F-\\u0D53\\u0D58-\\u0D5E\\u0D64\\u0D65\\u0D70-\\u0D79\\u0D80\\u0D84\\u0D97-\\u0D99\\u0DB2\\u0DBC\\u0DBE\\u0DBF\\u0DC7-\\u0DC9\\u0DCB-\\u0DCE\\u0DD5\\u0DD7\\u0DE0-\\u0DE5\\u0DF0\\u0DF1\\u0DF4-\\u0E00\\u0E3B-\\u0E3F\\u0E4F\\u0E5A-\\u0E80\\u0E83\\u0E85\\u0E8B\\u0EA4\\u0EA6\\u0EBE\\u0EBF\\u0EC5\\u0EC7\\u0ECE\\u0ECF\\u0EDA\\u0EDB\\u0EE0-\\u0EFF\\u0F01-\\u0F17\\u0F1A-\\u0F1F\\u0F2A-\\u0F34\\u0F36\\u0F38\\u0F3A-\\u0F3D\\u0F48\\u0F6D-\\u0F70\\u0F85\\u0F98\\u0FBD-\\u0FC5\\u0FC7-\\u0FFF\\u104A-\\u104F\\u109E\\u109F\\u10C6\\u10C8-\\u10CC\\u10CE\\u10CF\\u10FB\\u1249\\u124E\\u124F\\u1257\\u1259\\u125E\\u125F\\u1289\\u128E\\u128F\\u12B1\\u12B6\\u12B7\\u12BF\\u12C1\\u12C6\\u12C7\\u12D7\\u1311\\u1316\\u1317\\u135B\\u135C\\u1360-\\u137F\\u1390-\\u139F\\u13F6\\u13F7\\u13FE-\\u1400\\u166D\\u166E\\u1680\\u169B-\\u169F\\u16EB-\\u16ED\\u16F9-\\u16FF\\u170D\\u1715-\\u171F\\u1735-\\u173F\\u1754-\\u175F\\u176D\\u1771\\u1774-\\u177F\\u17D4-\\u17D6\\u17D8-\\u17DB\\u17DE\\u17DF\\u17EA-\\u180A\\u180E\\u180F\\u181A-\\u181F\\u1879-\\u187F\\u18AB-\\u18AF\\u18F6-\\u18FF\\u191F\\u192C-\\u192F\\u193C-\\u1945\\u196E\\u196F\\u1975-\\u197F\\u19AC-\\u19AF\\u19CA-\\u19CF\\u19DA-\\u19FF\\u1A1C-\\u1A1F\\u1A5F\\u1A7D\\u1A7E\\u1A8A-\\u1A8F\\u1A9A-\\u1AA6\\u1AA8-\\u1AAF\\u1AC1-\\u1AFF\\u1B4C-\\u1B4F\\u1B5A-\\u1B6A\\u1B74-\\u1B7F\\u1BF4-\\u1BFF\\u1C38-\\u1C3F\\u1C4A-\\u1C4C\\u1C7E\\u1C7F\\u1C89-\\u1C8F\\u1CBB\\u1CBC\\u1CC0-\\u1CCF\\u1CD3\\u1CFB-\\u1CFF\\u1DFA\\u1F16\\u1F17\\u1F1E\\u1F1F\\u1F46\\u1F47\\u1F4E\\u1F4F\\u1F58\\u1F5A\\u1F5C\\u1F5E\\u1F7E\\u1F7F\\u1FB5\\u1FBD\\u1FBF-\\u1FC1\\u1FC5\\u1FCD-\\u1FCF\\u1FD4\\u1FD5\\u1FDC-\\u1FDF\\u1FED-\\u1FF1\\u1FF5\\u1FFD-\\u203E\\u2041-\\u2053\\u2055-\\u2070\\u2072-\\u207E\\u2080-\\u208F\\u209D-\\u20CF\\u20F1-\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211E-\\u2123\\u2125\\u2127\\u2129\\u212E\\u213A\\u213B\\u2140-\\u2144\\u214A-\\u214D\\u214F-\\u215F\\u2189-\\u24B5\\u24EA-\\u2BFF\\u2C2F\\u2C5F\\u2CE5-\\u2CEA\\u2CF4-\\u2CFF\\u2D26\\u2D28-\\u2D2C\\u2D2E\\u2D2F\\u2D68-\\u2D6E\\u2D70-\\u2D7E\\u2D97-\\u2D9F\\u2DA7\\u2DAF\\u2DB7\\u2DBF\\u2DC7\\u2DCF\\u2DD7\\u2DDF\\u2E00-\\u2E2E\\u2E30-\\u3004\\u3008-\\u3020\\u3030\\u3036\\u3037\\u303D-\\u3040\\u3097\\u3098\\u309B\\u309C\\u30A0\\u30FB\\u3100-\\u3104\\u3130\\u318F-\\u319F\\u31C0-\\u31EF\\u3200-\\u33FF\\u4DC0-\\u4DFF\\u9FFD-\\u9FFF\\uA48D-\\uA4CF\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA62C-\\uA63F\\uA673\\uA67E\\uA6F2-\\uA716\\uA720\\uA721\\uA789\\uA78A\\uA7C0\\uA7C1\\uA7CB-\\uA7F4\\uA828-\\uA82B\\uA82D-\\uA83F\\uA874-\\uA87F\\uA8C6-\\uA8CF\\uA8DA-\\uA8DF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA954-\\uA95F\\uA97D-\\uA97F\\uA9C1-\\uA9CE\\uA9DA-\\uA9DF\\uA9FF\\uAA37-\\uAA3F\\uAA4E\\uAA4F\\uAA5A-\\uAA5F\\uAA77-\\uAA79\\uAAC3-\\uAADA\\uAADE\\uAADF\\uAAF0\\uAAF1\\uAAF7-\\uAB00\\uAB07\\uAB08\\uAB0F\\uAB10\\uAB17-\\uAB1F\\uAB27\\uAB2F\\uAB5B\\uAB6A-\\uAB6F\\uABEB\\uABEE\\uABEF\\uABFA-\\uABFF\\uD7A4-\\uD7AF\\uD7C7-\\uD7CA\\uD7FC-\\uD7FF\\uE000-\\uF8FF\\uFA6E\\uFA6F\\uFADA-\\uFAFF\\uFB07-\\uFB12\\uFB18-\\uFB1C\\uFB29\\uFB37\\uFB3D\\uFB3F\\uFB42\\uFB45\\uFBB2-\\uFBD2\\uFD3E-\\uFD4F\\uFD90\\uFD91\\uFDC8-\\uFDEF\\uFDFC-\\uFDFF\\uFE10-\\uFE1F\\uFE30-\\uFE32\\uFE35-\\uFE4C\\uFE50-\\uFE6F\\uFE75\\uFEFD-\\uFF0F\\uFF1A-\\uFF20\\uFF3B-\\uFF3E\\uFF40\\uFF5B-\\uFF65\\uFFBF-\\uFFC1\\uFFC8\\uFFC9\\uFFD0\\uFFD1\\uFFD8\\uFFD9\\uFFDD-\\uFFFF]|\\uD800[\\uDC0C\\uDC27\\uDC3B\\uDC3E\\uDC4E\\uDC4F\\uDC5E-\\uDC7F\\uDCFB-\\uDD3F\\uDD75-\\uDDFC\\uDDFE-\\uDE7F\\uDE9D-\\uDE9F\\uDED1-\\uDEDF\\uDEE1-\\uDEFF\\uDF20-\\uDF2C\\uDF4B-\\uDF4F\\uDF7B-\\uDF7F\\uDF9E\\uDF9F\\uDFC4-\\uDFC7\\uDFD0\\uDFD6-\\uDFFF]|\\uD801[\\uDC9E\\uDC9F\\uDCAA-\\uDCAF\\uDCD4-\\uDCD7\\uDCFC-\\uDCFF\\uDD28-\\uDD2F\\uDD64-\\uDDFF\\uDF37-\\uDF3F\\uDF56-\\uDF5F\\uDF68-\\uDFFF]|\\uD802[\\uDC06\\uDC07\\uDC09\\uDC36\\uDC39-\\uDC3B\\uDC3D\\uDC3E\\uDC56-\\uDC5F\\uDC77-\\uDC7F\\uDC9F-\\uDCDF\\uDCF3\\uDCF6-\\uDCFF\\uDD16-\\uDD1F\\uDD3A-\\uDD7F\\uDDB8-\\uDDBD\\uDDC0-\\uDDFF\\uDE04\\uDE07-\\uDE0B\\uDE14\\uDE18\\uDE36\\uDE37\\uDE3B-\\uDE3E\\uDE40-\\uDE5F\\uDE7D-\\uDE7F\\uDE9D-\\uDEBF\\uDEC8\\uDEE7-\\uDEFF\\uDF36-\\uDF3F\\uDF56-\\uDF5F\\uDF73-\\uDF7F\\uDF92-\\uDFFF]|\\uD803[\\uDC49-\\uDC7F\\uDCB3-\\uDCBF\\uDCF3-\\uDCFF\\uDD28-\\uDD2F\\uDD3A-\\uDE7F\\uDEAA\\uDEAD-\\uDEAF\\uDEB2-\\uDEFF\\uDF1D-\\uDF26\\uDF28-\\uDF2F\\uDF51-\\uDFAF\\uDFC5-\\uDFDF\\uDFF7-\\uDFFF]|\\uD804[\\uDC47-\\uDC65\\uDC70-\\uDC7E\\uDCBB-\\uDCCF\\uDCE9-\\uDCEF\\uDCFA-\\uDCFF\\uDD35\\uDD40-\\uDD43\\uDD48-\\uDD4F\\uDD74\\uDD75\\uDD77-\\uDD7F\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDFF\\uDE12\\uDE38-\\uDE3D\\uDE3F-\\uDE7F\\uDE87\\uDE89\\uDE8E\\uDE9E\\uDEA9-\\uDEAF\\uDEEB-\\uDEEF\\uDEFA-\\uDEFF\\uDF04\\uDF0D\\uDF0E\\uDF11\\uDF12\\uDF29\\uDF31\\uDF34\\uDF3A\\uDF45\\uDF46\\uDF49\\uDF4A\\uDF4E\\uDF4F\\uDF51-\\uDF56\\uDF58-\\uDF5C\\uDF64\\uDF65\\uDF6D-\\uDF6F\\uDF75-\\uDFFF]|\\uD805[\\uDC4B-\\uDC4F\\uDC5A-\\uDC5D\\uDC62-\\uDC7F\\uDCC6\\uDCC8-\\uDCCF\\uDCDA-\\uDD7F\\uDDB6\\uDDB7\\uDDC1-\\uDDD7\\uDDDE-\\uDDFF\\uDE41-\\uDE43\\uDE45-\\uDE4F\\uDE5A-\\uDE7F\\uDEB9-\\uDEBF\\uDECA-\\uDEFF\\uDF1B\\uDF1C\\uDF2C-\\uDF2F\\uDF3A-\\uDFFF]|\\uD806[\\uDC3B-\\uDC9F\\uDCEA-\\uDCFE\\uDD07\\uDD08\\uDD0A\\uDD0B\\uDD14\\uDD17\\uDD36\\uDD39\\uDD3A\\uDD44-\\uDD4F\\uDD5A-\\uDD9F\\uDDA8\\uDDA9\\uDDD8\\uDDD9\\uDDE2\\uDDE5-\\uDDFF\\uDE3F-\\uDE46\\uDE48-\\uDE4F\\uDE9A-\\uDE9C\\uDE9E-\\uDEBF\\uDEF9-\\uDFFF]|\\uD807[\\uDC09\\uDC37\\uDC41-\\uDC4F\\uDC5A-\\uDC71\\uDC90\\uDC91\\uDCA8\\uDCB7-\\uDCFF\\uDD07\\uDD0A\\uDD37-\\uDD39\\uDD3B\\uDD3E\\uDD48-\\uDD4F\\uDD5A-\\uDD5F\\uDD66\\uDD69\\uDD8F\\uDD92\\uDD99-\\uDD9F\\uDDAA-\\uDEDF\\uDEF7-\\uDFAF\\uDFB1-\\uDFFF]|\\uD808[\\uDF9A-\\uDFFF]|\\uD809[\\uDC6F-\\uDC7F\\uDD44-\\uDFFF]|[\\uD80A\\uD80B\\uD80E-\\uD810\\uD812-\\uD819\\uD824-\\uD82B\\uD82D\\uD82E\\uD830-\\uD833\\uD837\\uD839\\uD83D\\uD83F\\uD87B-\\uD87D\\uD87F\\uD885-\\uDB3F\\uDB41-\\uDBFF][\\uDC00-\\uDFFF]|\\uD80D[\\uDC2F-\\uDFFF]|\\uD811[\\uDE47-\\uDFFF]|\\uD81A[\\uDE39-\\uDE3F\\uDE5F\\uDE6A-\\uDECF\\uDEEE\\uDEEF\\uDEF5-\\uDEFF\\uDF37-\\uDF3F\\uDF44-\\uDF4F\\uDF5A-\\uDF62\\uDF78-\\uDF7C\\uDF90-\\uDFFF]|\\uD81B[\\uDC00-\\uDE3F\\uDE80-\\uDEFF\\uDF4B-\\uDF4E\\uDF88-\\uDF8E\\uDFA0-\\uDFDF\\uDFE2\\uDFE5-\\uDFEF\\uDFF2-\\uDFFF]|\\uD821[\\uDFF8-\\uDFFF]|\\uD823[\\uDCD6-\\uDCFF\\uDD09-\\uDFFF]|\\uD82C[\\uDD1F-\\uDD4F\\uDD53-\\uDD63\\uDD68-\\uDD6F\\uDEFC-\\uDFFF]|\\uD82F[\\uDC6B-\\uDC6F\\uDC7D-\\uDC7F\\uDC89-\\uDC8F\\uDC9A-\\uDC9C\\uDC9F-\\uDFFF]|\\uD834[\\uDC00-\\uDD64\\uDD6A-\\uDD6C\\uDD73-\\uDD7A\\uDD83\\uDD84\\uDD8C-\\uDDA9\\uDDAE-\\uDE41\\uDE45-\\uDFFF]|\\uD835[\\uDC55\\uDC9D\\uDCA0\\uDCA1\\uDCA3\\uDCA4\\uDCA7\\uDCA8\\uDCAD\\uDCBA\\uDCBC\\uDCC4\\uDD06\\uDD0B\\uDD0C\\uDD15\\uDD1D\\uDD3A\\uDD3F\\uDD45\\uDD47-\\uDD49\\uDD51\\uDEA6\\uDEA7\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3\\uDFCC\\uDFCD]|\\uD836[\\uDC00-\\uDDFF\\uDE37-\\uDE3A\\uDE6D-\\uDE74\\uDE76-\\uDE83\\uDE85-\\uDE9A\\uDEA0\\uDEB0-\\uDFFF]|\\uD838[\\uDC07\\uDC19\\uDC1A\\uDC22\\uDC25\\uDC2B-\\uDCFF\\uDD2D-\\uDD2F\\uDD3E\\uDD3F\\uDD4A-\\uDD4D\\uDD4F-\\uDEBF\\uDEFA-\\uDFFF]|\\uD83A[\\uDCC5-\\uDCCF\\uDCD7-\\uDCFF\\uDD4C-\\uDD4F\\uDD5A-\\uDFFF]|\\uD83B[\\uDC00-\\uDDFF\\uDE04\\uDE20\\uDE23\\uDE25\\uDE26\\uDE28\\uDE33\\uDE38\\uDE3A\\uDE3C-\\uDE41\\uDE43-\\uDE46\\uDE48\\uDE4A\\uDE4C\\uDE50\\uDE53\\uDE55\\uDE56\\uDE58\\uDE5A\\uDE5C\\uDE5E\\uDE60\\uDE63\\uDE65\\uDE66\\uDE6B\\uDE73\\uDE78\\uDE7D\\uDE7F\\uDE8A\\uDE9C-\\uDEA0\\uDEA4\\uDEAA\\uDEBC-\\uDFFF]|\\uD83C[\\uDC00-\\uDD2F\\uDD4A-\\uDD4F\\uDD6A-\\uDD6F\\uDD8A-\\uDFFF]|\\uD83E[\\uDC00-\\uDFEF\\uDFFA-\\uDFFF]|\\uD869[\\uDEDE-\\uDEFF]|\\uD86D[\\uDF35-\\uDF3F]|\\uD86E[\\uDC1E\\uDC1F]|\\uD873[\\uDEA2-\\uDEAF]|\\uD87A[\\uDFE1-\\uDFFF]|\\uD87E[\\uDE1E-\\uDFFF]|\\uD884[\\uDF4B-\\uDFFF]|\\uDB40[\\uDC00-\\uDCFF\\uDDF0-\\uDFFF]/g\n","import { regex } from './regex.js'\n\nconst own = Object.hasOwnProperty\n\n/**\n * Slugger.\n */\nexport default class BananaSlug {\n  /**\n   * Create a new slug class.\n   */\n  constructor () {\n    /** @type {Record<string, number>} */\n    // eslint-disable-next-line no-unused-expressions\n    this.occurrences\n\n    this.reset()\n  }\n\n  /**\n   * Generate a unique slug.\n  *\n  * Tracks previously generated slugs: repeated calls with the same value\n  * will result in different slugs.\n  * Use the `slug` function to get same slugs.\n   *\n   * @param  {string} value\n   *   String of text to slugify\n   * @param  {boolean} [maintainCase=false]\n   *   Keep the current case, otherwise make all lowercase\n   * @return {string}\n   *   A unique slug string\n   */\n  slug (value, maintainCase) {\n    const self = this\n    let result = slug(value, maintainCase === true)\n    const originalSlug = result\n\n    while (own.call(self.occurrences, result)) {\n      self.occurrences[originalSlug]++\n      result = originalSlug + '-' + self.occurrences[originalSlug]\n    }\n\n    self.occurrences[result] = 0\n\n    return result\n  }\n\n  /**\n   * Reset - Forget all previous slugs\n   *\n   * @return void\n   */\n  reset () {\n    this.occurrences = Object.create(null)\n  }\n}\n\n/**\n * Generate a slug.\n *\n * Does not track previously generated slugs: repeated calls with the same value\n * will result in the exact same slug.\n * Use the `GithubSlugger` class to get unique slugs.\n *\n * @param  {string} value\n *   String of text to slugify\n * @param  {boolean} [maintainCase=false]\n *   Keep the current case, otherwise make all lowercase\n * @return {string}\n *   A unique slug string\n */\nexport function slug (value, maintainCase) {\n  if (typeof value !== 'string') return ''\n  if (!maintainCase) value = value.toLowerCase()\n  return value.replace(regex, '').replace(/ /g, '-')\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n/**\n * Get the rank (`1` to `6`) of headings (`h1` to `h6`).\n *\n * @param {Nodes} node\n *   Node to check.\n * @returns {number | undefined}\n *   Rank of the heading or `undefined` if not a heading.\n */\nexport function headingRank(node) {\n  const name = node.type === 'element' ? node.tagName.toLowerCase() : ''\n  const code =\n    name.length === 2 && name.charCodeAt(0) === 104 /* `h` */\n      ? name.charCodeAt(1)\n      : 0\n  return code > 48 /* `0` */ && code < 55 /* `7` */\n    ? code - 48 /* `0` */\n    : undefined\n}\n","/**\n * @typedef {import('hast').Root} Root\n */\n\n/**\n * @typedef Options\n *   Configuration (optional).\n * @property {string} [prefix='']\n *   Prefix to add in front of `id`s (default: `''`).\n */\n\nimport GithubSlugger from 'github-slugger'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {toString} from 'hast-util-to-string'\nimport {visit} from 'unist-util-visit'\n\n/** @type {Options} */\nconst emptyOptions = {}\nconst slugs = new GithubSlugger()\n\n/**\n * Add `id`s to headings.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeSlug(options) {\n  const settings = options || emptyOptions\n  const prefix = settings.prefix || ''\n\n  /**\n   * @param {Root} tree\n   *   Tree.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  return function (tree) {\n    slugs.reset()\n\n    visit(tree, 'element', function (node) {\n      if (headingRank(node) && !node.properties.id) {\n        node.properties.id = prefix + slugs.slug(toString(node))\n      }\n    })\n  }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Parents} Parents\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 an element.\n * @param {unknown} this\n *   Context object (`this`) to call `test` with\n * @param {unknown} [element]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   Position of `element` in its parent.\n * @param {Parents | null | undefined} [parent]\n *   Parent of `element`.\n * @returns {boolean}\n *   Whether this is an element and passes a test.\n *\n * @typedef {Array<TestFunction | string> | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary element.\n *\n *   * when `string`, checks that the element has that tag name\n *   * when `function`, see `TestFunction`\n *   * when `Array`, checks if one of the subtests pass\n *\n * @callback TestFunction\n *   Check if an element passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Element} element\n *   An element.\n * @param {number | undefined} [index]\n *   Position of `element` in its parent.\n * @param {Parents | undefined} [parent]\n *   Parent of `element`.\n * @returns {boolean | undefined | void}\n *   Whether this element passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `element` is an `Element` and whether it passes the given test.\n *\n * @param element\n *   Thing to check, typically `element`.\n * @param test\n *   Check for a specific element.\n * @param index\n *   Position of `element` in its parent.\n * @param parent\n *   Parent of `element`.\n * @param context\n *   Context object (`this`) to call `test` with.\n * @returns\n *   Whether `element` is an `Element` and passes a test.\n * @throws\n *   When an incorrect `test`, `index`, or `parent` is given; there is no error\n *   thrown when `element` is not a node or not an element.\n */\nexport const isElement =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends TestFunction>(element: unknown, test: Condition, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &\n   *   (<Condition extends string>(element: unknown, test: Condition, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &\n   *   ((element?: null | undefined) => false) &\n   *   ((element: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &\n   *   ((element: unknown, test?: Test, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [element]\n     * @param {Test | undefined} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parents | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (element, test, index, parent, context) {\n      const check = convertElement(test)\n\n      if (\n        index !== null &&\n        index !== undefined &&\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 !== null &&\n        parent !== undefined &&\n        (!parent.type || !parent.children)\n      ) {\n        throw new Error('Expected valid `parent`')\n      }\n\n      if (\n        (index === null || index === undefined) !==\n        (parent === null || parent === undefined)\n      ) {\n        throw new Error('Expected both `index` and `parent`')\n      }\n\n      return looksLikeAnElement(element)\n        ? check.call(context, element, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate a check 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 * an `element`, `index`, and `parent`.\n *\n * @param test\n *   A test for a specific element.\n * @returns\n *   A check.\n */\nexport const convertElement =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends TestFunction>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &\n   *   (<Condition extends string>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &\n   *   ((test?: null | undefined) => (element?: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test | null | undefined} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return element\n      }\n\n      if (typeof test === 'string') {\n        return tagNameFactory(test)\n      }\n\n      // Assume array.\n      if (typeof test === 'object') {\n        return anyFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or array as `test`')\n    }\n  )\n\n/**\n * Handle multiple tests.\n *\n * @param {Array<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] = convertElement(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 a string into a test for an element with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction tagNameFactory(check) {\n  return castFactory(tagName)\n\n  /**\n   * @param {Element} element\n   * @returns {boolean}\n   */\n  function tagName(element) {\n    return element.tagName === check\n  }\n}\n\n/**\n * Turn a custom test into a test for an element 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      looksLikeAnElement(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\n/**\n * Make sure something is an element.\n *\n * @param {unknown} element\n * @returns {element is Element}\n */\nfunction element(element) {\n  return Boolean(\n    element &&\n      typeof element === 'object' &&\n      'type' in element &&\n      element.type === 'element' &&\n      'tagName' in element &&\n      typeof element.tagName === 'string'\n  )\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Element}\n */\nfunction looksLikeAnElement(value) {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    'type' in value &&\n    'tagName' in value\n  )\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Root} Root\n *\n * @typedef {import('hast-util-is-element').Test} Test\n */\n\n/**\n * @typedef {'after' | 'append' | 'before' | 'prepend' | 'wrap'} Behavior\n *   Behavior.\n *\n * @callback Build\n *   Generate content.\n * @param {Readonly<Element>} element\n *   Current heading.\n * @returns {Array<ElementContent> | ElementContent}\n *   Content.\n *\n * @callback BuildProperties\n *   Generate properties.\n * @param {Readonly<Element>} element\n *   Current heading.\n * @returns {Properties}\n *   Properties.\n *\n * @typedef Options\n *   Configuration.\n * @property {Behavior | null | undefined} [behavior='prepend']\n *   How to create links (default: `'prepend'`).\n * @property {Readonly<ElementContent> | ReadonlyArray<ElementContent> | Build | null | undefined} [content]\n *   Content to insert in the link (default: if `'wrap'` then `undefined`,\n *   otherwise `<span class=\"icon icon-link\"></span>`);\n *   if `behavior` is `'wrap'` and `Build` is passed, its result replaces the\n *   existing content, otherwise the content is added after existing content.\n * @property {Readonly<ElementContent> | ReadonlyArray<ElementContent> | Build | null | undefined} [group]\n *   Content to wrap the heading and link with, if `behavior` is `'after'` or\n *   `'before'` (optional).\n * @property {Readonly<Properties> | BuildProperties | null | undefined} [headingProperties]\n *   Extra properties to set on the heading (optional).\n * @property {Readonly<Properties> | BuildProperties | null | undefined} [properties]\n *   Extra properties to set on the link when injecting (default:\n *   `{ariaHidden: true, tabIndex: -1}` if `'append'` or `'prepend'`, otherwise\n *   `undefined`).\n * @property {Test | null | undefined} [test]\n *   Extra test for which headings are linked (optional).\n */\n\n/**\n * @template T\n *   Kind.\n * @typedef {(\n *   T extends Record<any, any>\n *     ? {-readonly [k in keyof T]: Cloneable<T[k]>}\n *     : T\n * )} Cloneable\n *   Deep clone.\n *\n *   See: <https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1237#issuecomment-1345515448>\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {convertElement} from 'hast-util-is-element'\nimport {SKIP, visit} from 'unist-util-visit'\n\n/** @type {Element} */\nconst contentDefaults = {\n  type: 'element',\n  tagName: 'span',\n  properties: {className: ['icon', 'icon-link']},\n  children: []\n}\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Add links from headings back to themselves.\n *\n * ###### Notes\n *\n * This plugin only applies to headings with `id`s.\n * Use `rehype-slug` to generate `id`s for headings that don’t have them.\n *\n * Several behaviors are supported:\n *\n * *   `'prepend'` (default) — inject link before the heading text\n * *   `'append'` — inject link after the heading text\n * *   `'wrap'` — wrap the whole heading text with the link\n * *   `'before'` — insert link before the heading\n * *   `'after'` — insert link after the heading\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeAutolinkHeadings(options) {\n  const settings = options || emptyOptions\n  let properties = settings.properties\n  const headingOroperties = settings.headingProperties\n  const behavior = settings.behavior || 'prepend'\n  const content = settings.content\n  const group = settings.group\n  const is = convertElement(settings.test)\n\n  /** @type {import('unist-util-visit').Visitor<Element>} */\n  let method\n\n  if (behavior === 'after' || behavior === 'before') {\n    method = around\n  } else if (behavior === 'wrap') {\n    method = wrap\n  } else {\n    method = inject\n\n    if (!properties) {\n      properties = {ariaHidden: 'true', tabIndex: -1}\n    }\n  }\n\n  /**\n   * Transform.\n   *\n   * @param {Root} tree\n   *   Tree.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  return function (tree) {\n    visit(tree, 'element', function (node, index, parent) {\n      if (headingRank(node) && node.properties.id && is(node, index, parent)) {\n        Object.assign(node.properties, toProperties(headingOroperties, node))\n        return method(node, index, parent)\n      }\n    })\n  }\n\n  /** @type {import('unist-util-visit').Visitor<Element>} */\n  function inject(node) {\n    const children = toChildren(content || contentDefaults, node)\n    node.children[behavior === 'prepend' ? 'unshift' : 'push'](\n      create(node, toProperties(properties, node), children)\n    )\n\n    return [SKIP]\n  }\n\n  /** @type {import('unist-util-visit').Visitor<Element>} */\n  function around(node, index, parent) {\n    /* c8 ignore next -- uncommon */\n    if (typeof index !== 'number' || !parent) return\n\n    const children = toChildren(content || contentDefaults, node)\n    const link = create(node, toProperties(properties, node), children)\n    let nodes = behavior === 'before' ? [link, node] : [node, link]\n\n    if (group) {\n      const grouping = toNode(group, node)\n\n      if (grouping && !Array.isArray(grouping) && grouping.type === 'element') {\n        grouping.children = nodes\n        nodes = [grouping]\n      }\n    }\n\n    parent.children.splice(index, 1, ...nodes)\n\n    return [SKIP, index + nodes.length]\n  }\n\n  /** @type {import('unist-util-visit').Visitor<Element>} */\n  function wrap(node) {\n    /** @type {Array<ElementContent>} */\n    let before = node.children\n    /** @type {Array<ElementContent> | ElementContent} */\n    let after = []\n\n    if (typeof content === 'function') {\n      before = []\n      after = content(node)\n    } else if (content) {\n      after = clone(content)\n    }\n\n    node.children = [\n      create(\n        node,\n        toProperties(properties, node),\n        Array.isArray(after) ? [...before, ...after] : [...before, after]\n      )\n    ]\n\n    return [SKIP]\n  }\n}\n\n/**\n * Deep clone.\n *\n * @template T\n *   Kind.\n * @param {T} thing\n *   Thing to clone.\n * @returns {Cloneable<T>}\n *   Cloned thing.\n */\nfunction clone(thing) {\n  // Cast because it’s mutable now.\n  return /** @type {Cloneable<T>} */ (structuredClone(thing))\n}\n\n/**\n * Create an `a`.\n *\n * @param {Readonly<Element>} node\n *   Related heading.\n * @param {Properties | undefined} properties\n *   Properties to set on the link.\n * @param {Array<ElementContent>} children\n *   Content.\n * @returns {Element}\n *   Link.\n */\nfunction create(node, properties, children) {\n  return {\n    type: 'element',\n    tagName: 'a',\n    properties: {...properties, href: '#' + node.properties.id},\n    children\n  }\n}\n\n/**\n * Turn into children.\n *\n * @param {Readonly<ElementContent> | ReadonlyArray<ElementContent> | Build} value\n *   Content.\n * @param {Readonly<Element>} node\n *   Related heading.\n * @returns {Array<ElementContent>}\n *   Children.\n */\nfunction toChildren(value, node) {\n  const result = toNode(value, node)\n  return Array.isArray(result) ? result : [result]\n}\n\n/**\n * Turn into a node.\n *\n * @param {Readonly<ElementContent> | ReadonlyArray<ElementContent> | Build} value\n *   Content.\n * @param {Readonly<Element>} node\n *   Related heading.\n * @returns {Array<ElementContent> | ElementContent}\n *   Node.\n */\nfunction toNode(value, node) {\n  if (typeof value === 'function') return value(node)\n  return clone(value)\n}\n\n/**\n * Turn into properties.\n *\n * @param {Readonly<Properties> | BuildProperties | null | undefined} value\n *   Properties.\n * @param {Readonly<Element>} node\n *   Related heading.\n * @returns {Properties}\n *   Properties.\n */\nfunction toProperties(value, node) {\n  if (typeof value === 'function') return value(node)\n  return value ? clone(value) : {}\n}\n","import type { Plugin, Pluggable } from 'unified';\nimport type { Root, RootContent, Literal } from 'hast';\nimport { visit } from 'unist-util-visit';\n\n/**\n * Raw string of HTML embedded into HTML AST.\n */\nexport interface Raw extends Literal {\n  /**\n   * Node type.\n   */\n  type: 'raw'\n}\n\n// Register nodes in content.\ndeclare module 'hast' {\n  interface RootContentMap {\n    /**\n     * Raw string of HTML embedded into HTML AST.\n     */\n    raw: Raw\n  }\n  interface ElementContentMap {\n    /**\n     * Raw string of HTML embedded into HTML AST.\n     */\n    raw: Raw\n  }\n}\n\n\nexport type RehypeIgnoreOptions = {\n  /**\n   *  Character to use for opening delimiter, by default `rehype:ignore:start`\n   */\n  openDelimiter?: string;\n  /**\n   * Character to use for closing delimiter, by default `rehype:ignore:end`\n   */\n  closeDelimiter?: string;\n}\n\nconst rehypeIgnore: Plugin<[RehypeIgnoreOptions?], Root> = (options = {}) => {\n  const { openDelimiter = 'rehype:ignore:start', closeDelimiter = 'rehype:ignore:end' } = options;\n  return (tree) => {\n    visit(tree, (node: Root | RootContent, index, parent) => {\n      if (node.type === 'element' || node.type === 'root') {\n        // const start = node.children.findIndex((item) => item.type === 'comment' && item.value === openDelimiter);\n        // const end = node.children.findIndex((item) => item.type === 'comment' && item.value === closeDelimiter);\n        // if (start > -1 && end > -1) {\n        //   node.children = node.children.filter((_, idx) => idx < start || idx > end);\n        // }\n        let start = false;\n        node.children = node.children.filter((item) => {\n          if (item.type === 'raw' || item.type === 'comment') {\n            let str =  (item.value || '').trim();\n            str = str.replace(/^<!--(.*?)-->/, '$1')\n            if (str === openDelimiter) {\n                start = true;\n                return false;\n            }\n            if (str === closeDelimiter) {\n                start = false;\n                return false;\n            }\n          }\n          \n          return !start;\n        })\n      }\n    });\n  }\n}\n\nexport default rehypeIgnore;\n","export var octiconLink = {\n  type: 'element',\n  tagName: 'svg',\n  properties: {\n    className: 'octicon octicon-link',\n    viewBox: '0 0 16 16',\n    version: '1.1',\n    width: '16',\n    height: '16',\n    ariaHidden: 'true'\n  },\n  children: [{\n    type: 'element',\n    tagName: 'path',\n    children: [],\n    properties: {\n      fillRule: 'evenodd',\n      d: 'M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z'\n    }\n  }]\n};","import _extends from \"@babel/runtime/helpers/extends\";\nimport slug from 'rehype-slug';\nimport headings from 'rehype-autolink-headings';\nimport rehypeIgnore from 'rehype-ignore';\nimport { getCodeString } from 'rehype-rewrite';\nimport { octiconLink } from './nodes/octiconLink';\nimport { copyElement } from './nodes/copy';\nexport var rehypeRewriteHandle = (disableCopy, rewrite) => (node, index, parent) => {\n  if (node.type === 'element' && parent && parent.type === 'root' && /h(1|2|3|4|5|6)/.test(node.tagName)) {\n    var child = node.children && node.children[0];\n    if (child && child.properties && child.properties.ariaHidden === 'true') {\n      child.properties = _extends({\n        class: 'anchor'\n      }, child.properties);\n      child.children = [octiconLink];\n    }\n  }\n  if (node.type === 'element' && node.tagName === 'pre' && !disableCopy) {\n    var code = getCodeString(node.children);\n    node.children.push(copyElement(code));\n  }\n  rewrite && rewrite(node, index === null ? undefined : index, parent === null ? undefined : parent);\n};\nexport var defaultRehypePlugins = [slug, headings, rehypeIgnore];","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from 'react';\nimport rehypePrism from 'rehype-prism-plus';\nimport rehypeRewrite from 'rehype-rewrite';\nimport rehypeAttrs from 'rehype-attr';\nimport rehypeRaw from 'rehype-raw';\nimport MarkdownPreview from './preview';\nimport { reservedMeta } from './plugins/reservedMeta';\nimport { retrieveMeta } from './plugins/retrieveMeta';\nimport { rehypeRewriteHandle, defaultRehypePlugins } from './rehypePlugins';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport * from './Props';\nexport default /*#__PURE__*/React.forwardRef((props, ref) => {\n  var _props$disableCopy;\n  var rehypePlugins = [reservedMeta, rehypeRaw, retrieveMeta, ...defaultRehypePlugins, [rehypeRewrite, {\n    rewrite: rehypeRewriteHandle((_props$disableCopy = props.disableCopy) != null ? _props$disableCopy : false, props.rehypeRewrite)\n  }], [rehypeAttrs, {\n    properties: 'attr'\n  }], ...(props.rehypePlugins || []), [rehypePrism, {\n    ignoreMissing: true\n  }]];\n  return /*#__PURE__*/_jsx(MarkdownPreview, _extends({}, props, {\n    rehypePlugins: rehypePlugins,\n    ref: ref\n  }));\n});","export function copyElement(str) {\n  if (str === void 0) {\n    str = '';\n  }\n  return {\n    type: 'element',\n    tagName: 'div',\n    properties: {\n      class: 'copied',\n      'data-code': str\n    },\n    children: [{\n      type: 'element',\n      tagName: 'svg',\n      properties: {\n        className: 'octicon-copy',\n        ariaHidden: 'true',\n        viewBox: '0 0 16 16',\n        fill: 'currentColor',\n        height: 12,\n        width: 12\n      },\n      children: [{\n        type: 'element',\n        tagName: 'path',\n        properties: {\n          fillRule: 'evenodd',\n          d: 'M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 010 1.5h-1.5a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 00.25-.25v-1.5a.75.75 0 011.5 0v1.5A1.75 1.75 0 019.25 16h-7.5A1.75 1.75 0 010 14.25v-7.5z'\n        },\n        children: []\n      }, {\n        type: 'element',\n        tagName: 'path',\n        properties: {\n          fillRule: 'evenodd',\n          d: 'M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0114.25 11h-7.5A1.75 1.75 0 015 9.25v-7.5zm1.75-.25a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 00.25-.25v-7.5a.25.25 0 00-.25-.25h-7.5z'\n        },\n        children: []\n      }]\n    }, {\n      type: 'element',\n      tagName: 'svg',\n      properties: {\n        className: 'octicon-check',\n        ariaHidden: 'true',\n        viewBox: '0 0 16 16',\n        fill: 'currentColor',\n        height: 12,\n        width: 12\n      },\n      children: [{\n        type: 'element',\n        tagName: 'path',\n        properties: {\n          fillRule: 'evenodd',\n          d: 'M13.78 4.22a.75.75 0 010 1.06l-7.25 7.25a.75.75 0 01-1.06 0L2.22 9.28a.75.75 0 011.06-1.06L6 10.94l6.72-6.72a.75.75 0 011.06 0z'\n        },\n        children: []\n      }]\n    }]\n  };\n}","// @ts-ignore\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'github-corners': GithubCorners;\n  }\n  namespace JSX {\n    interface IntrinsicElements {\n      'github-corners': Partial<GithubCorners> | {\n        style?: Partial<CSSStyleDeclaration> | React.CSSProperties;\n      };\n    }\n  }\n}\n\nconst GITHUB_CORNERS_TEMPLATE = document.createElement(\"template\");\nGITHUB_CORNERS_TEMPLATE.innerHTML = `\n<style>\n:host a:hover .octo-arm { animation: octocat-wave 560ms ease-in-out; }\n@keyframes octocat-wave {\n  0%, 100% { transform: rotate(0); }\n  20%, 60% { transform: rotate(-25deg); }\n  40%, 80% { transform: rotate(10deg); }\n}\n@media (max-width:500px) {\n  :host a:hover .octo-arm { animation: none; }\n  :host .octo-arm { animation: octocat-wave 560ms ease-in-out; }\n}\n:host svg {\n  z-index: 99;\n  position: fixed;\n  border: 0px;\n  top: 0px;\n}\n</style>\n<svg width=\"54\" height=\"54\" viewBox=\"0 0 250 250\" aria-hidden=\"true\">\n  <a xlink:href=\"https://github.com/uiwjs/react-github-corners\" target=\"_blank\" rel=\"nofollow sponsored\" style=\"fill: rgb(21, 21, 19); color: rgb(255, 255, 255);\">\n    <g>\n      <path d=\"M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z\"></path>\n      <path d=\"M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2\" fill=\"currentColor\" class=\"octo-arm\" style=\"transform-origin: 130px 106px;\"></path>\n      <path d=\"M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z\" fill=\"currentColor\" class=\"octo-body\"></path>\n    </g>\n  </a>\n</svg>\n`;\n\nexport class GithubCorners extends HTMLElement {\n  /** Sets the z-order of a positioned element and its descendants or flex items. */\n  'z-index'?: string;\n  height?: string | number;\n  width?: string | number;\n  href?: string;\n  color?: string;\n  fill?: string;\n  position?: string;\n  target?: string;\n  top?: string;\n  left?: string;\n  right?: string = '0';\n  bottom?: string;\n  transform?: string;\n  private shadow: ShadowRoot\n  static get observedAttributes(): string[] {\n    return ['style', 'z-index', 'target', 'height', 'width', 'href', 'color', 'fill', 'position', 'top', 'left', 'right', 'bottom', 'transform'];\n  }\n  constructor() {\n    super();\n    this.shadow = this.attachShadow({ mode: 'open' });\n    this.shadow.appendChild(this.ownerDocument.importNode(GITHUB_CORNERS_TEMPLATE.content, true));\n    this.update()\n  }\n  private setAttr(name: string, value: string) {\n    const svg = this.shadow.querySelector('svg');\n    if (/(href)/.test(name.toLocaleLowerCase())) {\n      svg.lastElementChild.setAttribute('xlink:href', value);\n    } else if (/(color|fill)/.test(name.toLocaleLowerCase())) {\n      (svg.firstElementChild as HTMLAnchorElement).style[name as any] = value;\n    } else if (/(z-index|position|top|left|right|bottom|transform)/.test(name.toLocaleLowerCase())) {\n      svg.style[name as any] = value;\n    } else {\n      svg.setAttribute(name, value);\n    }\n  }\n  private update() {\n    ;[...this.getAttributeNames(), 'right'].forEach((name) => {\n      const value = this.getAttribute(name) || this[name as keyof GithubCorners] as any || '';\n      this.setAttr(name, value);\n    });\n  }\n  attributeChangedCallback(name: string, oldValue: string, newValue: string) {\n    if (oldValue !== newValue) {\n      this.setAttr(name, newValue);\n    }\n  }\n}\n\ncustomElements.define('github-corners', GithubCorners);","import _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/objectWithoutPropertiesLoose\";\nvar _excluded = [\"size\", \"fixed\", \"bottom\", \"zIndex\", \"className\", \"style\", \"bgColor\", \"color\", \"position\"];\nimport React from 'react';\nimport '@uiw/github-corners';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default function githubCorners(props) {\n  var {\n      size = 80,\n      fixed = false,\n      bottom,\n      zIndex,\n      style,\n      bgColor = '#151513',\n      color = '#fff',\n      position = 'right'\n    } = props,\n    otherProps = _objectWithoutPropertiesLoose(props, _excluded);\n  var styl = position === 'left' ? {\n    left: 0,\n    right: 'initial',\n    transform: 'scale(-1, 1)'\n  } : {\n    right: 0,\n    left: 'initial',\n    transform: 'scale(1, 1)'\n  };\n  if (bottom) {\n    styl.bottom = 0;\n    styl.top = 'initial';\n    styl.transform = position === 'left' ? 'scale(-1, -1)' : 'scale(1, -1)';\n  } else {\n    styl.bottom = 'initial';\n    styl.top = 0;\n  }\n  return /*#__PURE__*/_jsx(\"github-corners\", _extends({\n    target: \"__blank\",\n    width: size,\n    height: size,\n    href: props.href,\n    position: fixed ? 'fixed' : 'absolute',\n    \"z-index\": zIndex,\n    style: style,\n    fill: bgColor,\n    color: color\n  }, styl, otherProps));\n}","export default \"<p align=\\\"center\\\">\\n  <a href=\\\"https://jaywcjlove.github.io/iNotify\\\">\\n    <img alt=\\\"iNotify demo preview\\\" src=\\\"https://github.com/jaywcjlove/iNotify/blob/master/website/assets/iNotify.png?raw=true\\\">\\n  </a>\\n</p>\\n\\n<p align=\\\"center\\\">\\n  <a href=\\\"https://jaywcjlove.github.io/#/sponsor\\\">\\n    <img src=\\\"https://img.shields.io/badge/Buy%20me%20a%20coffee-048754?logo=buymeacoffee\\\">\\n  </a>\\n  <a href=\\\"https://github.com/jaywcjlove/iNotify/issues\\\">\\n    <img src=\\\"https://img.shields.io/github/issues/jaywcjlove/iNotify.svg\\\">\\n  </a>\\n  <a href=\\\"https://github.com/jaywcjlove/iNotify/network\\\">\\n    <img src=\\\"https://img.shields.io/github/forks/jaywcjlove/iNotify.svg\\\">\\n  </a>\\n  <a href=\\\"https://github.com/jaywcjlove/iNotify/stargazers\\\">\\n    <img src=\\\"https://img.shields.io/github/stars/jaywcjlove/iNotify.svg\\\">\\n  </a>\\n  <a href=\\\"https://github.com/jaywcjlove/iNotify/releases\\\">\\n    <img src=\\\"https://img.shields.io/github/release/jaywcjlove/iNotify.svg\\\">\\n  </a>\\n  <a href=\\\"https://www.npmjs.com/package/@wcjiang/notify\\\">\\n    <img src=\\\"https://img.shields.io/npm/v/@wcjiang/notify.svg\\\">\\n  </a>\\n  <a href=\\\"./README-zh.md\\\">\\n    <img src=\\\"https://jaywcjlove.github.io/sb/lang/chinese.svg\\\">\\n  </a>\\n</p>\\n\\n<!--dividing-->\\n\\nJS achieve the browser title flashing, scrolling, voice prompts, Chrome/Safari/FireFox/IE notice. has no dependencies. It not interfere with any JavaScript libraries or frameworks. has a reasonable footprint 5.05kb (gzipped: 1.75kb)，Official document [demo preview](https://jaywcjlove.github.io/iNotify)。\\n\\n## Installation\\n\\nYou will need Node.js installed on your system.\\n\\n```bash\\n# v2.x\\n$ npm install @wcjiang/notify --save\\n# v1.x\\n$ npm install title-notify --save\\n```\\n\\n> ⚠️: open in server. You can use [ssr](https://github.com/jaywcjlove/ssr) to quickly create a service..\\n\\n## Using\\n\\n```js\\nimport Notify from \\\"@wcjiang/notify\\\";\\n\\nconst notify = new Notify({\\n  message: \\\"There is message.\\\", // page title.\\n  effect: \\\"flash\\\", // flash | scroll, Flashing or scrolling\\n  openurl: \\\"https://github.com/jaywcjlove/iNotify\\\", // Click on the pop-up window to open the connection address\\n  onclick: () => {\\n    // Click on the pop-up window trip event\\n    // Programmatically closes a notification.\\n    notify.close();\\n    console.log(\\\"---\\\");\\n  },\\n  // Optional playback sound\\n  audio: {\\n    // You can use arrays to pass sound files in multiple formats.\\n    file: [\\\"msg.mp4\\\", \\\"msg.mp3\\\", \\\"msg.wav\\\"],\\n    // The following is also work.\\n    // file: 'msg.mp4'\\n  },\\n  // Title flashing, or scrolling speed\\n  interval: 1000,\\n  disableFavicon: false, // Optional, default false, if true, No longer overwrites the original favicon\\n  // Optional, default green background white text. Favicon\\n  updateFavicon: {\\n    // favicon font color\\n    textColor: \\\"#fff\\\",\\n    // Background color, set the background color to be transparent, set the value to \\\"transparent\\\"\\n    backgroundColor: \\\"#2F9A00\\\",\\n  },\\n  // Optional chrome browser notifications，\\n  // The default is not to fill in the following content\\n  notification: {\\n    title: \\\"Notification!\\\", // Set notification title\\n    icon: \\\"\\\", // Set notification icon, The default is Favicon\\n    body: \\\"You have a new message!\\\", // Set message content\\n  },\\n});\\n\\nnotify.player();\\n```\\n\\nOr manually download and link **notify.js** in your HTML, It can also be downloaded via [UNPKG](https://unpkg.com/@wcjiang/notify/dist/)：\\n\\n```html\\n<script src=\\\"https://unpkg.com/@wcjiang/notify/dist/notify.min.js\\\"></script>\\n<script type=\\\"text/javascript\\\">\\n  var notify = new Notify({\\n    effect: \\\"flash\\\",\\n    interval: 500,\\n  });\\n  notify.setFavicon(\\\"1\\\");\\n</script>\\n```\\n\\n## option\\n\\n- **message**: String, page title\\n- **effect**: String, flash | scroll | favicon, Flashing or scrolling\\n- **audio**: Optional playback sound\\n  - **file**: String/Array, You can use arrays to pass sound files in multiple formats.\\n- **interval**: Number, Title flashing, or scrolling speed.\\n- **openurl**: String, Click on the pop-up window to open the connection address\\n- **onclick**: Function, Click on the pop-up window trip event\\n- **updateFavicon**: Optional, default green background white text. Favicon\\n  - **textColor**: String, favicon font color.\\n  - **backgroundColor**: Background color, set the background color to be transparent, set the value to \\\"transparent\\\"\\n- **notification**: Optional chrome browser notifications, The default is not to fill in the following content\\n  - **title**: Set notification title `iNotify`\\n  - **icon**: Set notification icon, The default is Favicon\\n  - **body**: Set message content\\n\\n## isPermission\\n\\nDetermine if the browser bulletin notification is blocked.\\n\\n```js\\nnotify.isPermission();\\n```\\n\\n## Sound Settings\\n\\n### player\\n\\nPlay sound.\\n\\n```js\\nnotify.player();\\n```\\n\\n### loopPlay\\n\\nLoop the sound.\\n\\n```js\\nnotify.loopPlay();\\n```\\n\\n### stopPlay\\n\\nStop playing sound.\\n\\n```js\\nnotify.stopPlay();\\n```\\n\\n### setURL\\n\\nSet the playback sound URL.\\n\\n```js\\nnotify.setURL(\\\"msg.mp3\\\"); // Set one\\nnotify.setURL([\\\"msg.mp3\\\", \\\"msg.ogg\\\", \\\"msg.mp4\\\"]); // Set multiple\\n```\\n\\n## title\\n\\nThe latest version does not play the title blinking animation by default. After initialization, you need to call the `setTitle(true)` method to play the title animation.\\n\\n### setTitle\\n\\nSet the title.\\n\\n```js\\nnotify.setTitle(true); // Play animation\\nnotify.setTitle(\\\"New title\\\"); // Flashing new title\\nnotify.setTitle(); // Clear Blinking Show original title\\n```\\n\\n### setInterval\\n\\nSet time interval.\\n\\n```js\\nnotify.setInterval(2000);\\n```\\n\\n### close\\n\\nProgrammatically closes a notification.\\n\\n```js\\nnotify.close();\\n```\\n\\n### addTimer\\n\\nAdd counter\\n\\n```js\\nnotify.addTimer();\\n```\\n\\n### clearTimer\\n\\nClear counter.\\n\\n```js\\nnotify.clearTimer();\\n```\\n\\n## Favicon Notice\\n\\n### setFavicon\\n\\nSet `icon` to display numbers or text\\n\\n```js\\nnotify.setFavicon(10);\\n```\\n\\n### setFaviconColor\\n\\nSet `icon` display text color\\n\\n```js\\nnotify.setFaviconColor(\\\"#0043ff\\\");\\n```\\n\\n### setFaviconBackgroundColor\\n\\nSet `icon` to display text color\\n\\n```js\\nnotify.setFaviconBackgroundColor(\\\"#0043ff\\\");\\n// Set font and background color\\nnotify.setFaviconColor(\\\"#f5ff00\\\").setFaviconBackgroundColor(\\\"red\\\");\\n```\\n\\n### faviconClear\\n\\nClear digital display original `icon`.\\n\\n```js\\nnotify.faviconClear();\\n```\\n\\n## Chrome Notice\\n\\n### notify\\n\\nThe chrome notification pops up, and the parameters are not passed as default values...\\n\\n```js\\nnotify.notify();\\nnotify.notify({\\n  title: \\\"New notice\\\",\\n  body: \\\"Thunder, it’s raining...\\\",\\n  openurl: \\\"https://jaywcjlove.github.io\\\",\\n  onclick: function () {\\n    console.log(\\\"on click\\\");\\n  },\\n  onshow: function () {\\n    console.log(\\\"on show\\\");\\n  },\\n});\\n```\\n\\n- `title` The notification title that will be displayed.\\n- `dir` The direction of the text; its value can be auto (auto), ltr (left to right), or rtl (right to left).\\n- `icon` The URL of a picture that will be used to display the icon for the notification.\\n- `body` A string that is additionally displayed in the notification.\\n- `openurl` Click to open the specified URL.\\n- `onclick` Triggered whenever the user clicks on the notification.\\n- `onshow` Triggered when the notification is displayed.\\n- `onerror` Triggered whenever a notification encounters an error.\\n- `onclose` Triggered when the user closes the notification.\\n\\n## Other\\n\\n`notify.init().title;` Get the title.\\n\\n## Example\\n\\n### Example 1\\n\\n```js\\nfunction iconNotify(num) {\\n  if (!notify) {\\n    var notify = new Notify({\\n      effect: \\\"flash\\\",\\n      interval: 500,\\n    });\\n  }\\n  if (num === 0) {\\n    notify.faviconClear();\\n    notify.setTitle();\\n  } else if (num < 100) {\\n    notify.setFavicon(num);\\n    notify.setTitle(\\\"There is new message!\\\");\\n  } else if (num > 99) {\\n    notify.setFavicon(\\\"..\\\");\\n    notify.setTitle(\\\"There is new message!\\\");\\n  }\\n}\\n```\\n\\n### Example 2\\n\\n```js\\nvar notify = new Notify({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n});\\nnotify.setFavicon(\\\"1\\\");\\n```\\n\\n### Example 3\\n\\n```js\\nvar iN = new Notify({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n  message: \\\"There is new message!\\\",\\n  updateFavicon: {\\n    // Optional, default green background white\\n    textColor: \\\"#fff\\\", // favicon font color\\n    backgroundColor: \\\"#2F9A00\\\", // favicon background color\\n  },\\n}).setFavicon(10);\\n```\\n\\n### Example 4\\n\\n```js\\nvar iN = new Notify().setFavicon(5);\\n```\\n\\n### Example 5\\n\\n```js\\nvar iN = new Notify({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n  message: \\\"There is new message!\\\",\\n  audio: {\\n    file: \\\"msg.mp4\\\",\\n  },\\n})\\n  .setFavicon(10)\\n  .player();\\n```\\n\\n### Example 6\\n\\n```js\\nvar iN = new Notify({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n  message: \\\"There is new message!\\\",\\n  audio: {\\n    file: \\\"msg.mp4\\\", // You can use arrays to pass sound files in multiple formats.\\n  },\\n  notification: {\\n    title: \\\"Notification!\\\", // Set notification title\\n    icon: \\\"\\\", // Set notification icon, The default is Favicon\\n    body: \\\"You have a new message!\\\", // Set message content\\n  },\\n})\\n  .setFavicon(10)\\n  .player();\\n\\n// The chrome notification pops up, and the parameters are not passed as default values...\\niN.notify();\\n\\niN.notify({\\n  title: \\\"Notification!\\\", // Set notification title\\n  body: \\\"You have a new message!\\\", // Set message content\\n});\\n```\\n\\n### Example 7\\n\\n```js\\nvar iN = new Notify({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n  message: \\\"There is new message!\\\",\\n  audio: {\\n    file: [\\\"msg.mp4\\\", \\\"msg.mp3\\\", \\\"msg.wav\\\"],\\n  },\\n  notification: {\\n    title: \\\"Notification!\\\", // Set notification title\\n    body: \\\"You have a new message!\\\", // Set message content\\n  },\\n});\\n\\niN.setFavicon(10).player();\\n\\nvar n = new Notify();\\nn.init({\\n  effect: \\\"flash\\\",\\n  interval: 500,\\n  message: \\\"There is new message!\\\",\\n  audio: {\\n    file: [\\\"openSub.mp4\\\", \\\"openSub.mp3\\\", \\\"openSub.wav\\\"],\\n  },\\n  notification: {\\n    title: \\\"Notification!\\\",\\n    icon: \\\"\\\",\\n    body: \\\"You have a new message!\\\",\\n  },\\n});\\n\\nn.setFavicon(10).player();\\n```\\n\\n## Contributors\\n\\nAs always, thanks to our amazing contributors!\\n\\n<a href=\\\"https://github.com/jaywcjlove/iNotify/graphs/contributors\\\">\\n  <img src=\\\"https://jaywcjlove.github.io/iNotify/CONTRIBUTORS.svg\\\" />\\n</a>\\n\\nMade with [contributors](https://github.com/jaywcjlove/github-action-contributors).\\n\\n## License\\n\\n[MIT © Kenny Wong](https://github.com/jaywcjlove/iNotify/blob/master/MIT-LICENSE)\\n\";","// extracted by mini-css-extract-plugin\nexport default {\"shields\":\"GithubShields_shields__olqv7\"};","import React from 'react';\nimport styles from './GithubShields.module.less';\n\nexport default function GithubShields({ source }) {\n  return (\n    <div className={styles.shields}>\n      {source.map((item, idx) => (\n        <a key={idx} href={item.href} target=\"_blank\" rel=\"noopener noreferrer\">\n          <img src={item.img} alt=\"\" />\n        </a>\n      ))}\n    </div>\n  );\n}\n","// extracted by mini-css-extract-plugin\nexport default {\"button\":\"index_button__nNd7C\"};","import React from 'react';\nimport classNames from 'classnames';\nimport styles from './index.module.less';\n\nconst index = ({\n  className, children, type = 'button', ...props\n}) => {\n  return (\n    <button className={classNames(className, styles.button)} type={type} {...props}> {children} </button>\n  );\n};\n\nexport default index;\n","// extracted by mini-css-extract-plugin\nexport default {\"footer\":\"Footer_footer__6AZaJ\"};","import React from 'react';\nimport style from './Footer.module.less';\n\nexport default function Footer({ name, href, year }) {\n  return (\n    <div className={style.footer}>\n      <div>\n        Licensed under MIT. (Yes it&acute;s free and\n        <a href=\"https://github.com/jaywcjlove/hotkeys\">\n          open-sourced\n        </a>\n        )\n      </div>\n      <div>\n        ©\n        <a target=\"_blank\" rel=\"noopener noreferrer\" href={href}>\n          {name}\n        </a>\n        {year}\n      </div>\n    </div>\n  );\n}\n","// extracted by mini-css-extract-plugin\nexport default {\"panel\":\"index_panel__AWhli\",\"button\":\"index_button__UNTJM\"};","// 提醒是否添加chrome通知\nif (window.Notification && window.Notification.permission !== 'granted') {\n  window.Notification.requestPermission().then((permission) => {\n    if (permission === 'denied') {\n      console.log(\"Permission wasn't granted. Allow a retry.\");\n      return;\n    }\n    if (permission === 'default') {\n      console.log('The permission request was dismissed.');\n      return;\n    }\n  });\n}\nlet iconURL = '';\nconst repeatableEffects = ['flash', 'scroll'];\n\nconst defaultNotification = {\n  title: 'iNotify !',\n  body: 'You have a new message.',\n  openurl: '',\n};\nfunction jsonArguments(news, olds) {\n  for (const a in olds) {\n    if (news[a]) {\n      olds[a] = news[a];\n    }\n  }\n  return olds;\n}\nfunction isArray(value) {\n  return Object.prototype.toString.call(value) === '[object Array]';\n}\n\nfunction createAudio(url) {\n  const audioElm = document.createElement('audio');\n  audioElm.autoplay = true;\n  audioElm.muted = true;\n  let source;\n  if (isArray(url) && url.length > 0) {\n    for (let i = 0; i < url.length; i++) {\n      source = document.createElement('source');\n      source.src = url[i];\n      source.type = `audio/${getExtension(url[i])}`;\n      audioElm.appendChild(source);\n    }\n  } else {\n    audioElm.src = url;\n  }\n  return audioElm;\n}\n\nfunction getFavicon(setting) {\n  let ic = document.querySelectorAll('link[rel~=shortcut]')[0];\n  if (!ic) {\n    ic = changeFavicon('O', setting);\n  }\n  return ic;\n}\n\nfunction getExtension(fileName) {\n  return fileName.match(/\\.([^\\\\.]+)$/)[1];\n}\n\nfunction changeFavicon(num, settings) {\n  const canvas = document.createElement('canvas');\n  const head = document.getElementsByTagName('head')[0];\n  const linkTag = document.createElement('link');\n  let ctx = null;\n\n  canvas.height = 32;\n  canvas.width = 32;\n  ctx = canvas.getContext('2d');\n  ctx.fillStyle = settings.backgroundColor;\n  ctx.fillRect(0, 0, 32, 32);\n\n  ctx.textAlign = 'center';\n  ctx.font = '22px \"helvetica\", sans-serif';\n  ctx.fillStyle = settings.textColor;\n  num && ctx.fillText(num, 16, 24);\n\n  // 生成到\n  linkTag.setAttribute('rel', 'shortcut icon');\n  linkTag.setAttribute('type', 'image/x-icon');\n  linkTag.setAttribute('id', `new${settings.id}`);\n  linkTag.setAttribute('href', canvas.toDataURL('image/png'));\n  iconURL = canvas.toDataURL('image/png');\n  return head.appendChild(linkTag);\n}\n\nfunction Notify(config) {\n  if (config) {\n    this.init(config);\n  }\n}\n\nNotify.prototype = {\n  init(config) {\n    if (!config) {\n      config = {};\n    }\n    this.interval = config.interval || 100; // 响应时长\n    this.effect = config.effect || 'flash'; // 效果\n    this.title = config.title || document.title; // 标题\n    this.message = config.message || this.title; // 原来的标题\n    this.onclick = config.onclick || this.onclick; // 点击事件\n    this.openurl = config.openurl || this.openurl; // 点击事件\n    this.disableFavicon = config.disableFavicon || false; // 禁用favicon 默认开启\n    this.updateFavicon = !this.disableFavicon\n      && (config.updateFavicon || {\n        id: 'favicon',\n        textColor: '#fff',\n        backgroundColor: '#2F9A00',\n      });\n    this.audio = config.audio || '';\n    this.favicon = !this.disableFavicon && getFavicon(this.updateFavicon);\n    this.cloneFavicon = this.favicon && this.favicon.cloneNode(true);\n    iconURL = config.notification && config.notification.icon\n      ? config.notification.icon\n      : config.icon\n        ? config.icon\n        : this.favicon.href;\n    defaultNotification.icon = iconURL;\n    this.notification = config.notification || defaultNotification;\n    // 初始化生成声音文件节点\n    if (this.audio && this.audio.file) {\n      this.setURL(this.audio.file);\n    }\n    return this;\n  },\n  render() {\n    if (this.effect === 'flash') {\n      document.title = this.title === document.title ? this.message : this.title;\n    } else if (this.effect === 'scroll') {\n      const title = this.message || document.title;\n      if (!this.scrollTitle || !this.scrollTitle.slice(1)) {\n        document.title = title;\n        this.scrollTitle = title;\n      } else {\n        this.scrollTitle = this.scrollTitle.slice(1);\n        document.title = this.scrollTitle;\n      }\n    }\n    return this;\n  },\n  // 设置标题\n  setTitle(str) {\n    if (str === true) {\n      if (repeatableEffects.indexOf(this.effect) >= 0) {\n        return this.addTimer();\n      }\n    } else if (str) {\n      this.message = str;\n      this.scrollTitle = '';\n      this.addTimer();\n    } else {\n      this.clearTimer();\n    }\n    return this;\n  },\n  setURL(url) {\n    if (url) {\n      if (this.audioElm) {\n        this.audioElm.remove();\n      }\n      this.audioElm = createAudio(url);\n      document.body.appendChild(this.audioElm);\n    }\n    return this;\n  },\n  loopPlay() {\n    this.setURL();\n    this.audioElm.loop = true;\n    this.player();\n    return this;\n  },\n  stopPlay() {\n    this.audioElm && ((this.audioElm.loop = false), this.audioElm.pause());\n    return this;\n  },\n  // 播放声音\n  player() {\n    if (!this.audio || !this.audio.file) {\n      return;\n    }\n    if (!this.audioElm) {\n      this.audioElm = createAudio(this.audio.file);\n      document.body.appendChild(this.audioElm);\n    }\n    this.audioElm.muted = false;\n    const resp = this.audioElm.play();\n    if (resp !== undefined) {\n      resp.then(() => {\n        // autoplay starts!\n      }).catch(() => {\n        // show error\n      });\n    }\n    return this;\n  },\n  notify(json) {\n    let nt = this.notification;\n    const url = json.openurl ? json.openurl : this.openurl;\n    const onclick = json.onclick ? json.onclick : this.onclick;\n    if (window.Notification) {\n      if (json) {\n        nt = jsonArguments(json, nt);\n      } else {\n        nt = defaultNotification;\n      }\n      const option = {};\n      option.icon = json.icon ? json.icon : iconURL;\n      option.body = nt.body || json.body;\n      if (json.dir) option.dir = json.dir;\n      const n = new Notification(nt.title || json.title, option);\n      n.onclick = () => {\n        onclick && typeof onclick === 'function' && onclick(n);\n        url && window.open(url);\n      };\n      n.onshow = () => {\n        json.onshow && typeof json.onshow === 'function' && json.onshow(n);\n      };\n      n.onclose = () => {\n        json.onclose && typeof json.onclose === 'function' && json.onclose(n);\n      };\n      n.onerror = () => {\n        json.onerror && typeof json.onerror === 'function' && json.onerror(n);\n      };\n      this.Notifiy = n;\n    }\n    return this;\n  },\n  // 是否许可弹框通知\n  isPermission() {\n    return window.Notification && Notification.permission === 'granted';\n  },\n  // 设置时间间隔\n  setInterval(num) {\n    if (num) {\n      this.interval = num;\n      this.addTimer();\n    }\n    return this;\n  },\n  // 设置网页Icon\n  setFavicon(num) {\n    if (!num && num !== 0) {\n      return this.faviconClear();\n    }\n    const oldicon = document.getElementById(`new${this.updateFavicon.id}`);\n    if (this.favicon) {\n      this.favicon.remove();\n    }\n    if (oldicon) {\n      oldicon.remove();\n    }\n    this.updateFavicon.num = num;\n    changeFavicon(num, this.updateFavicon);\n    return this;\n  },\n  // 设置 Favicon 文字颜色\n  setFaviconColor(color) {\n    if (color) {\n      this.faviconRemove();\n      this.updateFavicon.textColor = color;\n      changeFavicon(this.updateFavicon.num, this.updateFavicon);\n    }\n    return this;\n  },\n  // 设置 Favicon 背景颜色\n  setFaviconBackgroundColor(color) {\n    if (color) {\n      this.faviconRemove();\n      this.updateFavicon.backgroundColor = color;\n      changeFavicon(this.updateFavicon.num, this.updateFavicon);\n    }\n    return this;\n  },\n  faviconRemove() {\n    this.faviconClear();\n    const oldicon = document.getElementById(`new${this.updateFavicon.id}`);\n    if (this.favicon) {\n      this.favicon.remove();\n    }\n    if (oldicon) {\n      oldicon.remove();\n    }\n  },\n  // 添加计数器\n  addTimer() {\n    this.clearTimer();\n    if (repeatableEffects.indexOf(this.effect) >= 0) {\n      this.timer = setInterval(this.render.bind(this), this.interval);\n    }\n    return this;\n  },\n  close() {\n    if (this.Notifiy) this.Notifiy.close();\n  },\n  // 清除Icon\n  faviconClear() {\n    const newicon = document.getElementById(`new${this.updateFavicon.id}`);\n    const head = document.getElementsByTagName('head')[0];\n    const ficon = document.querySelectorAll('link[rel~=shortcut]');\n    newicon && newicon.remove();\n    if (ficon.length > 0) {\n      for (let i = 0; i < ficon.length; i++) {\n        ficon[i].remove();\n      }\n    }\n    head.appendChild(this.cloneFavicon);\n    iconURL = this.cloneFavicon.href;\n    this.favicon = this.cloneFavicon;\n    return this;\n  },\n  // 清除计数器\n  clearTimer() {\n    this.timer && clearInterval(this.timer);\n    document.title = this.title;\n    return this;\n  },\n};\n\nexport default Notify;\n","import React, { Component } from 'react';\nimport MarkdownPreview from '@uiw/react-markdown-preview';\nimport '@wcj/dark-mode';\nimport GitHubCorners from '@uiw/react-github-corners';\nimport DocumentStr from '../README.md';\nimport GithubShields from './components/GithubShields';\nimport Button from './components/Button';\nimport Footer from './components/Footer';\nimport styles from './styles/index.module.less';\nimport './styles/reset.less';\nimport Notify from '..';\nimport notifyImg from './assets/iNotify.png';\n\nimport mp4 from './assets/msg.mp4';\nimport mp3 from './assets/msg.mp3';\nimport wav from './assets/msg.wav';\n\nexport default class App extends Component {\n  constructor() {\n    super();\n    this.state = {\n      button: [\n        {\n          label: 'Popup box',\n          onClick: () => {\n            this.iN.notify({\n              title: 'Welcome to iNotify!',\n              body: 'You are opening the iNotify website!',\n            });\n          },\n        },\n        {\n          label: 'Play sound',\n          onClick: () => {\n            this.iN.player();\n          },\n        },\n        {\n          label: 'Stop playing sound',\n          onClick: () => {\n            this.iN.stopPlay();\n          },\n        },\n        {\n          label: 'Stop title animation',\n          onClick: () => {\n            this.iN.setTitle();\n          },\n        },\n        {\n          label: 'Play title animation',\n          onClick: () => {\n            this.iN.setTitle(true);\n          },\n        },\n        {\n          label: 'Title animation, update title',\n          onClick: () => {\n            this.iN.setTitle('Title animation, update title.');\n          },\n        },\n        {\n          label: 'Number of messages',\n          onClick: () => {\n            const num = Math.floor(Math.random() * 10) || 2;\n            this.iN.faviconClear().setFavicon(num + 1);\n          },\n        },\n        {\n          label: 'Clear the messages number',\n          onClick: () => {\n            this.iN.faviconClear();\n          },\n        },\n        {\n          label: 'Open website.',\n          onClick: () => {\n            this.iN.notify({\n              title: 'Welcome to iNotify!',\n              body: 'You are opening the iNotify website!',\n              openurl: 'https://github.com/jaywcjlove/iNotify',\n              onclick: () => {\n                console.log('on click');\n                this.iN.close();\n              },\n              onshow: () => {\n                console.log('on show');\n              },\n            });\n          },\n        },\n        {\n          label: 'Favicon Font color',\n          onClick: () => {\n            this.iN.setFaviconColor('#0043ff');\n          },\n        },\n        {\n          label: 'Favicon Background color',\n          onClick: () => {\n            this.iN.setFaviconColor('#f5ff00').setFaviconBackgroundColor('red');\n          },\n        },\n      ],\n    };\n  }\n\n  componentDidMount() {\n    this.iN = new Notify({\n      // effect: 'flash',\n      effect: 'scroll',\n      interval: 300,\n      message: '有消息拉！',\n      audio: {\n        file: [mp4, mp3, wav],\n      },\n      notification: {\n        title: '通知！',\n        body: '您来了一条新消息',\n      },\n      onclick: () => {\n        console.log('on click');\n        this.iN.close();\n      },\n    });\n    this.iN.setTitle('New news, welcome to iNotify!')\n      .notify({\n        title: 'Welcome to iNotify!',\n        body: 'You are opening the iNotify website!',\n        openurl: 'https://github.com/jaywcjlove/iNotify',\n      })\n      .player();\n  }\n\n  render() {\n    const { button } = this.state;\n    let DocumentStrSource = DocumentStr;\n    if (DocumentStrSource) DocumentStrSource = DocumentStr.replace(/([\\s\\S]*)<!--dividing-->/, '');\n    return (\n      <div className={styles.wapper}>\n        <dark-mode permanent light=\"Dart\" dark=\"Light\" style={{ position: 'fixed', top: 8, left: 10 }} />\n        <GitHubCorners fixed target=\"__blank\" zIndex={10} href=\"https://github.com/jaywcjlove/iNotify\" />\n        <div className={styles.panel}>\n          <h1>\n            iNotify\n          </h1>\n          <img src={notifyImg} alt=\"iNotify\" />\n        </div>\n        <div className={styles.button}>\n          {button.map((item, key) => {\n            return (\n              <Button key={key} onClick={item.onClick}>\n                {item.label}\n              </Button>\n            );\n          })}\n        </div>\n        <MarkdownPreview style={{ maxWidth: 1024, margin: '0 auto' }} source={DocumentStrSource} />\n        <GithubShields\n          source={[\n            {\n              href: 'https://github.com/jaywcjlove/iNotify/stargazers',\n              img: 'https://img.shields.io/github/stars/jaywcjlove/iNotify.svg?style=social',\n            },\n            {\n              href: 'https://github.com/jaywcjlove/iNotify/network',\n              img: 'https://img.shields.io/github/forks/jaywcjlove/iNotify.svg?style=social',\n            },\n            {\n              href: 'https://github.com/jaywcjlove/iNotify/watchers',\n              img: 'https://img.shields.io/github/watchers/jaywcjlove/iNotify.svg?style=social&label=Watch',\n            },\n            {\n              href: 'https://github.com/jaywcjlove/followers',\n              img: 'https://img.shields.io/github/followers/jaywcjlove.svg?style=social',\n            },\n          ]}\n        />\n        <Footer name=\"Kenny Wong\" href=\"http://jaywcjlove.github.io\" year=\"2015-present\" />\n      </div>\n    );\n  }\n}\n","import * as ReactDOMClient from 'react-dom/client';\nimport React from 'react';\nimport App from './App';\n\nconst container = document.getElementById('root');\nconst root = ReactDOMClient.createRoot(container);\nroot.render(<App />);\n","/**\n * *** This styling is an extra step which is likely not required. ***\n * https://github.com/w3c/clipboard-apis/blob/master/explainer.adoc#writing-to-the-clipboard\n * \n * Why is it here? To ensure:\n * \n * 1. the element is able to have focus and selection.\n * 2. if element was to flash render it has minimal visual impact.\n * 3. less flakyness with selection and copying which **might** occur if\n *     the textarea element is not visible.\n *\n *   The likelihood is the element won't even render, not even a flash,\n *   so some of these are just precautions. However in IE the element\n *   is visible whilst the popup box asking the user for permission for\n *   the web page to copy to the clipboard.\n *  \n *   Place in top-left corner of screen regardless of scroll position.\n *\n * @typedef CopyTextToClipboard\n * @property {(text: string, method?: (isCopy: boolean) => void) => void} void\n * @returns {void}\n * \n * @param {string} text \n * @param {CopyTextToClipboard} cb \n */\nexport default function copyTextToClipboard(text, cb) {\n  if (typeof document === \"undefined\") return;\n  const el = document.createElement('textarea');\n  el.value = text;\n  el.setAttribute('readonly', '');\n  el.style = {\n    position: 'absolute',\n    left: '-9999px',\n  }\n  document.body.appendChild(el);\n  const selected = document.getSelection().rangeCount > 0 ? document.getSelection().getRangeAt(0) : false;\n  el.select();\n  let isCopy = false;\n  try {\n    const successful = document.execCommand('copy');\n    isCopy = !!successful;\n  } catch (err) {\n    isCopy = false;\n  }\n  document.body.removeChild(el);\n  if (selected && document.getSelection) {\n    document.getSelection().removeAllRanges();\n    document.getSelection().addRange(selected);\n  }\n  cb && cb(isCopy);\n};\n","/**\n * @package @wcj/dark-mode\n * Web Component that toggles dark mode 🌒\n * Github: https://github.com/jaywcjlove/dark-mode.git\n * Website: https://jaywcjlove.github.io/dark-mode\n * \n * Licensed under the MIT license.\n * @license Copyright © 2022. Licensed under the MIT License\n * @author kenny wong <wowohoo@qq.com>\n */\nconst t=document;const e=\"_dark_mode_theme_\";const s=\"permanent\";const o=\"colorschemechange\";const i=\"permanentcolorscheme\";const h=\"light\";const r=\"dark\";const n=(t,e,s=e)=>{Object.defineProperty(t,s,{enumerable:true,get(){const t=this.getAttribute(e);return t===null?\"\":t},set(t){this.setAttribute(e,t)}})};const c=(t,e,s=e)=>{Object.defineProperty(t,s,{enumerable:true,get(){return this.hasAttribute(e)},set(t){if(t){this.setAttribute(e,\"\")}else{this.removeAttribute(e)}}})};class a extends HTMLElement{static get observedAttributes(){return[\"mode\",h,r,s]}LOCAL_NANE=e;constructor(){super();this.t()}connectedCallback(){n(this,\"mode\");n(this,r);n(this,h);c(this,s);const a=localStorage.getItem(e);if(a&&[h,r].includes(a)){this.mode=a;this.permanent=true}if(this.permanent&&!a){localStorage.setItem(e,this.mode)}const l=[h,r].includes(a);if(this.permanent&&a){this.o()}else{if(window.matchMedia&&window.matchMedia(\"(prefers-color-scheme: dark)\").matches){this.mode=r;this.o()}if(window.matchMedia&&window.matchMedia(\"(prefers-color-scheme: light)\").matches){this.mode=h;this.o()}}if(!this.permanent&&!l){window.matchMedia(\"(prefers-color-scheme: light)\").onchange=t=>{this.mode=t.matches?h:r;this.o()};window.matchMedia(\"(prefers-color-scheme: dark)\").onchange=t=>{this.mode=t.matches?r:h;this.o()}}const d=new MutationObserver(((s,h)=>{this.mode=t.documentElement.dataset.colorMode;if(this.permanent&&l){localStorage.setItem(e,this.mode);this.i(i,{permanent:this.permanent})}this.h();this.i(o,{colorScheme:this.mode})}));d.observe(t.documentElement,{attributes:true});this.i(o,{colorScheme:this.mode});this.h()}attributeChangedCallback(t,s,o){if(t===\"mode\"&&s!==o&&[h,r].includes(o)){const t=localStorage.getItem(e);if(this.mode===t){this.mode=o;this.h();this.o()}else if(this.mode&&this.mode!==t){this.h();this.o()}}else if((t===h||t===r)&&s!==o){this.h()}if(t===\"permanent\"&&typeof this.permanent===\"boolean\"){this.permanent?localStorage.setItem(e,this.mode):localStorage.removeItem(e)}}o(){t.documentElement.setAttribute(\"data-color-mode\",this.mode)}h(){this.icon.textContent=this.mode===h?\"🌒\":\"🌞\";this.text.textContent=this.mode===h?this.getAttribute(r):this.getAttribute(h);if(!this.text.textContent&&this.text.parentElement&&this.text){this.text.parentElement.removeChild(this.text)}}t(){var s=this.attachShadow({mode:\"open\"});this.label=t.createElement(\"span\");this.label.setAttribute(\"class\",\"wrapper\");this.label.onclick=()=>{this.mode=this.mode===h?r:h;if(this.permanent){localStorage.setItem(e,this.mode)}this.o();this.h()};s.appendChild(this.label);this.icon=t.createElement(\"span\");this.label.appendChild(this.icon);this.text=t.createElement(\"span\");this.label.appendChild(this.text);const o=`\\n[data-color-mode*='dark'], [data-color-mode*='dark'] body {\\n  color-scheme: dark;\\n  --color-theme-bg: #0d1117;\\n  --color-theme-text: #c9d1d9;\\n  background-color: var(--color-theme-bg);\\n  color: var(--color-theme-text);\\n}\\n\\n[data-color-mode*='light'], [data-color-mode*='light'] body {\\n  color-scheme: light;\\n  --color-theme-bg: #fff;\\n  --color-theme-text: #24292f;\\n  background-color: var(--color-theme-bg);\\n  color: var(--color-theme-text);\\n}`;const i=\"_dark_mode_style_\";const n=t.getElementById(i);if(!n){var c=t.createElement(\"style\");c.id=i;c.textContent=o;t.head.appendChild(c)}var a=t.createElement(\"style\");a.textContent=`\\n    .wrapper { cursor: pointer; user-select: none; position: relative; }\\n    .wrapper > span + span { margin-left: .4rem; }\\n    `;s.appendChild(a)}i(t,e){this.dispatchEvent(new CustomEvent(t,{bubbles:true,composed:true,detail:e}))}}customElements.define(\"dark-mode\",a);","module.exports = {\n\ttrueFunc: function trueFunc(){\n\t\treturn true;\n\t},\n\tfalseFunc: function falseFunc(){\n\t\treturn false;\n\t}\n};","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames() {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","/**\n * @param {string} string    The string to parse\n * @returns {Array<number>}  Returns an energetic array.\n */\nfunction parsePart(string) {\n  let res = [];\n  let m;\n\n  for (let str of string.split(\",\").map((str) => str.trim())) {\n    // just a number\n    if (/^-?\\d+$/.test(str)) {\n      res.push(parseInt(str, 10));\n    } else if (\n      (m = str.match(/^(-?\\d+)(-|\\.\\.\\.?|\\u2025|\\u2026|\\u22EF)(-?\\d+)$/))\n    ) {\n      // 1-5 or 1..5 (equivalent) or 1...5 (doesn't include 5)\n      let [_, lhs, sep, rhs] = m;\n\n      if (lhs && rhs) {\n        lhs = parseInt(lhs);\n        rhs = parseInt(rhs);\n        const incr = lhs < rhs ? 1 : -1;\n\n        // Make it inclusive by moving the right 'stop-point' away by one.\n        if (sep === \"-\" || sep === \"..\" || sep === \"\\u2025\") rhs += incr;\n\n        for (let i = lhs; i !== rhs; i += incr) res.push(i);\n      }\n    }\n  }\n\n  return res;\n}\n\nexports.default = parsePart;\nmodule.exports = parsePart;\n","/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","import parse from 'inline-style-parser';\nimport type { Declaration } from 'inline-style-parser';\n\nexport { Declaration };\n\ninterface StyleObject {\n  [name: string]: string;\n}\n\ntype Iterator = (\n  property: string,\n  value: string,\n  declaration: Declaration,\n) => void;\n\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 */\nexport default function StyleToObject(\n  style: string,\n  iterator?: Iterator,\n): StyleObject | null {\n  let styleObject: StyleObject | null = null;\n\n  if (!style || typeof style !== 'string') {\n    return styleObject;\n  }\n\n  const declarations = parse(style);\n  const hasIterator = typeof iterator === 'function';\n\n  declarations.forEach((declaration) => {\n    if (declaration.type !== 'declaration') {\n      return;\n    }\n\n    const { property, value } = declaration;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      styleObject = styleObject || {};\n      styleObject[property] = value;\n    }\n  });\n\n  return styleObject;\n}\n","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nmodule.exports = toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nmodule.exports = toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n */\n\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.\n * @param {Selector | null | undefined} [selector]\n *   Simple CSS selector.\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: import('./extract.js').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: fine.\n    tagName: tagName || defaultTagName || 'div',\n    properties: props,\n    children: []\n  }\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Content} Content\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef {Content | Root} Node\n *   Any concrete `hast` node.\n * @typedef {Root | Element} HResult\n *   Result from a `h` (or `s`) call.\n *\n * @typedef {string | number} HStyleValue\n *   Value for a CSS style field.\n * @typedef {Record<string, HStyleValue>} HStyle\n *   Supported value of a `style` prop.\n * @typedef {string | number | boolean | null | undefined} HPrimitiveValue\n *   Primitive property value.\n * @typedef {Array<string | number>} HArrayValue\n *   List of property values for space- or comma separated values (such as `className`).\n * @typedef {HPrimitiveValue | HArrayValue} HPropertyValue\n *   Primitive value or list value.\n * @typedef {{[property: string]: HPropertyValue | HStyle}} HProperties\n *   Acceptable value for element properties.\n *\n * @typedef {string | number | null | undefined} HPrimitiveChild\n *   Primitive children, either ignored (nullish), or turned into text nodes.\n * @typedef {Array<Node | HPrimitiveChild>} HArrayChild\n *   List of children.\n * @typedef {Node | HPrimitiveChild | HArrayChild} HChild\n *   Acceptable child value.\n */\n\nimport {find, normalize} from 'property-information'\nimport {parseSelector} from 'hast-util-parse-selector'\nimport {parse as spaces} from 'space-separated-tokens'\nimport {parse as commas} from 'comma-separated-tokens'\n\nconst buttonTypes = new Set(['menu', 'submit', 'reset', 'button'])\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Schema} schema\n * @param {string} defaultTagName\n * @param {Array<string>} [caseSensitive]\n */\nexport function core(schema, defaultTagName, caseSensitive) {\n  const adjust = caseSensitive && createAdjustMap(caseSensitive)\n\n  const h =\n    /**\n     * @type {{\n     *   (): Root\n     *   (selector: null | undefined, ...children: Array<HChild>): Root\n     *   (selector: string, properties?: HProperties, ...children: Array<HChild>): Element\n     *   (selector: string, ...children: Array<HChild>): Element\n     * }}\n     */\n    (\n      /**\n       * Hyperscript compatible DSL for creating virtual hast trees.\n       *\n       * @param {string | null} [selector]\n       * @param {HProperties | HChild} [properties]\n       * @param {Array<HChild>} children\n       * @returns {HResult}\n       */\n      function (selector, properties, ...children) {\n        let index = -1\n        /** @type {HResult} */\n        let node\n\n        if (selector === undefined || selector === null) {\n          node = {type: 'root', children: []}\n          // @ts-expect-error Properties are not supported for roots.\n          children.unshift(properties)\n        } else {\n          node = parseSelector(selector, defaultTagName)\n          // Normalize the name.\n          node.tagName = node.tagName.toLowerCase()\n          if (adjust && own.call(adjust, node.tagName)) {\n            node.tagName = adjust[node.tagName]\n          }\n\n          // Handle props.\n          if (isProperties(properties, node.tagName)) {\n            /** @type {string} */\n            let key\n\n            for (key in properties) {\n              if (own.call(properties, key)) {\n                // @ts-expect-error `node.properties` is set.\n                addProperty(schema, node.properties, key, properties[key])\n              }\n            }\n          } else {\n            children.unshift(properties)\n          }\n        }\n\n        // Handle children.\n        while (++index < children.length) {\n          addChild(node.children, children[index])\n        }\n\n        if (node.type === 'element' && node.tagName === 'template') {\n          node.content = {type: 'root', children: node.children}\n          node.children = []\n        }\n\n        return node\n      }\n    )\n\n  return h\n}\n\n/**\n * @param {HProperties | HChild} value\n * @param {string} name\n * @returns {value is HProperties}\n */\nfunction isProperties(value, name) {\n  if (\n    value === null ||\n    value === undefined ||\n    typeof value !== 'object' ||\n    Array.isArray(value)\n  ) {\n    return false\n  }\n\n  if (name === 'input' || !value.type || typeof value.type !== 'string') {\n    return true\n  }\n\n  if ('children' in value && Array.isArray(value.children)) {\n    return false\n  }\n\n  if (name === 'button') {\n    return buttonTypes.has(value.type.toLowerCase())\n  }\n\n  return !('value' in value)\n}\n\n/**\n * @param {Schema} schema\n * @param {Properties} properties\n * @param {string} key\n * @param {HStyle | HPropertyValue} value\n * @returns {void}\n */\nfunction addProperty(schema, properties, key, value) {\n  const info = find(schema, key)\n  let index = -1\n  /** @type {HPropertyValue} */\n  let result\n\n  // Ignore nullish and NaN values.\n  if (value === undefined || value === null) return\n\n  if (typeof value === 'number') {\n    // Ignore NaN.\n    if (Number.isNaN(value)) return\n\n    result = value\n  }\n  // Booleans.\n  else if (typeof value === 'boolean') {\n    result = value\n  }\n  // Handle list values.\n  else if (typeof value === 'string') {\n    if (info.spaceSeparated) {\n      result = spaces(value)\n    } else if (info.commaSeparated) {\n      result = commas(value)\n    } else if (info.commaOrSpaceSeparated) {\n      result = spaces(commas(value).join(' '))\n    } else {\n      result = parsePrimitive(info, info.property, value)\n    }\n  } else if (Array.isArray(value)) {\n    result = value.concat()\n  } else {\n    result = info.property === 'style' ? style(value) : String(value)\n  }\n\n  if (Array.isArray(result)) {\n    /** @type {Array<string | number>} */\n    const finalResult = []\n\n    while (++index < result.length) {\n      // @ts-expect-error Assume no booleans in array.\n      finalResult[index] = parsePrimitive(info, info.property, result[index])\n    }\n\n    result = finalResult\n  }\n\n  // Class names (which can be added both on the `selector` and here).\n  if (info.property === 'className' && Array.isArray(properties.className)) {\n    // @ts-expect-error Assume no booleans in `className`.\n    result = properties.className.concat(result)\n  }\n\n  properties[info.property] = result\n}\n\n/**\n * @param {Array<Content>} nodes\n * @param {HChild} value\n * @returns {void}\n */\nfunction addChild(nodes, value) {\n  let index = -1\n\n  if (value === undefined || value === null) {\n    // Empty.\n  } else if (typeof value === 'string' || typeof value === 'number') {\n    nodes.push({type: 'text', value: String(value)})\n  } else if (Array.isArray(value)) {\n    while (++index < value.length) {\n      addChild(nodes, value[index])\n    }\n  } else if (typeof value === 'object' && 'type' in value) {\n    if (value.type === 'root') {\n      addChild(nodes, value.children)\n    } else {\n      nodes.push(value)\n    }\n  } else {\n    throw new Error('Expected node, nodes, or string, got `' + value + '`')\n  }\n}\n\n/**\n * Parse a single primitives.\n *\n * @param {Info} info\n * @param {string} name\n * @param {HPrimitiveValue} value\n * @returns {HPrimitiveValue}\n */\nfunction parsePrimitive(info, name, value) {\n  if (typeof value === 'string') {\n    if (info.number && value && !Number.isNaN(Number(value))) {\n      return Number(value)\n    }\n\n    if (\n      (info.boolean || info.overloadedBoolean) &&\n      (value === '' || normalize(value) === normalize(name))\n    ) {\n      return true\n    }\n  }\n\n  return value\n}\n\n/**\n * Serialize a `style` object as a string.\n *\n * @param {HStyle} 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","/**\n * @typedef {import('./core.js').HChild} Child\n *   Acceptable child value.\n * @typedef {import('./core.js').HProperties} Properties\n *   Acceptable value for element properties.\n * @typedef {import('./core.js').HResult} Result\n *   Result from a `h` (or `s`) call.\n *\n * @typedef {import('./jsx-classic.js').Element} h.JSX.Element\n * @typedef {import('./jsx-classic.js').IntrinsicAttributes} h.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic.js').IntrinsicElements} h.JSX.IntrinsicElements\n * @typedef {import('./jsx-classic.js').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute\n */\n\nimport {html} from 'property-information'\nimport {core} from './core.js'\n\nexport const h = core(html, 'div')\n","/**\n * List of legacy HTML named character references that don’t need a trailing semicolon.\n *\n * @type {Array<string>}\n */\nexport const characterEntitiesLegacy = [\n  'AElig',\n  'AMP',\n  'Aacute',\n  'Acirc',\n  'Agrave',\n  'Aring',\n  'Atilde',\n  'Auml',\n  'COPY',\n  'Ccedil',\n  'ETH',\n  'Eacute',\n  'Ecirc',\n  'Egrave',\n  'Euml',\n  'GT',\n  'Iacute',\n  'Icirc',\n  'Igrave',\n  'Iuml',\n  'LT',\n  'Ntilde',\n  'Oacute',\n  'Ocirc',\n  'Ograve',\n  'Oslash',\n  'Otilde',\n  'Ouml',\n  'QUOT',\n  'REG',\n  'THORN',\n  'Uacute',\n  'Ucirc',\n  'Ugrave',\n  'Uuml',\n  'Yacute',\n  'aacute',\n  'acirc',\n  'acute',\n  'aelig',\n  'agrave',\n  'amp',\n  'aring',\n  'atilde',\n  'auml',\n  'brvbar',\n  'ccedil',\n  'cedil',\n  'cent',\n  'copy',\n  'curren',\n  'deg',\n  'divide',\n  'eacute',\n  'ecirc',\n  'egrave',\n  'eth',\n  'euml',\n  'frac12',\n  'frac14',\n  'frac34',\n  'gt',\n  'iacute',\n  'icirc',\n  'iexcl',\n  'igrave',\n  'iquest',\n  'iuml',\n  'laquo',\n  'lt',\n  'macr',\n  'micro',\n  'middot',\n  'nbsp',\n  'not',\n  'ntilde',\n  'oacute',\n  'ocirc',\n  'ograve',\n  'ordf',\n  'ordm',\n  'oslash',\n  'otilde',\n  'ouml',\n  'para',\n  'plusmn',\n  'pound',\n  'quot',\n  'raquo',\n  'reg',\n  'sect',\n  'shy',\n  'sup1',\n  'sup2',\n  'sup3',\n  'szlig',\n  'thorn',\n  'times',\n  'uacute',\n  'ucirc',\n  'ugrave',\n  'uml',\n  'uuml',\n  'yacute',\n  'yen',\n  'yuml'\n]\n","/**\n * Map of invalid numeric character references to their replacements, according to HTML.\n *\n * @type {Record<number, string>}\n */\nexport const characterReferenceInvalid = {\n  0: '�',\n  128: '€',\n  130: '‚',\n  131: 'ƒ',\n  132: '„',\n  133: '…',\n  134: '†',\n  135: '‡',\n  136: 'ˆ',\n  137: '‰',\n  138: 'Š',\n  139: '‹',\n  140: 'Œ',\n  142: 'Ž',\n  145: '‘',\n  146: '’',\n  147: '“',\n  148: '”',\n  149: '•',\n  150: '–',\n  151: '—',\n  152: '˜',\n  153: '™',\n  154: 'š',\n  155: '›',\n  156: 'œ',\n  158: 'ž',\n  159: 'Ÿ'\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is decimal.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is a decimal\n */\nexport function isDecimal(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return code >= 48 && code <= 57 /* 0-9 */\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is hexadecimal.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is hexadecimal\n */\nexport function isHexadecimal(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 /* a */ && code <= 102) /* z */ ||\n    (code >= 65 /* A */ && code <= 70) /* Z */ ||\n    (code >= 48 /* A */ && code <= 57) /* Z */\n  )\n}\n","import {isAlphabetical} from 'is-alphabetical'\nimport {isDecimal} from 'is-decimal'\n\n/**\n * Check if the given character code, or the character code at the first\n * character, is alphanumerical.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is alphanumerical.\n */\nexport function isAlphanumerical(character) {\n  return isAlphabetical(character) || isDecimal(character)\n}\n","/**\n * Check if the given character code, or the character code at the first\n * character, is alphabetical.\n *\n * @param {string|number} character\n * @returns {boolean} Whether `character` is alphabetical.\n */\nexport function isAlphabetical(character) {\n  const code =\n    typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 && code <= 122) /* a-z */ ||\n    (code >= 65 && code <= 90) /* A-Z */\n  )\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\nimport {characterEntitiesLegacy} from 'character-entities-legacy'\nimport {characterReferenceInvalid} from 'character-reference-invalid'\nimport {isDecimal} from 'is-decimal'\nimport {isHexadecimal} from 'is-hexadecimal'\nimport {isAlphanumerical} from 'is-alphanumerical'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\n\nconst fromCharCode = String.fromCharCode\n\n// Warning messages.\nconst messages = [\n  '',\n  /* 1: Non terminated (named) */\n  'Named character references must be terminated by a semicolon',\n  /* 2: Non terminated (numeric) */\n  'Numeric character references must be terminated by a semicolon',\n  /* 3: Empty (named) */\n  'Named character references cannot be empty',\n  /* 4: Empty (numeric) */\n  'Numeric character references cannot be empty',\n  /* 5: Unknown (named) */\n  'Named character references must be known',\n  /* 6: Disallowed (numeric) */\n  'Numeric character references cannot be disallowed',\n  /* 7: Prohibited (numeric) */\n  'Numeric character references cannot be outside the permissible Unicode range'\n]\n\n/**\n * Parse HTML character references.\n *\n * @param {string} value\n * @param {import('../index.js').Options} [options={}]\n */\nexport function parseEntities(value, options = {}) {\n  const additional =\n    typeof options.additional === 'string'\n      ? options.additional.charCodeAt(0)\n      : options.additional\n  /** @type {Array<string>} */\n  const result = []\n  let index = 0\n  let lines = -1\n  let queue = ''\n  /** @type {Point|undefined} */\n  let point\n  /** @type {Array<number>|undefined} */\n  let indent\n\n  if (options.position) {\n    if ('start' in options.position || 'indent' in options.position) {\n      // @ts-expect-error: points don’t have indent.\n      indent = options.position.indent\n      // @ts-expect-error: points don’t have indent.\n      point = options.position.start\n    } else {\n      point = options.position\n    }\n  }\n\n  let line = (point ? point.line : 0) || 1\n  let column = (point ? point.column : 0) || 1\n\n  // Cache the current point.\n  let previous = now()\n  /** @type {number|undefined} */\n  let character\n\n  // Ensure the algorithm walks over the first character (inclusive).\n  index--\n\n  while (++index <= value.length) {\n    // If the previous character was a newline.\n    if (character === 10 /* `\\n` */) {\n      column = (indent ? indent[lines] : 0) || 1\n    }\n\n    character = value.charCodeAt(index)\n\n    if (character === 38 /* `&` */) {\n      const following = value.charCodeAt(index + 1)\n\n      // The behavior depends on the identity of the next character.\n      if (\n        following === 9 /* `\\t` */ ||\n        following === 10 /* `\\n` */ ||\n        following === 12 /* `\\f` */ ||\n        following === 32 /* ` ` */ ||\n        following === 38 /* `&` */ ||\n        following === 60 /* `<` */ ||\n        Number.isNaN(following) ||\n        (additional && following === additional)\n      ) {\n        // Not a character reference.\n        // No characters are consumed, and nothing is returned.\n        // This is not an error, either.\n        queue += fromCharCode(character)\n        column++\n        continue\n      }\n\n      const start = index + 1\n      let begin = start\n      let end = start\n      /** @type {string} */\n      let type\n\n      if (following === 35 /* `#` */) {\n        // Numerical reference.\n        end = ++begin\n\n        // The behavior further depends on the next character.\n        const following = value.charCodeAt(end)\n\n        if (following === 88 /* `X` */ || following === 120 /* `x` */) {\n          // ASCII hexadecimal digits.\n          type = 'hexadecimal'\n          end = ++begin\n        } else {\n          // ASCII decimal digits.\n          type = 'decimal'\n        }\n      } else {\n        // Named reference.\n        type = 'named'\n      }\n\n      let characterReferenceCharacters = ''\n      let characterReference = ''\n      let characters = ''\n      // Each type of character reference accepts different characters.\n      // This test is used to detect whether a reference has ended (as the semicolon\n      // is not strictly needed).\n      const test =\n        type === 'named'\n          ? isAlphanumerical\n          : type === 'decimal'\n          ? isDecimal\n          : isHexadecimal\n\n      end--\n\n      while (++end <= value.length) {\n        const following = value.charCodeAt(end)\n\n        if (!test(following)) {\n          break\n        }\n\n        characters += fromCharCode(following)\n\n        // Check if we can match a legacy named reference.\n        // If so, we cache that as the last viable named reference.\n        // This ensures we do not need to walk backwards later.\n        if (type === 'named' && characterEntitiesLegacy.includes(characters)) {\n          characterReferenceCharacters = characters\n          // @ts-expect-error: always able to decode.\n          characterReference = decodeNamedCharacterReference(characters)\n        }\n      }\n\n      let terminated = value.charCodeAt(end) === 59 /* `;` */\n\n      if (terminated) {\n        end++\n\n        const namedReference =\n          type === 'named' ? decodeNamedCharacterReference(characters) : false\n\n        if (namedReference) {\n          characterReferenceCharacters = characters\n          characterReference = namedReference\n        }\n      }\n\n      let diff = 1 + end - start\n      let reference = ''\n\n      if (!terminated && options.nonTerminated === false) {\n        // Empty.\n      } else if (!characters) {\n        // An empty (possible) reference is valid, unless it’s numeric (thus an\n        // ampersand followed by an octothorp).\n        if (type !== 'named') {\n          warning(4 /* Empty (numeric) */, diff)\n        }\n      } else if (type === 'named') {\n        // An ampersand followed by anything unknown, and not terminated, is\n        // invalid.\n        if (terminated && !characterReference) {\n          warning(5 /* Unknown (named) */, 1)\n        } else {\n          // If there’s something after an named reference which is not known,\n          // cap the reference.\n          if (characterReferenceCharacters !== characters) {\n            end = begin + characterReferenceCharacters.length\n            diff = 1 + end - begin\n            terminated = false\n          }\n\n          // If the reference is not terminated, warn.\n          if (!terminated) {\n            const reason = characterReferenceCharacters\n              ? 1 /* Non terminated (named) */\n              : 3 /* Empty (named) */\n\n            if (options.attribute) {\n              const following = value.charCodeAt(end)\n\n              if (following === 61 /* `=` */) {\n                warning(reason, diff)\n                characterReference = ''\n              } else if (isAlphanumerical(following)) {\n                characterReference = ''\n              } else {\n                warning(reason, diff)\n              }\n            } else {\n              warning(reason, diff)\n            }\n          }\n        }\n\n        reference = characterReference\n      } else {\n        if (!terminated) {\n          // All nonterminated numeric references are not rendered, and emit a\n          // warning.\n          warning(2 /* Non terminated (numeric) */, diff)\n        }\n\n        // When terminated and numerical, parse as either hexadecimal or\n        // decimal.\n        let referenceCode = Number.parseInt(\n          characters,\n          type === 'hexadecimal' ? 16 : 10\n        )\n\n        // Emit a warning when the parsed number is prohibited, and replace with\n        // replacement character.\n        if (prohibited(referenceCode)) {\n          warning(7 /* Prohibited (numeric) */, diff)\n          reference = fromCharCode(65533 /* `�` */)\n        } else if (referenceCode in characterReferenceInvalid) {\n          // Emit a warning when the parsed number is disallowed, and replace by\n          // an alternative.\n          warning(6 /* Disallowed (numeric) */, diff)\n          reference = characterReferenceInvalid[referenceCode]\n        } else {\n          // Parse the number.\n          let output = ''\n\n          // Emit a warning when the parsed number should not be used.\n          if (disallowed(referenceCode)) {\n            warning(6 /* Disallowed (numeric) */, diff)\n          }\n\n          // Serialize the number.\n          if (referenceCode > 0xffff) {\n            referenceCode -= 0x10000\n            output += fromCharCode((referenceCode >>> (10 & 0x3ff)) | 0xd800)\n            referenceCode = 0xdc00 | (referenceCode & 0x3ff)\n          }\n\n          reference = output + fromCharCode(referenceCode)\n        }\n      }\n\n      // Found it!\n      // First eat the queued characters as normal text, then eat a reference.\n      if (reference) {\n        flush()\n\n        previous = now()\n        index = end - 1\n        column += end - start + 1\n        result.push(reference)\n        const next = now()\n        next.offset++\n\n        if (options.reference) {\n          options.reference.call(\n            options.referenceContext,\n            reference,\n            {start: previous, end: next},\n            value.slice(start - 1, end)\n          )\n        }\n\n        previous = next\n      } else {\n        // If we could not find a reference, queue the checked characters (as\n        // normal characters), and move the pointer to their end.\n        // This is possible because we can be certain neither newlines nor\n        // ampersands are included.\n        characters = value.slice(start - 1, end)\n        queue += characters\n        column += characters.length\n        index = end - 1\n      }\n    } else {\n      // Handle anything other than an ampersand, including newlines and EOF.\n      if (character === 10 /* `\\n` */) {\n        line++\n        lines++\n        column = 0\n      }\n\n      if (Number.isNaN(character)) {\n        flush()\n      } else {\n        queue += fromCharCode(character)\n        column++\n      }\n    }\n  }\n\n  // Return the reduced nodes.\n  return result.join('')\n\n  // Get current position.\n  function now() {\n    return {\n      line,\n      column,\n      offset: index + ((point ? point.offset : 0) || 0)\n    }\n  }\n\n  /**\n   * Handle the warning.\n   *\n   * @param {1|2|3|4|5|6|7} code\n   * @param {number} offset\n   */\n  function warning(code, offset) {\n    /** @type {ReturnType<now>} */\n    let position\n\n    if (options.warning) {\n      position = now()\n      position.column += offset\n      position.offset += offset\n\n      options.warning.call(\n        options.warningContext,\n        messages[code],\n        position,\n        code\n      )\n    }\n  }\n\n  /**\n   * Flush `queue` (normal text).\n   * Macro invoked before each reference and at the end of `value`.\n   * Does nothing when `queue` is empty.\n   */\n  function flush() {\n    if (queue) {\n      result.push(queue)\n\n      if (options.text) {\n        options.text.call(options.textContext, queue, {\n          start: previous,\n          end: now()\n        })\n      }\n\n      queue = ''\n    }\n  }\n}\n\n/**\n * Check if `character` is outside the permissible unicode range.\n *\n * @param {number} code\n * @returns {boolean}\n */\nfunction prohibited(code) {\n  return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff\n}\n\n/**\n * Check if `character` is disallowed.\n *\n * @param {number} code\n * @returns {boolean}\n */\nfunction disallowed(code) {\n  return (\n    (code >= 0x0001 && code <= 0x0008) ||\n    code === 0x000b ||\n    (code >= 0x000d && code <= 0x001f) ||\n    (code >= 0x007f && code <= 0x009f) ||\n    (code >= 0xfdd0 && code <= 0xfdef) ||\n    (code & 0xffff) === 0xffff ||\n    (code & 0xffff) === 0xfffe\n  )\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    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 * 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","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"./\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t792: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunk_wcjiang_notify\"] = self[\"webpackChunk_wcjiang_notify\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [670,411], () => (__webpack_require__(123)))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["_extends","Object","assign","bind","n","e","arguments","length","t","r","hasOwnProperty","call","apply","convert","test","undefined","ok","castFactory","Array","isArray","tests","checks","index","any","_len","parameters","_key","this","anyFactory","check","checkAsRecord","all","node","nodeAsRecord","key","propsFactory","type","typeFactory","Error","testFunction","value","parent","Boolean","looksLikeANode","empty","CONTINUE","EXIT","SKIP","visitParents","tree","visitor","reverse","is","step","factory","parents","name","tagName","defineProperty","visit","subresult","offset","grandparents","result","toResult","children","nodeAsParent","concat","child","testOrVisitor","visitorOrReverse","maybeReverse","indexOf","toString","one","join","own","filter","options","cascadeRaw","cascade","preorder","parentNode","childIndex","push","next","c","i","o","registered","defaultLanguage","l","s","p","f","data","meta","properties","metastring","className","m","h","d","u","done","slice","toLowerCase","g","v","includes","split","highlight","ignoreMissing","message","reduce","match","position","start","line","column","end","a","entries","prototype","y","b","map","trim","exec","w","lines","Number","groups","N","j","x","showLineNumbers","some","substring","O","pop","emptyMulticharIndex","emptyRegularIndex","extendIndex","item","currentIndex","pos","isLast","char","charAt","charIndex","chars","self","createMulticharIndex","items","_i","items_1","createRegularIndex","items_2","emptyPseudoSignatures","defaultPseudoSignature","optional","calculatePseudoSignature","types","setResultType","types_1","ofSelector","calculatePseudoSignatures","definitions","pseudoClassesToArgumentTypes","obj","_a","keys","category","_b","_c","inverseCategories","pseudoClass","argumentTypes","__assign","emptyXmlOptions","defaultXmlOptions","wildcard","withPositive","positive","merge","base","extension","mergeSection","values","mergeSchema","replaceValueIfSpecified","concatArray","mergeDefinitions","baseValue","migration","extendSyntaxDefinition","withNoNegative","baseSyntax","tag","ids","classNames","namespace","combinators","attributes","operators","caseSensitivityModifiers","unknownCaseSensitivityModifiers","pseudoClasses","unknown","pseudoElements","notation","NoArgument","css1SyntaxDefinition","css2SyntaxDefinition","String","selectors3SyntaxDefinition","Formula","Selector","selectors4SyntaxDefinition","FormulaOfSelector","cssSyntaxDefinitions","css1","css2","css3","latest","progressive","isIdentStart","isIdent","isHex","whitespaceChars","quoteChars","digitsChars","errorPrefix","astMethods","generatorName","checkerName","props","entity","cssSelectorParse","syntax","substitutes","strict","syntaxDefinition","param","tagNameEnabled","tagNameWildcardEnabled","idEnabled","classNamesEnabled","namespaceEnabled","namespaceWildcardEnabled","substitutesEnabled","combinatorsIndex","_d","attributesEnabled","attributesOperatorsIndex","attributesCaseSensitivityModifiers","attributesAcceptUnknownCaseSensitivityModifiers","attributesCaseSensitivityModifiersEnabled","_e","pseudoClassesEnabled","pseudoClassesDefinitions","pseudoClassesAcceptUnknown","_f","pseudoElementsEnabled","pseudoElementsSingleColonNotationEnabled","pseudoElementsDoubleColonNotationEnabled","pseudoElementsDefinitions","pseudoElementsAcceptUnknown","str","chr","comparison","isTagStart","rewind","newPos","readAndNext","current","fail","errorMessage","Math","min","error","assert","condition","assertNonEof","isEof","pass","character","matchMulticharIndex","matchMulticharIndexPos","subPos","subMatch","parseHex","hex","count","skipSingleWhitespace","fromCharCode","parseInt","parseString","quote","parseIdentifier","parsePseudoClassString","skipWhitespace","parseSelector","relative","rules","parseRule","parseAttribute","attr","name_1","name_2","identifier","savedPos","name_3","operator","name_4","caseSensitivityModifier","parseNumber","isNumberStart","parsePseudoArgument","pseudoName","signature","argument","name_5","ident","firstNumber","firstNumberMultiplier","sign","parseFormula","selector","parseTagName","name_6","parseTagNameWithNamespace","rule","combinator","idName","isDoubleColon","pseudoElement","nestedRule","input","createParser","parse","TypeError","rtlRange","ltrRange","rtl","RegExp","ltr","dirBidi","source","direction","dirProperty","dir","attribute","query","element","schema","info","find","commaSeparated","commas","spaces","normalizeValue","property","emptyClassNames","id","tags","ranges","left","cast","right","matches","rightIndex","range","leftIndex","extendedFilter","lastIndexOf","hasProperty","re","whitespace","thing","replace","Set","ZERO","charCodeAt","NINE","nthCheck","formula","parsed","boolbase","absA","abs","bMod","compile","idx","readSign","number","readNumber","has","zwitch","settings","fn","invalid","handlers","fauxEsmNthCheck","pseudo","_","blank","someChildren","checked","_1","_2","_3","state","disabled","enabled","assertDeep","elementIndex","typeIndex","childState","found","results","rootQuery","scopeElements","shallow","walk","lang","language","elementCount","typeCount","not","getCachedNthCheck","required","readWrite","root","space","scope","query_","_cachedFn","editableOrEditingHost","add","nest","field","list","combine","counts","toUpperCase","get","set","currentRules","nestResult","adjacentSibling","descendant","directChild","generalSibling","exit","currentDirection","dirInferred","xmlLang","contentEditable","svg","enterState","rootRules","selectorIndex","applySelectors","fromParent","fromSibling","total","Map","before","createState","html","getCodeString","code","forEach","rewrite","selected","selectAll","nextChild","codeBlockParames","getCommentObject","_ref","getURLParameters","keyName","isNaN","propertiesHandle","defaultAttrs","attrs","JSON","stringify","rehyp","firstChild","prevChild","env","globalThis","deserialize","serialized","deserializer","$","as","out","unpair","arr","object","Date","flags","BigInt","EMPTY","typeOf","asString","shouldSkip","TYPE","serialize","json","lossy","serializer","pair","entry","valueOf","toJSON","toISOString","structuredClone","search","buttonTypes","createH","defaultTagName","caseSensitive","adjust","createAdjustMap","unshift","previous","lastIndex","subvalue","isProperties","addProperty","addChild","content","spaceSeparated","commaOrSpaceSeparated","parsePrimitive","style","finalResult","nodes","boolean","overloadedBoolean","normalize","webNamespaces","mathml","xlink","xml","xmlns","proto","nodeName","reference","patch","quirksMode","mode","childNodes","file","location","doc","loc","indices","toPoint","toOffset","point","namespaceURI","prefix","sourceCodeLocation","startTag","endTag","from","to","createLocation","tail","verbose","opening","closing","startLine","startCol","startOffset","endLine","endCol","endOffset","emptyOptions","parentSchema","currentSchema","prop","createProperty","fragment","text","comment","doctype","publicId","systemId","htmlVoidElements","UNDEFINED_CODE_POINTS","REPLACEMENT_CHARACTER","CODE_POINTS","SEQUENCES","isSurrogate","cp","isControlCodePoint","isUndefinedCodePoint","ERR","Preprocessor","constructor","handler","lastGapPos","gapStack","skipNextNewLine","lastChunkWritten","endOfChunkHit","bufferWaterline","isEol","lineStartPos","droppedBufferSize","lastErrOffset","col","getError","_err","onParseError","_addGap","_processSurrogate","nextCp","isSurrogatePair","EOF","surrogateInInputStream","willDropParsedChunk","dropParsedChunk","write","chunk","isLastChunk","insertHtmlAtCurrentPos","startsWith","pattern","peek","CARRIAGE_RETURN","LINE_FEED","advance","_checkForProblematicCharacters","controlCharacterInInputStream","noncharacterInInputStream","retreat","TokenType","getTokenAttr","token","attrName","Uint16Array","decodeMap","fromCodePoint","codePoint","output","replaceCodePoint","CharCodes","BinTrieFlags","EntityDecoderState","DecodingMode","isNumber","isHexadecimalCharacter","UPPER_A","UPPER_F","LOWER_A","LOWER_F","isEntityInAttributeInvalidEnd","EQUALS","UPPER_Z","LOWER_Z","isAsciiAlphaNumeric","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","emitNumericEntity","lastCp","expectedLength","absenceOfDigitsInNumericCharacterReference","SEMI","missingSemicolonAfterCharacterReference","validateNumericCharacterReference","valueLength","VALUE_LENGTH","determineBranch","max","Attribute","emitNotTerminatedNamedEntity","emitNamedEntityData","getDecoder","ret","decoder","len","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","htmlDecodeTree","xmlDecodeTree","NS","ATTRS","DOCUMENT_MODE","TAG_NAMES","TAG_ID","TAG_NAME_TO_ID","A","ADDRESS","ANNOTATION_XML","APPLET","AREA","ARTICLE","ASIDE","B","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","I","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","P","PARAM","PLAINTEXT","PRE","RB","RP","RT","RTC","RUBY","S","SCRIPT","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","SPECIAL_ELEMENTS","MATHML","XLINK","XML","XMLNS","isNumberedHeader","tn","C1_CONTROLS_REFERENCE_REPLACEMENTS","State","TokenizerMode","DATA","RCDATA","RAWTEXT","SCRIPT_DATA","CDATA_SECTION","isAsciiDigit","DIGIT_0","DIGIT_9","isAsciiUpper","LATIN_CAPITAL_A","LATIN_CAPITAL_Z","isAsciiLetter","LATIN_SMALL_A","LATIN_SMALL_Z","isAsciiLower","isAsciiUpperHexDigit","LATIN_CAPITAL_F","isAsciiLowerHexDigit","LATIN_SMALL_F","toAsciiLower","isWhitespace","SPACE","TABULATION","FORM_FEED","isScriptDataDoubleEscapeSequenceEnd","SOLIDUS","GREATER_THAN_SIGN","Tokenizer","paused","inLoop","inForeignNode","lastStartTagName","active","returnState","charRefCode","consumedAfterSnapshot","currentCharacterToken","currentToken","currentAttr","preprocessor","currentLocation","getCurrentLocation","sourceCodeLocationInfo","_runParsingLoop","_consume","_ensureHibernation","_callState","pause","resume","writeCallback","_unconsume","_reconsumeInState","_advanceBy","_consumeSequenceIfMatch","_createStartTagToken","START_TAG","tagID","selfClosing","ackSelfClosing","_createEndTagToken","END_TAG","_createCommentToken","COMMENT","_createDoctypeToken","initialName","DOCTYPE","forceQuirks","_createCharacterToken","_createAttr","attrNameFirstCh","_leaveAttrName","create","_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","isAsciiHexDigit","nullCharacterReference","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","document","tagIDs","stackTop","tmplCount","currentTagId","_indexOf","getNamespaceURI","_updateCurrentElement","onItemPush","popped","onItemPop","oldElement","newElement","insertAfter","referenceElement","newElementID","insertionIdx","splice","popUntilTagNamePopped","targetIdx","shortenToLength","popUntilElementPopped","popUntilPopped","tagNames","targetNS","_indexOfTagNames","popUntilNumberedHeaderPopped","popUntilTableCellPopped","popAllUpToHtmlElement","clearBackTo","clearBackToTableContext","clearBackToTableBodyContext","clearBackToTableRowContext","remove","tryPeekProperlyNestedBodyElement","contains","getCommonAncestor","elementIdx","isRootHtmlElementCurrent","hasInScope","ns","hasNumberedHeaderInScope","hasInListItemScope","hasInButtonScope","hasInTableScope","hasTableBodyContextInTableScope","hasInSelectScope","generateImpliedEndTags","generateImpliedEndTagsThoroughly","generateImpliedEndTagsWithExclusion","exclusionId","EntryType","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","entryIndex","clearToLastMarker","markerIdx","getElementEntryInScopeWithTagName","getElementEntry","createTextNode","defaultTreeAdapter","createDocument","NO_QUIRKS","createDocumentFragment","createElement","createCommentNode","appendChild","newNode","insertBefore","referenceNode","setTemplateContent","templateElement","contentElement","setDocumentType","doctypeNode","setDocumentMode","getDocumentMode","detachNode","insertText","prevNode","isTextNode","insertTextBefore","adoptAttributes","recipient","recipientAttrsMap","getFirstChild","getChildNodes","getParentNode","getTextNodeContent","textNode","getCommentNodeContent","commentNode","getDocumentTypeNodeName","getDocumentTypeNodePublicId","getDocumentTypeNodeSystemId","isCommentNode","isDocumentTypeNode","isElementNode","setNodeSourceCodeLocation","getNodeSourceCodeLocation","updateNodeSourceCodeLocation","endLocation","VALID_DOCTYPE_NAME","VALID_SYSTEM_ID","QUIRKS_MODE_SYSTEM_ID","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","MIME_TYPES","TEXT_HTML","APPLICATION_XML","DEFINITION_URL_ATTR","ADJUSTED_DEFINITION_URL_ATTR","SVG_ATTRS_ADJUSTMENT_MAP","XML_ATTRS_ADJUSTMENT_MAP","SVG_TAG_NAMES_ADJUSTMENT_MAP","EXITS_FOREIGN_CONTENT","adjustTokenMathMLAttrs","adjustTokenSVGAttrs","adjustedAttrName","adjustTokenXMLAttrs","adjustedAttrEntry","isIntegrationPoint","foreignNS","ENCODING","isHtmlIntegrationPoint","isMathMLTextIntegrationPoint","HIDDEN_INPUT_TYPE","AA_OUTER_LOOP_ITER","AA_INNER_LOOP_ITER","InsertionMode","BASE_LOC","TABLE_STRUCTURE_TAGS","defaultParserOptions","scriptingEnabled","Parser","fragmentContext","scriptHandler","stopped","insertionMode","INITIAL","originalInsertionMode","headElement","formElement","currentNotInHTML","tmplInsertionModeStack","pendingCharacterTokens","hasNonWhitespacePendingCharacterToken","framesetOk","fosterParentingEnabled","tokenizer","activeFormattingElements","fragmentContextID","_setContextModes","openElements","parser","getFragmentParser","opts","TN","documentMock","IN_TEMPLATE","_initTokenizerForFragmentParsing","_insertFakeRootElement","_resetInsertionMode","_findFormInFragmentContext","getFragment","rootElement","_adoptNodes","beforeToken","err","tid","isTop","_setEndLocation","isHTML","_isIntegrationPoint","_switchToTextParsing","nextTokenizerState","_insertElement","TEXT","switchToPlaintextParsing","IN_BODY","_getAdjustedCurrentElement","_setDocumentType","docTypeNode","_attachElementToTree","_shouldFosterParentOnInsertion","_fosterParentElement","_appendElement","_insertFakeElement","_insertTemplate","tmpl","_appendCommentNode","_insertCharacters","beforeElement","_findFosterParentingLocation","siblings","textNodeIdx","donor","closingToken","ctLoc","endLoc","shouldProcessStartTagTokenInForeignContent","_processToken","_processStartTag","foreignContent","_reconstructActiveFormattingElements","listLength","endIndex","findIndex","_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","characterInForeignContent","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","unicode","nullCharacterInForeignContent","appendComment","AFTER_FRAMESET","tokenInTableText","appendCommentToRootHtmlElement","AFTER_AFTER_FRAMESET","appendCommentToDocument","QUIRKS","LIMITED_QUIRKS","nonConformingDoctype","doctypeInInitialMode","misplacedDoctype","nonVoidHtmlElementStartTagWithTrailingSolidus","startTagToken","COLOR","SIZE","FACE","popUntilHtmlOrIntegrationPoint","_startTagOutsideForeignContent","currentNs","adjustedTagName","startTagInForeignContent","startTagBeforeHtml","startTagInBody","startTagBeforeHead","startTagInHead","nestedNoscriptInHead","startTagInHeadNoScript","abandonedHeadElementChild","misplacedStartTagForHeadElement","startTagAfterHead","startTagInTable","TABLE_VOID_ELEMENTS","startTagInCaption","startTagInColumnGroup","startTagInTableBody","startTagInRow","startTagInCell","startTagInSelect","startTagInSelectInTable","startTagInTemplate","startTagAfterBody","startTagInFrameset","startTagAfterFrameset","startTagAfterAfterBody","startTagAfterAfterFrameset","_endTagOutsideForeignContent","endTagInForeignContent","endTagBeforeHtml","endTagWithoutMatchingOpenElement","endTagBeforeHead","templateEndTagInHead","endTagInHead","endTagInHeadNoScript","endTagAfterHead","endTagInBody","endTagInText","endTagInTable","endTagInCaption","endTagInColumnGroup","endTagInTableBody","endTagInRow","endTagInCell","endTagInSelect","endTagInSelectInTable","endTagInTemplate","endTagAfterBody","endTagInFrameset","endTagAfterFrameset","eofInBody","eofInElementThatCanContainOnlyText","eofInText","eofInTemplate","stopParsing","whitespaceCharacterInBody","whitespaceCharacterInTableText","aaObtainFormattingElementEntry","formattingElementEntry","genericEndTagInBody","aaObtainFurthestBlock","furthestBlock","aaInnerLoop","formattingElement","lastElement","nextElement","elementEntry","counterOverflow","aaRecreateElementFromEntry","aaInsertLastNodeInCommonAncestor","commonAncestor","aaReplaceFormattingElement","callAdoptionAgency","target","htmlElement","htmlLocation","bodyElement","bodyLocation","missingDoctype","closingOfElementWithOpenChildElements","shift","errCode","openElementsLeftAfterEof","disallowedContentInNoscriptInHead","modeInBody","areaStartTagInBody","isHiddenInput","inputType","noembedStartTagInBody","genericStartTagInBody","bStartTagInBody","activeElementEntry","aStartTagInBody","numberedHeaderStartTagInBody","addressStartTagInBody","elementId","listItemStartTagInBody","hrStartTagInBody","rbStartTagInBody","rtStartTagInBody","preStartTagInBody","xmpStartTagInBody","svgStartTagInBody","htmlStartTagInBody","bodyStartTagInBody","inTemplate","formStartTagInBody","nobrStartTagInBody","mathStartTagInBody","tableStartTagInBody","inputStartTagInBody","paramStartTagInBody","imageStartTagInBody","buttonStartTagInBody","appletStartTagInBody","iframeStartTagInBody","selectStartTagInBody","optgroupStartTagInBody","framesetStartTagInBody","textareaStartTagInBody","plaintextStartTagInBody","pEndTagInBody","addressEndTagInBody","liEndTagInBody","ddEndTagInBody","numberedHeaderEndTagInBody","brEndTagInBody","bodyEndTagInBody","htmlEndTagInBody","formEndTagInBody","appletEndTagInBody","tokenInTable","tdStartTagInTable","colStartTagInTable","formStartTagInTable","tableStartTagInTable","tbodyStartTagInTable","inputStartTagInTable","captionStartTagInTable","colgroupStartTagInTable","savedFosterParentingState","xmlCodeMap","codePointAt","getEscaper","regex","lastIdx","pointEnd","pointStart","knownMdxNames","parseOptions","raw","head","documentMode","handleRaw","handle","stitches","resetTokenizer","fromParse5","stitch","toParse5","Token","createParse5Location","clone","cloneWithoutChildren","fakeRoot","setPoint","node_","passThrough","extra","rehypeRaw","_objectWithoutPropertiesLoose","nameRe","nameReJsx","jsx","hastToReact","classId","dataType","itemId","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xmlnsXLink","StyleToObject","stringifyPosition","VFileMessage","causeOrReason","optionsOrParentOrPlace","origin","super","reason","legacyCause","place","ancestors","cause","ruleId","fatal","stack","actual","expected","note","url","emptyMap","cap","dashSomething","tableElements","tableCellElement","docs","toJsxRuntime","Fragment","filePath","development","jsxDEV","isStaticChildren","columnNumber","fileName","lineNumber","developmentCreate","jsxs","productionCreate","components","elementAttributeNameCase","evaluater","createEvaluater","ignoreInvalidStyle","passKeys","passNode","stylePropertyNameCase","tableCellAlignToStyle","findComponentFromName","alignValue","createElementProps","createChildren","addNode","addChildren","estree","expression","body","evaluateExpression","crashEstree","mdxExpression","objectExpression","createJsxElementProps","mdxJsxElement","evaluateProgram","mdxEsm","countsByName","styleObject","styleToObject","replacer","toCamel","parseStyle","domCasing","cssCasing","transformStyleToCssCasing","transformStylesToCssCasing","allowExpression","identifiers","isIdentifierName","computed","toDash","$1","$0","urlAttributes","action","cite","formAction","href","icon","manifest","ping","poster","src","includeImageAlt","includeHtml","alt","chunkStart","SpliceBuffer","initial","RangeError","setCursor","stop","POSITIVE_INFINITY","deleteCount","trunc","removed","chunkedPush","pushMany","unshiftMany","subtokenize","eventsArray","jumps","event","lineIndex","otherIndex","otherEvent","subevents","more","events","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","_container","eventIndex","context","startPosition","startPositions","childEvents","gaps","stream","breaks","sliceStream","defineSkip","_gfmTasklistFirstContentOfListItem","combineExtensions","extensions","syntaxExtension","hook","constructs","existing","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","factorySpace","effects","limit","size","enter","consume","tokenize","contentStart","attempt","contentInitial","lineStart","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","nok","disable","null","blankLine","after","partial","chunkInside","contentEnd","continuationConstruct","contentContinue","resolve","prefixed","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","_index","_bufferIndex","called","createTokenizer","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","main","expectedCode","startIndex","startBufferIndex","endBufferIndex","view","sliceChunks","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","begin","escape","factoryWhitespace","normalizeIdentifier","definition","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","paragraph","heading","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","nonLazyContinuation","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","infoBefore","atNonLazyBreak","metaBefore","contentBefore","beforeContentChunk","contentChunk","characterReference","numeric","decodeNamedCharacterReference","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","close","media","group","label","insideSpan","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","closingSequence","use","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","instruction","tagOpen","declaration","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","between","tailExitIndex","headEnterIndex","resolveText","decodeNumericCharacterReference","characterEscapeOrReference","decode","$2","fromMarkdown","encoding","config","transforms","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","tokenStack","listStack","prepareList","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","expectingFirstListItemValue","flowCodeInside","title","depth","setextHeadingSlurpLineEnding","atHardBreak","inReference","referenceType","ancestor","decodeString","characterReferenceType","ordered","spread","compiler","postprocess","defaultConstructs","atCarriageReturn","endPosition","TextDecoder","ceil","preprocess","combined","remarkParse","normalizeUri","skip","encodeURIComponent","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","revert","subtype","suffix","contents","listItemLoose","tab","trimLines","last","trimLine","blockquote","wrap","applyData","break","delete","footnoteReference","clobberPrefix","safeId","footnoteOrder","counter","reuseCounter","footnoteCounts","dataFootnoteRef","ariaDescribedBy","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","rows","firstRow","tableContent","tableCell","tableRow","align","cellIndex","cells","cell","toml","ignore","yaml","footnoteDefinition","hName","hChildren","hProperties","defaultUnknownHandler","trimMarkdownSpaceStart","toHast","footnoteById","defaultHandlers","unknownHandler","foot","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","remarkRehype","destination","async","hastTree","run","bail","isPlainObject","getPrototypeOf","Symbol","toStringTag","iterator","trough","fns","pipeline","middlewareIndex","callback","_len2","_key2","middleware","wrapped","_len3","_key3","fnExpectsCallback","then","_len4","_key4","middelware","path","basename","ext","assertPath","seenNonSlash","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","joined","segments","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","sep","proc","cwd","isUrl","fileUrlOrPath","protocol","auth","urlToPath","URL","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","isUint8Array","history","messages","stored","assertNonEmpty","assertPart","stem","part","CallableInstance","setPrototypeOf","Processor","Compiler","attachers","freezeIndex","frozen","transformers","copy","attacher","extend","assertUnfrozen","freeze","transformer","realFile","vfile","assertParser","process","assertCompiler","executor","Promise","reject","parseTree","realDone","compileTree","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugin","plugins","primary","rest","currentPrimary","isPlainObj","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","hasOwn","mdastTree","colon","questionMark","numberSign","ccount","findAndReplace","ignored","pairs","tupleOrList","tuple","toExpression","toFunction","toPairs","pairIndex","grandparent","change","matchObject","global","inConstruct","notInConstruct","enterLiteralAutolink","enterLiteralAutolinkValue","exitLiteralAutolinkHttp","exitLiteralAutolinkWww","exitLiteralAutolinkEmail","exitLiteralAutolink","transformGfmAutolinkLiterals","findUrl","findEmail","domain","parts","isCorrectDomain","trailExec","trail","closingParenIndex","openingParens","closingParens","splitUrl","atext","email","enterFootnoteDefinition","enterFootnoteDefinitionLabelString","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","enterFootnoteCall","enterFootnoteCallString","exitFootnoteCallString","exitFootnoteCall","tracker","createTracker","move","subexit","safe","associationId","indentLines","containerFlow","constructsWithoutStrikethrough","enterStrikethrough","exitStrikethrough","handleDelete","containerPhrasing","defaultStringLength","toAlignment","listInScope","none","unsafe","checkQuote","checkEmphasis","compilePattern","formatLinkAsAutolink","resourceLink","checkBullet","bullet","checkRule","phrasing","checkStrong","fence","checkFence","fences","formatCodeAsIndented","repeat","longestStreak","encode","rank","literalWithBreak","setext","formatHeadingAsSetext","closeAtx","bulletCurrent","bulletOrdered","checkBulletOrdered","bulletOther","checkBulletOther","useDifferentMarker","bulletLastUsed","firstListItem","indexStack","listItemIndent","checkListItemIndent","incrementListMarker","ruleSpaces","repetition","ruleRepetition","checkRuleRepetition","enterTable","_align","inTable","exitTable","enterRow","enterCell","exitCodeText","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","serializeData","handleTableRowAsData","handleTableAsData","handleTableCell","row","matrix","alignments","cellMatrix","sizeMatrix","longestCellByColumn","mostCellsPerRow","rowIndex","sizes","columnIndex","delimiterStart","delimiterEnd","markdownTable","exitCheck","exitParagraphWithTaskListItem","firstParaghraph","sibling","listItemWithTaskListItem","checkable","checkbox","wwwPrefix","wwwPrefixInside","wwwPrefixAfter","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","domainAfter","domainAtPunctuation","sizeClose","pathInside","pathAtPunctuation","trailCharRefStart","trailBracketAfter","trailCharRefInside","emailDomainDotTrail","wwwAutolink","previousWww","previousUnbalanced","wwwAfter","protocolAutolink","previousProtocol","protocolPrefixInside","protocolSlashesInside","afterProtocol","protocolAfter","emailAutolink","dot","gfmAtext","previousEmail","emailDomain","emailDomainAfter","emailDomainDot","_gfmAutolinkLiteralWalkedInto","indent","tokenizePotentialGfmFootnoteCall","gfmFootnotes","resolveToPotentialGfmFootnoteCall","tokenizeGfmFootnoteCall","callStart","callData","callEscape","tokenizeDefinitionStart","labelAtMarker","whitespaceAfter","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","gfmStrikethrough","single","singleTilde","strikethrough","EditMap","editMap","at","addImpl","sort","vecs","gfmTableAlign","inDelimiterRow","alignIndex","tokenizeTable","sizeB","bodyRowStart","headRowBefore","headRowBreak","headRowStart","headDelimiterStart","headRowData","headRowEscape","headDelimiterBefore","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","resolveTable","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","afterHeadAwaitingFirstBodyRow","lastTableEnd","flushTableEnd","flushCell","rowEnd","previousCell","groupName","getPoint","relatedStart","relatedEnd","valueToken","tableBody","exits","related","side","tasklistCheck","spaceThenNonSpace","remarkGfm","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","gfm","literalAutolink","literalAutolinkEmail","literalAutolinkHttp","literalAutolinkWww","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","tableData","tableHeader","taskListCheckValueChecked","taskListCheckValueUnchecked","gfmToMarkdown","alertRegex","alertLegacyRegex","remarkAlert","legacyTitle","alertType","isNext","firstNode","reg","toLocaleLowerCase","toLocaleUpperCase","itemChild","class","getAlertIcon","_pathData$type","viewBox","width","height","ariaHidden","pathData","tip","important","warning","caution","getParentElement","dom","dataset","classList","parentElement","useCopied","container","copyTextToClipboard","setTimeout","useEffect","_container$current","_container$current2","removeEventListener","addEventListener","_container$current3","_excluded","React","ref","prefixCls","disableCopy","onScroll","onMouseOver","pluginsFilter","wrapperElement","warpperElement","other","mdp","useImperativeHandle","cls","customProps","wrapperProps","_jsx","ReactMarkdown","reservedMeta","retrieveMeta","metaString","headingRank","slugs","occurrences","reset","slug","maintainCase","originalSlug","convertElement","tagNameFactory","looksLikeAnElement","contentDefaults","toChildren","toNode","toProperties","openDelimiter","closeDelimiter","octiconLink","version","fillRule","defaultRehypePlugins","headingOroperties","headingProperties","behavior","method","grouping","tabIndex","rehypeIgnore","_props$disableCopy","rehypeRewrite","fill","rehypeAttrs","rehypePrism","MarkdownPreview","GITHUB_CORNERS_TEMPLATE","innerHTML","GithubCorners","HTMLElement","observedAttributes","shadow","attachShadow","ownerDocument","importNode","update","setAttr","querySelector","lastElementChild","setAttribute","firstElementChild","getAttributeNames","getAttribute","attributeChangedCallback","oldValue","newValue","customElements","define","githubCorners","fixed","bottom","zIndex","bgColor","color","otherProps","styl","transform","top","GithubShields","styles","rel","img","_jsxs","Footer","year","window","Notification","permission","requestPermission","console","log","iconURL","repeatableEffects","defaultNotification","openurl","createAudio","audioElm","autoplay","muted","changeFavicon","num","canvas","getElementsByTagName","linkTag","ctx","getContext","fillStyle","backgroundColor","fillRect","textAlign","font","textColor","fillText","toDataURL","Notify","init","interval","effect","onclick","disableFavicon","updateFavicon","audio","favicon","setting","ic","querySelectorAll","getFavicon","cloneFavicon","cloneNode","notification","setURL","render","scrollTitle","setTitle","addTimer","clearTimer","loopPlay","loop","player","stopPlay","resp","play","catch","notify","nt","news","olds","jsonArguments","option","onshow","onclose","onerror","Notifiy","isPermission","setInterval","setFavicon","faviconClear","oldicon","getElementById","setFaviconColor","faviconRemove","setFaviconBackgroundColor","timer","newicon","ficon","clearInterval","App","Component","button","onClick","iN","floor","random","componentDidMount","mp4","mp3","wav","DocumentStrSource","DocumentStr","wapper","permanent","light","dark","GitHubCorners","panel","notifyImg","Button","maxWidth","margin","ReactDOMClient","cb","el","getSelection","rangeCount","getRangeAt","select","isCopy","execCommand","removeChild","removeAllRanges","addRange","enumerable","_defineProperty","connectedCallback","hasAttribute","removeAttribute","localStorage","getItem","setItem","matchMedia","onchange","MutationObserver","documentElement","colorMode","colorScheme","observe","removeItem","textContent","dispatchEvent","CustomEvent","bubbles","composed","detail","module","exports","trueFunc","falseFunc","classes","arg","argType","inner","default","toStr","gOPD","getOwnPropertyDescriptor","hasOwnConstructor","hasIsPrototypeOf","setProperty","configurable","writable","getProperty","copyIsArray","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","lineno","updatePosition","Position","errorsList","msg","filename","silent","comments","val","decl","decls","declarations","parsePart","res","lhs","rhs","incr","k","C","sortIndex","performance","unstable_now","q","z","D","E","clearTimeout","F","setImmediate","G","startTime","expirationTime","H","J","K","L","M","priorityLevel","navigator","scheduling","isInputPending","Q","R","MessageChannel","T","port2","port1","onmessage","postMessage","unstable_IdlePriority","unstable_ImmediatePriority","unstable_LowPriority","unstable_NormalPriority","unstable_Profiling","unstable_UserBlockingPriority","unstable_cancelCallback","unstable_continueExecution","unstable_forceFrameRate","unstable_getCurrentPriorityLevel","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_requestPaint","unstable_runWithPriority","unstable_scheduleCallback","delay","unstable_shouldYield","unstable_wrapCallback","inline_style_parser_1","__importDefault","require","hasIterator","toPropertyKey","__esModule","_typeof","toPrimitive","tokens","padRight","padLeft","core","characterEntitiesLegacy","characterReferenceInvalid","isDecimal","isHexadecimal","isAlphanumerical","isAlphabetical","parseEntities","additional","queue","following","characterReferenceCharacters","characters","terminated","namedReference","diff","nonTerminated","referenceCode","disallowed","flush","referenceContext","warningContext","textContext","Schema","normal","DefinedInfo","mustUseProperty","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlnsxlink","aria","ariaActiveDescendant","ariaAtomic","booleanish","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaInvalid","ariaKeyShortcuts","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","autoCapitalize","autoComplete","autoFocus","autoPlay","blocking","capture","charSet","cols","colSpan","controls","controlsList","coords","crossOrigin","dateTime","decoding","defer","dirName","download","draggable","encType","enterKeyHint","fetchPriority","form","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inert","inputMode","integrity","isMap","itemProp","itemRef","itemScope","itemType","loading","low","maxLength","minLength","multiple","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforeMatch","onBeforePrint","onBeforeToggle","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScrollEnd","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","preload","readOnly","referrerPolicy","reversed","rowSpan","sandbox","scoped","seamless","shadowRootClonable","shadowRootDelegatesFocus","shadowRootMode","shape","slot","span","spellCheck","srcDoc","srcLang","srcSet","translate","typeMustMatch","useMap","writingSuggestions","aLink","archive","axis","background","border","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","clear","codeBase","codeType","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","security","unselectable","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dominantBaseline","enableBackground","fillOpacity","floodColor","floodOpacity","fontFamily","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","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","transformOrigin","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","defaultAction","descent","diffuseConstant","display","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","filterRes","filterUnits","focusable","focusHighlight","format","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","mask","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","numOctaves","observer","opacity","orient","orientation","overflow","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","viewTarget","visibility","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan","htmlBase","svgBase","valid","dash","Type","Info","camelcase","dashes","kebab","mark","powers","increment","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","deferred","chunkIds","priority","notFulfilled","Infinity","fulfilled","getter","installedChunks","chunkId","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","chunkLoadingGlobal","__webpack_exports__"],"sourceRoot":""}