{"version":3,"file":"static/js/main.28372144.js","mappings":"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AA0Bx9C,EAA0D,CAEpF05B,OAAO,EACP+jB,gBAAgB,EAChBxM,aAAa,EACb6M,oBAAoB,EACpBT,mBAAmB,EACnBlM,mBAAmB,EACnBnxC,QAAQ,EACR8+C,eAAe,IAIZtB,CGpUT,KCIM6B,GAAS,SAAC9Z,GAAAA,OAAAA,SCCQ+Z,EACtBC,EACAha,EACA5oC,GAAAA,QAAAA,IAAAA,IAAAA,EAAkBm0C,MAEb0O,EAAAA,GAAAA,oBAAmBja,GAAAA,OACf6M,GAAiB,EAAGxkC,OAAO23B,IAAAA,IAK9Bka,EAAmB,kBAAaF,EAAqBha,EAAK5oC,EAAS+1C,GAAAA,WAAAA,EAAAA,WAAAA,EAAAA,OAGzE+M,EAAiBC,WAAa,YAAAvmC,OAC5BmmC,EAAqBC,EAAsBha,EAAAA,GAAAA,CAAAA,EAAU5oC,EAAAA,CAAAA,EAAYwc,GAAAA,EAGnEsmC,EAAiB/lB,MAAQ,YAAAA,OACvB4lB,EAAqBC,EAAsBha,EAAAA,GAAAA,CAAAA,EACtC5oC,EAAAA,CACH+8B,MAAOn3B,MAAMsE,UAAUvP,OAAOqF,EAAQ+8B,MAAOA,GAAOzhC,OAAOwJ,WAAAA,EAGxDg+C,CDzBuBH,CAAhB/Z,CAAqCoa,GAAiBpa,EAAAA,EDJvD,CACb,IACA,OACA,UACA,OACA,UACA,QACA,QACA,IACA,OACA,MACA,MACA,MACA,aACA,OACA,KACA,SACA,SACA,UACA,OACA,OACA,MACA,WACA,OACA,WACA,KACA,MACA,UACA,MACA,SACA,MACA,KACA,KACA,KACA,QACA,WACA,aACA,SACA,SACA,OACA,KACA,KACA,KACA,KACA,KACA,KACA,OACA,SACA,SACA,KACA,OACA,IACA,SACA,MACA,QACA,MACA,MACA,SACA,QACA,SACA,KACA,OACA,OACA,MACA,OACA,UACA,OACA,WACA,OACA,QACA,MACA,WACA,SACA,KACA,WACA,SACA,SACA,IACA,QACA,UACA,MACA,WACA,IACA,KACA,KACA,OACA,IACA,OACA,SACA,UACA,SACA,QACA,SACA,OACA,SACA,QACA,MACA,UACA,MACA,QACA,QACA,KACA,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AAS/P,EAAW5D,EAAYuB,EAAQtT,GAK7C,IAHA,IAAM+M,EAAS,GACXzT,GAAS,IAEJA,EAAQyY,EAAWzZ,QAAQ,CAClC,IAAMkY,EAAUuB,EAAWzY,GAAOqc,WAE9BnF,IAAYzD,EAAOhB,SAASyE,KAC9B8C,EAAS9C,EAAQ8C,EAAQtT,GACzB+M,EAAOjT,KAAK0W,GAEf,CAED,OAAO8C,CACR,sGCxBM,IAAMsvD,EAA0B,CACrC,QACA,MACA,SACA,QACA,SACA,QACA,SACA,OACA,OACA,SACA,MACA,SACA,QACA,SACA,OACA,KACA,SACA,QACA,SACA,OACA,KACA,SACA,SACA,QACA,SACA,SACA,SACA,OACA,OACA,MACA,QACA,SACA,QACA,SACA,OACA,SACA,SACA,QACA,QACA,QACA,SACA,MACA,QACA,SACA,OACA,SACA,SACA,QACA,OACA,OACA,SACA,MACA,SACA,SACA,QACA,SACA,MACA,OACA,SACA,SACA,SACA,KACA,SACA,QACA,QACA,SACA,SACA,OACA,QACA,KACA,OACA,QACA,SACA,OACA,MACA,SACA,SACA,QACA,SACA,OACA,OACA,SACA,SACA,OACA,OACA,SACA,QACA,OACA,QACA,MACA,OACA,MACA,OACA,OACA,OACA,QACA,QACA,QACA,SACA,QACA,SACA,MACA,OACA,SACA,MACA,QC1GWC,EAA4B,CACvC,EAAG,SACH,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,UC1BA,SAASC,EAAUzxC,GACxB,IAAMpnB,EACiB,kBAAdonB,EAAyBA,EAAU7nB,WAAW,GAAK6nB,EAE5D,OAAOpnB,GAAQ,IAAMA,GAAQ,EAC9B,CCLM,SAAS84D,EAAc1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","sources":["../../../../packages/react-router/lib/context.ts","../../../../packages/react-router/lib/router.ts","../../../../packages/react-router/lib/hooks.tsx","../../../../packages/react-router/lib/components.tsx","../../../../packages/react-router-dom/index.tsx","../../node_modules/@uiw/github-corners/src/index.ts","../../node_modules/@uiw/react-github-corners/src/index.tsx","../../node_modules/unist-util-stringify-position/index.js","../../node_modules/vfile-message/index.js","../../node_modules/vfile/lib/minpath.browser.js","../../node_modules/vfile/lib/minproc.browser.js","../../node_modules/vfile/lib/minurl.shared.js","../../node_modules/vfile/lib/minurl.browser.js","../../node_modules/vfile/lib/index.js","../../node_modules/bail/index.js","../../node_modules/unified/node_modules/is-plain-obj/index.js","../../node_modules/trough/index.js","../../node_modules/unified/lib/index.js","../../node_modules/mdast-util-to-string/index.js","../../node_modules/micromark/lib/initialize/content.js","../../node_modules/micromark/lib/initialize/document.js","../../node_modules/micromark/lib/initialize/flow.js","../../node_modules/micromark/lib/initialize/text.js","../../node_modules/micromark/lib/create-tokenizer.js","../../node_modules/micromark/lib/constructs.js","../../node_modules/micromark/lib/preprocess.js","../../node_modules/micromark-util-decode-numeric-character-reference/index.js","../../node_modules/micromark-util-decode-string/index.js","../../node_modules/mdast-util-from-markdown/lib/index.js","../../node_modules/micromark/lib/postprocess.js","../../node_modules/micromark/lib/parse.js","../../node_modules/remark-parse/index.js","../../node_modules/remark-parse/lib/index.js","../../node_modules/unist-builder/index.js","../../node_modules/unist-util-is/index.js","../../node_modules/unist-util-visit-parents/index.js","../../node_modules/unist-util-visit/index.js","../../node_modules/unist-util-position/index.js","../../node_modules/mdast-util-definitions/index.js","../../node_modules/mdast-util-to-hast/lib/traverse.js","../../node_modules/micromark-util-sanitize-uri/index.js","../../node_modules/mdast-util-to-hast/lib/wrap.js","../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../../node_modules/mdast-util-to-hast/lib/revert.js","../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../../node_modules/trim-lines/index.js","../../node_modules/mdast-util-to-hast/lib/handlers/index.js","../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../../node_modules/mdast-util-to-hast/lib/handlers/break.js","../../node_modules/mdast-util-to-hast/lib/handlers/code.js","../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../../node_modules/mdast-util-to-hast/lib/handlers/footnote.js","../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../../node_modules/mdast-util-to-hast/lib/handlers/html.js","../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../../node_modules/mdast-util-to-hast/lib/handlers/image.js","../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../../node_modules/mdast-util-to-hast/lib/handlers/link.js","../../node_modules/mdast-util-to-hast/lib/handlers/list.js","../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../../node_modules/mdast-util-to-hast/lib/handlers/root.js","../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../../node_modules/mdast-util-to-hast/lib/handlers/table.js","../../node_modules/mdast-util-to-hast/lib/handlers/text.js","../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../../node_modules/mdast-util-to-hast/lib/index.js","../../node_modules/unist-util-generated/index.js","../../node_modules/mdast-util-to-hast/lib/footer.js","../../node_modules/remark-rehype/lib/index.js","../../node_modules/react-markdown/lib/rehype-filter.js","../../node_modules/react-markdown/lib/uri-transformer.js","../../node_modules/hast-util-whitespace/index.js","../../node_modules/property-information/lib/hast-to-react.js","../../node_modules/react-markdown/lib/ast-to-react.js","../../node_modules/react-markdown/lib/react-markdown.js","../../node_modules/ccount/index.js","../../node_modules/mdast-util-find-and-replace/lib/index.js","../../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","../../node_modules/mdast-util-gfm-autolink-literal/index.js","../../node_modules/mdast-util-to-markdown/lib/util/association.js","../../node_modules/mdast-util-to-markdown/lib/util/track.js","../../node_modules/mdast-util-to-markdown/lib/util/container-flow.js","../../node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","../../node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","../../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","../../node_modules/mdast-util-to-markdown/lib/util/safe.js","../../node_modules/mdast-util-gfm-footnote/index.js","../../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","../../node_modules/mdast-util-gfm-strikethrough/index.js","../../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","../../node_modules/markdown-table/index.js","../../node_modules/mdast-util-gfm-table/lib/index.js","../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js","../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","../../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","../../node_modules/mdast-util-gfm-task-list-item/index.js","../../node_modules/mdast-util-gfm/lib/index.js","../../node_modules/remark-gfm/index.js","../../node_modules/hast-util-has-property/index.js","../../node_modules/hast-util-heading-rank/index.js","../../node_modules/hast-util-to-string/index.js","../../node_modules/rehype-slug/index.js","../../node_modules/hast-util-is-element/index.js","../../node_modules/rehype-autolink-headings/lib/index.js","../../node_modules/hastscript/lib/svg.js","../../node_modules/hastscript/lib/svg-case-sensitive-tag-names.js","../../node_modules/web-namespaces/index.js","../../node_modules/hast-util-from-parse5/lib/index.js","../../node_modules/vfile-location/index.js","../../node_modules/hast-to-hyperscript/index.js","../../node_modules/zwitch/index.js","../../node_modules/hast-util-to-parse5/lib/index.js","../../node_modules/html-void-elements/index.js","../../node_modules/hast-util-raw/lib/index.js","../../node_modules/rehype-raw/index.js","../../node_modules/rehype-attr/src/utils.ts","../../node_modules/rehype-attr/src/index.ts","../../node_modules/rehype-ignore/src/index.ts","../../node_modules/unist-util-filter/index.js","../../src/generator.js","../../src/all.js","../../src/common.js","../../node_modules/direction/index.js","../../node_modules/hast-util-select/lib/util.js","../../node_modules/hast-util-select/lib/enter-state.js","../../node_modules/hast-util-select/lib/nest.js","../../node_modules/bcp-47-match/index.js","../../node_modules/hast-util-select/lib/pseudo.js","../../node_modules/hast-util-select/lib/attribute.js","../../node_modules/hast-util-select/lib/test.js","../../node_modules/hast-util-select/lib/name.js","../../node_modules/hast-util-select/lib/class-name.js","../../node_modules/hast-util-select/lib/id.js","../../node_modules/hast-util-select/lib/any.js","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/parse.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/index.ts","../https:/raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/compile.ts","../../node_modules/hast-util-select/lib/parse.js","../../node_modules/hast-util-select/index.js","../../node_modules/rehype-rewrite/src/index.ts","../../node_modules/@uiw/react-markdown-preview/src/nodes/octiconLink.ts","../../node_modules/@uiw/react-markdown-preview/src/plugins/reservedMeta.ts","../../node_modules/@uiw/react-markdown-preview/src/index.tsx","../../node_modules/@uiw/react-markdown-preview/src/nodes/copy.ts","../../node_modules/@emotion/stylis/dist/stylis.browser.esm.js","../../node_modules/@emotion/unitless/dist/unitless.browser.esm.js","../../node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","../../node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","../../src/utils/interleave.js","../../src/utils/isPlainObject.js","../../src/utils/empties.js","../../src/utils/isFunction.js","../../src/utils/getComponentName.js","../../src/utils/isStyledComponent.js","../../src/constants.js","../../src/utils/error.js","../../src/sheet/GroupedTag.js","../../src/sheet/GroupIDAllocator.js","../../src/sheet/Rehydration.js","../../src/utils/nonce.js","../../src/sheet/dom.js","../../src/sheet/Tag.js","../../src/sheet/Sheet.js","../../src/utils/generateAlphabeticName.js","../../src/utils/hash.js","../../src/utils/isStaticRules.js","../../src/models/ComponentStyle.js","../../src/utils/stylis.js","../../src/utils/stylisPluginInsertRule.js","../../src/models/StyleSheetManager.js","../../src/models/Keyframes.js","../../src/utils/hyphenateStyleName.js","../../src/utils/flatten.js","../../src/utils/isStatelessFunction.js","../../src/utils/addUnitIfNeeded.js","../../src/constructors/css.js","../../src/utils/checkDynamicCreation.js","../../src/utils/determineTheme.js","../../src/utils/escape.js","../../src/utils/generateComponentId.js","../../src/utils/isTag.js","../../src/utils/mixinDeep.js","../../src/models/ThemeProvider.js","../../src/models/StyledComponent.js","../../src/utils/generateDisplayName.js","../../src/utils/joinStrings.js","../../src/utils/domElements.js","../../src/constructors/styled.js","../../src/constructors/constructWithOptions.js","../../src/models/GlobalStyle.js","../../src/models/ServerStyleSheet.js","../../src/constructors/keyframes.js","../../src/base.js","../../core/README.md","pages/Home.tsx","data.ts","Layout.tsx","../../node_modules/react-keywords/src/index.tsx","components/SkeletonLoader.tsx","components/IconCard.tsx","store/context.tsx","pages/Search.tsx","pages/Icons.tsx","app.tsx","index.tsx","../../src/main.js","../../node_modules/@wcj/dark-mode/dist/dark-mode.min.js","../../node_modules/boolbase/index.js","../../node_modules/css-selector-parser/lib/index.js","../../node_modules/css-selector-parser/lib/parser-context.js","../../node_modules/css-selector-parser/lib/render.js","../../node_modules/css-selector-parser/lib/utils.js","../../node_modules/extend/index.js","../../node_modules/github-slugger/index.js","../../node_modules/github-slugger/regex.js","../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../../node_modules/hoist-non-react-statics/node_modules/react-is/cjs/react-is.production.min.js","../../node_modules/hoist-non-react-statics/node_modules/react-is/index.js","../../node_modules/inline-style-parser/index.js","../../node_modules/is-buffer/index.js","../../node_modules/mdurl/encode.js","../../node_modules/parse-numeric-range/index.js","../../node_modules/prop-types/factoryWithThrowingShims.js","../../node_modules/prop-types/index.js","../../node_modules/prop-types/lib/ReactPropTypesSecret.js","../../node_modules/react-is/cjs/react-is.production.min.js","../../node_modules/react-is/index.js","../../node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","../../node_modules/react-markdown/node_modules/react-is/index.js","../../node_modules/scheduler/cjs/scheduler.production.min.js","../../node_modules/scheduler/index.js","../../node_modules/shallowequal/index.js","../../node_modules/style-to-object/index.js","../../node_modules/comma-separated-tokens/index.js","../../node_modules/decode-named-character-reference/index.dom.js","../../node_modules/hast-util-parse-selector/index.js","../../node_modules/hastscript/lib/core.js","../../node_modules/hastscript/lib/html.js","../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js","../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","../../node_modules/micromark-extension-gfm-table/lib/syntax.js","../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","../../node_modules/micromark-util-classify-character/index.js","../../node_modules/micromark-util-combine-extensions/index.js","../../node_modules/micromark-util-html-tag-name/index.js","../../node_modules/micromark-util-normalize-identifier/index.js","../../node_modules/micromark-util-resolve-all/index.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/create fake namespace object","../webpack/runtime/define property getters","../webpack/runtime/ensure chunk","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/make namespace object","../webpack/runtime/jsonp chunk loading","../webpack/startup"],"sourcesContent":["import * as React from \"react\";\nimport type { History, Location } from \"history\";\nimport { Action as NavigationType } from \"history\";\n\nimport type { RouteMatch } from \"./router\";\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport type Navigator = Pick;\n\ninterface NavigationContextObject {\n basename: string;\n navigator: Navigator;\n static: boolean;\n}\n\nexport const NavigationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n location: Location;\n navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n LocationContext.displayName = \"Location\";\n}\n\ninterface RouteContextObject {\n outlet: React.ReactElement | null;\n matches: RouteMatch[];\n}\n\nexport const RouteContext = React.createContext({\n outlet: null,\n matches: [],\n});\n\nif (__DEV__) {\n RouteContext.displayName = \"Route\";\n}\n","import type { Location, Path, To } from \"history\";\nimport { parsePath } from \"history\";\n\nexport function invariant(cond: any, message: string): asserts cond {\n if (!cond) throw new Error(message);\n}\n\nexport function warning(cond: any, message: string): void {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\n\n try {\n // Welcome to debugging React Router!\n //\n // This error is thrown as a convenience so you can more easily\n // find the source for a warning that appears in the console by\n // enabling \"pause on exceptions\" in your JavaScript debugger.\n throw new Error(message);\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n}\n\nconst alreadyWarned: Record = {};\nexport function warningOnce(key: string, cond: boolean, message: string) {\n if (!cond && !alreadyWarned[key]) {\n alreadyWarned[key] = true;\n warning(false, message);\n }\n}\n\ntype ParamParseFailed = { failed: true };\n\ntype ParamParseSegment =\n // Check here if there exists a forward slash in the string.\n Segment extends `${infer LeftSegment}/${infer RightSegment}`\n ? // If there is a forward slash, then attempt to parse each side of the\n // forward slash.\n ParamParseSegment extends infer LeftResult\n ? ParamParseSegment extends infer RightResult\n ? LeftResult extends string\n ? // If the left side is successfully parsed as a param, then check if\n // the right side can be successfully parsed as well. If both sides\n // can be parsed, then the result is a union of the two sides\n // (read: \"foo\" | \"bar\").\n RightResult extends string\n ? LeftResult | RightResult\n : LeftResult\n : // If the left side is not successfully parsed as a param, then check\n // if only the right side can be successfully parse as a param. If it\n // can, then the result is just right, else it's a failure.\n RightResult extends string\n ? RightResult\n : ParamParseFailed\n : ParamParseFailed\n : // If the left side didn't parse into a param, then just check the right\n // side.\n ParamParseSegment extends infer RightResult\n ? RightResult extends string\n ? RightResult\n : ParamParseFailed\n : ParamParseFailed\n : // If there's no forward slash, then check if this segment starts with a\n // colon. If it does, then this is a dynamic segment, so the result is\n // just the remainder of the string. Otherwise, it's a failure.\n Segment extends `:${infer Remaining}`\n ? Remaining\n : ParamParseFailed;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey =\n ParamParseSegment extends string\n ? ParamParseSegment\n : string;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params = {\n readonly [key in Key]: string | undefined;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport interface RouteObject {\n caseSensitive?: boolean;\n children?: RouteObject[];\n element?: React.ReactNode;\n index?: boolean;\n path?: string;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nexport function generatePath(path: string, params: Params = {}): string {\n return path\n .replace(/:(\\w+)/g, (_, key) => {\n invariant(params[key] != null, `Missing \":${key}\" param`);\n return params[key]!;\n })\n .replace(/\\/*\\*$/, (_) =>\n params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\")\n );\n}\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface RouteMatch {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The route object that was used to match.\n */\n route: RouteObject;\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nexport function matchRoutes(\n routes: RouteObject[],\n locationArg: Partial | string,\n basename = \"/\"\n): RouteMatch[] | null {\n let location =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n let pathname = stripBasename(location.pathname || \"/\", basename);\n\n if (pathname == null) {\n return null;\n }\n\n let branches = flattenRoutes(routes);\n rankRouteBranches(branches);\n\n let matches = null;\n for (let i = 0; matches == null && i < branches.length; ++i) {\n matches = matchRouteBranch(branches[i], pathname);\n }\n\n return matches;\n}\n\ninterface RouteMeta {\n relativePath: string;\n caseSensitive: boolean;\n childrenIndex: number;\n route: RouteObject;\n}\n\ninterface RouteBranch {\n path: string;\n score: number;\n routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes(\n routes: RouteObject[],\n branches: RouteBranch[] = [],\n parentsMeta: RouteMeta[] = [],\n parentPath = \"\"\n): RouteBranch[] {\n routes.forEach((route, index) => {\n let meta: RouteMeta = {\n relativePath: route.path || \"\",\n caseSensitive: route.caseSensitive === true,\n childrenIndex: index,\n route,\n };\n\n if (meta.relativePath.startsWith(\"/\")) {\n invariant(\n meta.relativePath.startsWith(parentPath),\n `Absolute route path \"${meta.relativePath}\" nested under path ` +\n `\"${parentPath}\" is not valid. An absolute child route path ` +\n `must start with the combined path of all its parent routes.`\n );\n\n meta.relativePath = meta.relativePath.slice(parentPath.length);\n }\n\n let path = joinPaths([parentPath, meta.relativePath]);\n let routesMeta = parentsMeta.concat(meta);\n\n // Add the children before adding this route to the array so we traverse the\n // route tree depth-first and child routes appear before their parents in\n // the \"flattened\" version.\n if (route.children && route.children.length > 0) {\n invariant(\n route.index !== true,\n `Index routes must not have child routes. Please remove ` +\n `all child routes from route path \"${path}\".`\n );\n\n flattenRoutes(route.children, branches, routesMeta, path);\n }\n\n // Routes without a path shouldn't ever match by themselves unless they are\n // index routes, so don't add them to the list of possible branches.\n if (route.path == null && !route.index) {\n return;\n }\n\n branches.push({ path, score: computeScore(path, route.index), routesMeta });\n });\n\n return branches;\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n branches.sort((a, b) =>\n a.score !== b.score\n ? b.score - a.score // Higher score first\n : compareIndexes(\n a.routesMeta.map((meta) => meta.childrenIndex),\n b.routesMeta.map((meta) => meta.childrenIndex)\n )\n );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n let segments = path.split(\"/\");\n let initialScore = segments.length;\n if (segments.some(isSplat)) {\n initialScore += splatPenalty;\n }\n\n if (index) {\n initialScore += indexRouteValue;\n }\n\n return segments\n .filter((s) => !isSplat(s))\n .reduce(\n (score, segment) =>\n score +\n (paramRe.test(segment)\n ? dynamicSegmentValue\n : segment === \"\"\n ? emptySegmentValue\n : staticSegmentValue),\n initialScore\n );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n let siblings =\n a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n return siblings\n ? // If two routes are siblings, we should try to match the earlier sibling\n // first. This allows people to have fine-grained control over the matching\n // behavior by simply putting routes with identical paths in the order they\n // want them tried.\n a[a.length - 1] - b[b.length - 1]\n : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n // so they sort equally.\n 0;\n}\n\nfunction matchRouteBranch(\n branch: RouteBranch,\n pathname: string\n): RouteMatch[] | null {\n let { routesMeta } = branch;\n\n let matchedParams = {};\n let matchedPathname = \"/\";\n let matches: RouteMatch[] = [];\n for (let i = 0; i < routesMeta.length; ++i) {\n let meta = routesMeta[i];\n let end = i === routesMeta.length - 1;\n let remainingPathname =\n matchedPathname === \"/\"\n ? pathname\n : pathname.slice(matchedPathname.length) || \"/\";\n let match = matchPath(\n { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n remainingPathname\n );\n\n if (!match) return null;\n\n Object.assign(matchedParams, match.params);\n\n let route = meta.route;\n\n matches.push({\n params: matchedParams,\n pathname: joinPaths([matchedPathname, match.pathname]),\n pathnameBase: normalizePathname(\n joinPaths([matchedPathname, match.pathnameBase])\n ),\n route,\n });\n\n if (match.pathnameBase !== \"/\") {\n matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n }\n }\n\n return matches;\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern {\n /**\n * A string to match against a URL pathname. May contain `:id`-style segments\n * to indicate placeholders for dynamic parameters. May also end with `/*` to\n * indicate matching the rest of the URL pathname.\n */\n path: Path;\n /**\n * Should be `true` if the static portions of the `path` should be matched in\n * the same case.\n */\n caseSensitive?: boolean;\n /**\n * Should be `true` if this pattern should match the entire URL pathname.\n */\n end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The pattern that was used to match.\n */\n pattern: PathPattern;\n}\n\ntype Mutable = {\n -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nexport function matchPath<\n ParamKey extends ParamParseKey,\n Path extends string\n>(\n pattern: PathPattern | Path,\n pathname: string\n): PathMatch | null {\n if (typeof pattern === \"string\") {\n pattern = { path: pattern, caseSensitive: false, end: true };\n }\n\n let [matcher, paramNames] = compilePath(\n pattern.path,\n pattern.caseSensitive,\n pattern.end\n );\n\n let match = pathname.match(matcher);\n if (!match) return null;\n\n let matchedPathname = match[0];\n let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n let captureGroups = match.slice(1);\n let params: Params = paramNames.reduce>(\n (memo, paramName, index) => {\n // We need to compute the pathnameBase here using the raw splat value\n // instead of using params[\"*\"] later because it will be decoded then\n if (paramName === \"*\") {\n let splatValue = captureGroups[index] || \"\";\n pathnameBase = matchedPathname\n .slice(0, matchedPathname.length - splatValue.length)\n .replace(/(.)\\/+$/, \"$1\");\n }\n\n memo[paramName] = safelyDecodeURIComponent(\n captureGroups[index] || \"\",\n paramName\n );\n return memo;\n },\n {}\n );\n\n return {\n params,\n pathname: matchedPathname,\n pathnameBase,\n pattern,\n };\n}\n\nfunction compilePath(\n path: string,\n caseSensitive = false,\n end = true\n): [RegExp, string[]] {\n warning(\n path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n\n let paramNames: string[] = [];\n let regexpSource =\n \"^\" +\n path\n .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n .replace(/:(\\w+)/g, (_: string, paramName: string) => {\n paramNames.push(paramName);\n return \"([^\\\\/]+)\";\n });\n\n if (path.endsWith(\"*\")) {\n paramNames.push(\"*\");\n regexpSource +=\n path === \"*\" || path === \"/*\"\n ? \"(.*)$\" // Already matched the initial /, just match the rest\n : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n } else {\n regexpSource += end\n ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n // parent routes to matching only their own words and nothing more, e.g. parent\n // route \"/home\" should not match \"/home2\".\n // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,\n // but do not consume the character in the matched path so they can match against\n // nested paths.\n \"(?:(?=[.~-]|%[0-9A-F]{2})|\\\\b|\\\\/|$)\";\n }\n\n let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n try {\n return decodeURIComponent(value);\n } catch (error) {\n warning(\n false,\n `The value for the URL param \"${paramName}\" will not be decoded because` +\n ` the string \"${value}\" is a malformed URL segment. This is probably` +\n ` due to a bad percent encoding (${error}).`\n );\n\n return value;\n }\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n let {\n pathname: toPathname,\n search = \"\",\n hash = \"\",\n } = typeof to === \"string\" ? parsePath(to) : to;\n\n let pathname = toPathname\n ? toPathname.startsWith(\"/\")\n ? toPathname\n : resolvePathname(toPathname, fromPathname)\n : fromPathname;\n\n return {\n pathname,\n search: normalizeSearch(search),\n hash: normalizeHash(hash),\n };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n let relativeSegments = relativePath.split(\"/\");\n\n relativeSegments.forEach((segment) => {\n if (segment === \"..\") {\n // Keep the root \"\" segment so the pathname starts at /\n if (segments.length > 1) segments.pop();\n } else if (segment !== \".\") {\n segments.push(segment);\n }\n });\n\n return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nexport function resolveTo(\n toArg: To,\n routePathnames: string[],\n locationPathname: string\n): Path {\n let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname;\n\n // If a pathname is explicitly provided in `to`, it should be relative to the\n // route context. This is explained in `Note on `` values` in our\n // migration guide from v5 as a means of disambiguation between `to` values\n // that begin with `/` and those that do not. However, this is problematic for\n // `to` values that do not provide a pathname. `to` can simply be a search or\n // hash string, in which case we should assume that the navigation is relative\n // to the current location's pathname and *not* the route pathname.\n let from: string;\n if (toPathname == null) {\n from = locationPathname;\n } else {\n let routePathnameIndex = routePathnames.length - 1;\n\n if (toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n\n // Each leading .. segment means \"go up one route\" instead of \"go up one\n // URL segment\". This is a key difference from how works and a\n // major reason we call this a \"to\" value instead of a \"href\".\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n routePathnameIndex -= 1;\n }\n\n to.pathname = toSegments.join(\"/\");\n }\n\n // If there are more \"..\" segments than parent routes, resolve relative to\n // the root / URL.\n from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n }\n\n let path = resolvePath(to, from);\n\n // Ensure the pathname has a trailing slash if the original to value had one.\n if (\n toPathname &&\n toPathname !== \"/\" &&\n toPathname.endsWith(\"/\") &&\n !path.pathname.endsWith(\"/\")\n ) {\n path.pathname += \"/\";\n }\n\n return path;\n}\n\nexport function getToPathname(to: To): string | undefined {\n // Empty strings should be treated the same as / paths\n return to === \"\" || (to as Path).pathname === \"\"\n ? \"/\"\n : typeof to === \"string\"\n ? parsePath(to).pathname\n : to.pathname;\n}\n\nexport function stripBasename(\n pathname: string,\n basename: string\n): string | null {\n if (basename === \"/\") return pathname;\n\n if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n return null;\n }\n\n let nextChar = pathname.charAt(basename.length);\n if (nextChar && nextChar !== \"/\") {\n // pathname does not start with basename/\n return null;\n }\n\n return pathname.slice(basename.length) || \"/\";\n}\n\nexport const joinPaths = (paths: string[]): string =>\n paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\nexport const normalizePathname = (pathname: string): string =>\n pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = (search: string): string =>\n !search || search === \"?\"\n ? \"\"\n : search.startsWith(\"?\")\n ? search\n : \"?\" + search;\n\nconst normalizeHash = (hash: string): string =>\n !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n","import * as React from \"react\";\nimport type { Location, Path, To } from \"history\";\nimport { Action as NavigationType, parsePath } from \"history\";\n\nimport { LocationContext, NavigationContext, RouteContext } from \"./context\";\nimport type {\n ParamParseKey,\n Params,\n PathMatch,\n PathPattern,\n RouteMatch,\n RouteObject,\n} from \"./router\";\nimport {\n getToPathname,\n invariant,\n joinPaths,\n matchPath,\n matchRoutes,\n resolveTo,\n warning,\n warningOnce,\n} from \"./router\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usehref\n */\nexport function useHref(to: To): string {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useHref() may be used only in the context of a component.`\n );\n\n let { basename, navigator } = React.useContext(NavigationContext);\n let { hash, pathname, search } = useResolvedPath(to);\n\n let joinedPathname = pathname;\n if (basename !== \"/\") {\n let toPathname = getToPathname(to);\n let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n joinedPathname =\n pathname === \"/\"\n ? basename + (endsWithSlash ? \"/\" : \"\")\n : joinPaths([basename, pathname]);\n }\n\n return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a .\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\nexport function useInRouterContext(): boolean {\n return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/docs/en/v6/api#uselocation\n */\nexport function useLocation(): Location {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useLocation() may be used only in the context of a component.`\n );\n\n return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigationtype\n */\nexport function useNavigationType(): NavigationType {\n return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns true if the URL for the given \"to\" value matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * .\n *\n * @see https://reactrouter.com/docs/en/v6/api#usematch\n */\nexport function useMatch<\n ParamKey extends ParamParseKey,\n Path extends string\n>(pattern: PathPattern | Path): PathMatch | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useMatch() may be used only in the context of a component.`\n );\n\n let { pathname } = useLocation();\n return React.useMemo(\n () => matchPath(pattern, pathname),\n [pathname, pattern]\n );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n (to: To, options?: NavigateOptions): void;\n (delta: number): void;\n}\n\nexport interface NavigateOptions {\n replace?: boolean;\n state?: any;\n}\n\n/**\n * Returns an imperative method for changing the location. Used by s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigate\n */\nexport function useNavigate(): NavigateFunction {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useNavigate() may be used only in the context of a component.`\n );\n\n let { basename, navigator } = React.useContext(NavigationContext);\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n matches.map((match) => match.pathnameBase)\n );\n\n let activeRef = React.useRef(false);\n React.useEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(\n activeRef.current,\n `You should call navigate() in a React.useEffect(), not when ` +\n `your component is first rendered.`\n );\n\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n navigator.go(to);\n return;\n }\n\n let path = resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname\n );\n\n if (basename !== \"/\") {\n path.pathname = joinPaths([basename, path.pathname]);\n }\n\n (!!options.replace ? navigator.replace : navigator.push)(\n path,\n options.state\n );\n },\n [basename, navigator, routePathnamesJson, locationPathname]\n );\n\n return navigate;\n}\n\nconst OutletContext = React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\nexport function useOutletContext(): Context {\n return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by to render child routes.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useoutlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n let outlet = React.useContext(RouteContext).outlet;\n if (outlet) {\n return (\n {outlet}\n );\n }\n return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useparams\n */\nexport function useParams<\n ParamsOrKey extends string | Record = string\n>(): Readonly<\n [ParamsOrKey] extends [string] ? Params : Partial\n> {\n let { matches } = React.useContext(RouteContext);\n let routeMatch = matches[matches.length - 1];\n return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\nexport function useResolvedPath(to: To): Path {\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n matches.map((match) => match.pathnameBase)\n );\n\n return React.useMemo(\n () => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname),\n [to, routePathnamesJson, locationPathname]\n );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an to render their child route's\n * element.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useroutes\n */\nexport function useRoutes(\n routes: RouteObject[],\n locationArg?: Partial | string\n): React.ReactElement | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useRoutes() may be used only in the context of a component.`\n );\n\n let { matches: parentMatches } = React.useContext(RouteContext);\n let routeMatch = parentMatches[parentMatches.length - 1];\n let parentParams = routeMatch ? routeMatch.params : {};\n let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n let parentRoute = routeMatch && routeMatch.route;\n\n if (__DEV__) {\n // You won't get a warning about 2 different under a \n // without a trailing *, but this is a best-effort warning anyway since we\n // cannot even give the warning unless they land at the parent route.\n //\n // Example:\n //\n // \n // {/* This route path MUST end with /* because otherwise\n // it will never match /blog/post/123 */}\n // } />\n // } />\n // \n //\n // function Blog() {\n // return (\n // \n // } />\n // \n // );\n // }\n let parentPath = (parentRoute && parentRoute.path) || \"\";\n warningOnce(\n parentPathname,\n !parentRoute || parentPath.endsWith(\"*\"),\n `You rendered descendant (or called \\`useRoutes()\\`) at ` +\n `\"${parentPathname}\" (under ) but the ` +\n `parent route path has no trailing \"*\". This means if you navigate ` +\n `deeper, the parent won't match anymore and therefore the child ` +\n `routes will never render.\\n\\n` +\n `Please change the parent to .`\n );\n }\n\n let locationFromContext = useLocation();\n\n let location;\n if (locationArg) {\n let parsedLocationArg =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n invariant(\n parentPathnameBase === \"/\" ||\n parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n `When overriding the location using \\`\\` or \\`useRoutes(routes, location)\\`, ` +\n `the location pathname must begin with the portion of the URL pathname that was ` +\n `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n );\n\n location = parsedLocationArg;\n } else {\n location = locationFromContext;\n }\n\n let pathname = location.pathname || \"/\";\n let remainingPathname =\n parentPathnameBase === \"/\"\n ? pathname\n : pathname.slice(parentPathnameBase.length) || \"/\";\n let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n if (__DEV__) {\n warning(\n parentRoute || matches != null,\n `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n );\n\n warning(\n matches == null ||\n matches[matches.length - 1].route.element !== undefined,\n `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" does not have an element. ` +\n `This means it will render an with a null value by default resulting in an \"empty\" page.`\n );\n }\n\n return _renderMatches(\n matches &&\n matches.map((match) =>\n Object.assign({}, match, {\n params: Object.assign({}, parentParams, match.params),\n pathname: joinPaths([parentPathnameBase, match.pathname]),\n pathnameBase:\n match.pathnameBase === \"/\"\n ? parentPathnameBase\n : joinPaths([parentPathnameBase, match.pathnameBase]),\n })\n ),\n parentMatches\n );\n}\n\nexport function _renderMatches(\n matches: RouteMatch[] | null,\n parentMatches: RouteMatch[] = []\n): React.ReactElement | null {\n if (matches == null) return null;\n\n return matches.reduceRight((outlet, match, index) => {\n return (\n \n );\n }, null as React.ReactElement | null);\n}\n","import * as React from \"react\";\nimport type { InitialEntry, Location, MemoryHistory, To } from \"history\";\nimport {\n Action as NavigationType,\n createMemoryHistory,\n parsePath,\n} from \"history\";\n\nimport { LocationContext, NavigationContext, Navigator } from \"./context\";\nimport {\n useInRouterContext,\n useNavigate,\n useOutlet,\n useRoutes,\n _renderMatches,\n} from \"./hooks\";\nimport type { RouteMatch, RouteObject } from \"./router\";\nimport { invariant, normalizePathname, stripBasename, warning } from \"./router\";\n\nexport interface MemoryRouterProps {\n basename?: string;\n children?: React.ReactNode;\n initialEntries?: InitialEntry[];\n initialIndex?: number;\n}\n\n/**\n * A that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nexport function MemoryRouter({\n basename,\n children,\n initialEntries,\n initialIndex,\n}: MemoryRouterProps): React.ReactElement {\n let historyRef = React.useRef();\n if (historyRef.current == null) {\n historyRef.current = createMemoryHistory({ initialEntries, initialIndex });\n }\n\n let history = historyRef.current;\n let [state, setState] = React.useState({\n action: history.action,\n location: history.location,\n });\n\n React.useLayoutEffect(() => history.listen(setState), [history]);\n\n return (\n \n );\n}\n\nexport interface NavigateProps {\n to: To;\n replace?: boolean;\n state?: any;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/docs/en/v6/api#navigate\n */\nexport function Navigate({ to, replace, state }: NavigateProps): null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of\n // the router loaded. We can help them understand how to avoid that.\n ` may be used only in the context of a component.`\n );\n\n warning(\n !React.useContext(NavigationContext).static,\n ` must not be used on the initial render in a . ` +\n `This is a no-op, but you should modify your code so the is ` +\n `only ever rendered in response to some user interaction or state change.`\n );\n\n let navigate = useNavigate();\n React.useEffect(() => {\n navigate(to, { replace, state });\n });\n\n return null;\n}\n\nexport interface OutletProps {\n context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/api#outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n return useOutlet(props.context);\n}\n\nexport interface RouteProps {\n caseSensitive?: boolean;\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n index?: boolean;\n path?: string;\n}\n\nexport interface PathRouteProps {\n caseSensitive?: boolean;\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n index?: false;\n path: string;\n}\n\nexport interface LayoutRouteProps {\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n}\n\nexport interface IndexRouteProps {\n element?: React.ReactNode | null;\n index: true;\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nexport function Route(\n _props: PathRouteProps | LayoutRouteProps | IndexRouteProps\n): React.ReactElement | null {\n invariant(\n false,\n `A is only ever to be used as the child of element, ` +\n `never rendered directly. Please wrap your in a .`\n );\n}\n\nexport interface RouterProps {\n basename?: string;\n children?: React.ReactNode;\n location: Partial | string;\n navigationType?: NavigationType;\n navigator: Navigator;\n static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a directly. Instead, you'll render a\n * router that is more specific to your environment such as a \n * in web browsers or a for server rendering.\n *\n * @see https://reactrouter.com/docs/en/v6/api#router\n */\nexport function Router({\n basename: basenameProp = \"/\",\n children = null,\n location: locationProp,\n navigationType = NavigationType.Pop,\n navigator,\n static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n invariant(\n !useInRouterContext(),\n `You cannot render a inside another .` +\n ` You should never have more than one in your app.`\n );\n\n let basename = normalizePathname(basenameProp);\n let navigationContext = React.useMemo(\n () => ({ basename, navigator, static: staticProp }),\n [basename, navigator, staticProp]\n );\n\n if (typeof locationProp === \"string\") {\n locationProp = parsePath(locationProp);\n }\n\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n state = null,\n key = \"default\",\n } = locationProp;\n\n let location = React.useMemo(() => {\n let trailingPathname = stripBasename(pathname, basename);\n\n if (trailingPathname == null) {\n return null;\n }\n\n return {\n pathname: trailingPathname,\n search,\n hash,\n state,\n key,\n };\n }, [basename, pathname, search, hash, state, key]);\n\n warning(\n location != null,\n ` is not able to match the URL ` +\n `\"${pathname}${search}${hash}\" because it does not start with the ` +\n `basename, so the won't render anything.`\n );\n\n if (location == null) {\n return null;\n }\n\n return (\n \n \n \n );\n}\n\nexport interface RoutesProps {\n children?: React.ReactNode;\n location?: Partial | string;\n}\n\n/**\n * A container for a nested tree of elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#routes\n */\nexport function Routes({\n children,\n location,\n}: RoutesProps): React.ReactElement | null {\n return useRoutes(createRoutesFromChildren(children), location);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `` element or an array of them. Used internally by\n * `` to create a route config from its children.\n *\n * @see https://reactrouter.com/docs/en/v6/api#createroutesfromchildren\n */\nexport function createRoutesFromChildren(\n children: React.ReactNode\n): RouteObject[] {\n let routes: RouteObject[] = [];\n\n React.Children.forEach(children, (element) => {\n if (!React.isValidElement(element)) {\n // Ignore non-elements. This allows people to more easily inline\n // conditionals in their route config.\n return;\n }\n\n if (element.type === React.Fragment) {\n // Transparently support React.Fragment and its children.\n routes.push.apply(\n routes,\n createRoutesFromChildren(element.props.children)\n );\n return;\n }\n\n invariant(\n element.type === Route,\n `[${\n typeof element.type === \"string\" ? element.type : element.type.name\n }] is not a component. All component children of must be a or `\n );\n\n let route: RouteObject = {\n caseSensitive: element.props.caseSensitive,\n element: element.props.element,\n index: element.props.index,\n path: element.props.path,\n };\n\n if (element.props.children) {\n route.children = createRoutesFromChildren(element.props.children);\n }\n\n routes.push(route);\n });\n\n return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n matches: RouteMatch[] | null\n): React.ReactElement | null {\n return _renderMatches(matches);\n}\n","/**\n * NOTE: If you refactor this to split up the modules into separate files,\n * you'll need to update the rollup config for react-router-dom-v5-compat.\n */\nimport * as React from \"react\";\nimport type { BrowserHistory, HashHistory, History } from \"history\";\nimport { createBrowserHistory, createHashHistory } from \"history\";\nimport {\n MemoryRouter,\n Navigate,\n Outlet,\n Route,\n Router,\n Routes,\n createRoutesFromChildren,\n generatePath,\n matchRoutes,\n matchPath,\n createPath,\n parsePath,\n resolvePath,\n renderMatches,\n useHref,\n useInRouterContext,\n useLocation,\n useMatch,\n useNavigate,\n useNavigationType,\n useOutlet,\n useParams,\n useResolvedPath,\n useRoutes,\n useOutletContext,\n} from \"react-router\";\nimport type { To } from \"react-router\";\n\nfunction warning(cond: boolean, message: string): void {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\n\n try {\n // Welcome to debugging React Router!\n //\n // This error is thrown as a convenience so you can more easily\n // find the source for a warning that appears in the console by\n // enabling \"pause on exceptions\" in your JavaScript debugger.\n throw new Error(message);\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// RE-EXPORTS\n////////////////////////////////////////////////////////////////////////////////\n\n// Note: Keep in sync with react-router exports!\nexport {\n MemoryRouter,\n Navigate,\n Outlet,\n Route,\n Router,\n Routes,\n createRoutesFromChildren,\n generatePath,\n matchRoutes,\n matchPath,\n createPath,\n parsePath,\n renderMatches,\n resolvePath,\n useHref,\n useInRouterContext,\n useLocation,\n useMatch,\n useNavigate,\n useNavigationType,\n useOutlet,\n useParams,\n useResolvedPath,\n useRoutes,\n useOutletContext,\n};\n\nexport { NavigationType } from \"react-router\";\nexport type {\n Hash,\n Location,\n Path,\n To,\n MemoryRouterProps,\n NavigateFunction,\n NavigateOptions,\n NavigateProps,\n Navigator,\n OutletProps,\n Params,\n PathMatch,\n RouteMatch,\n RouteObject,\n RouteProps,\n PathRouteProps,\n LayoutRouteProps,\n IndexRouteProps,\n RouterProps,\n Pathname,\n Search,\n RoutesProps,\n} from \"react-router\";\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n UNSAFE_NavigationContext,\n UNSAFE_LocationContext,\n UNSAFE_RouteContext,\n} from \"react-router\";\n\n////////////////////////////////////////////////////////////////////////////////\n// COMPONENTS\n////////////////////////////////////////////////////////////////////////////////\n\nexport interface BrowserRouterProps {\n basename?: string;\n children?: React.ReactNode;\n window?: Window;\n}\n\n/**\n * A `` for use in web browsers. Provides the cleanest URLs.\n */\nexport function BrowserRouter({\n basename,\n children,\n window,\n}: BrowserRouterProps) {\n let historyRef = React.useRef();\n if (historyRef.current == null) {\n historyRef.current = createBrowserHistory({ window });\n }\n\n let history = historyRef.current;\n let [state, setState] = React.useState({\n action: history.action,\n location: history.location,\n });\n\n React.useLayoutEffect(() => history.listen(setState), [history]);\n\n return (\n \n );\n}\n\nexport interface HashRouterProps {\n basename?: string;\n children?: React.ReactNode;\n window?: Window;\n}\n\n/**\n * A `` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nexport function HashRouter({ basename, children, window }: HashRouterProps) {\n let historyRef = React.useRef();\n if (historyRef.current == null) {\n historyRef.current = createHashHistory({ window });\n }\n\n let history = historyRef.current;\n let [state, setState] = React.useState({\n action: history.action,\n location: history.location,\n });\n\n React.useLayoutEffect(() => history.listen(setState), [history]);\n\n return (\n \n );\n}\n\nexport interface HistoryRouterProps {\n basename?: string;\n children?: React.ReactNode;\n history: History;\n}\n\n/**\n * A `` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter({ basename, children, history }: HistoryRouterProps) {\n const [state, setState] = React.useState({\n action: history.action,\n location: history.location,\n });\n\n React.useLayoutEffect(() => history.listen(setState), [history]);\n\n return (\n \n );\n}\n\nif (__DEV__) {\n HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nexport { HistoryRouter as unstable_HistoryRouter };\n\nfunction isModifiedEvent(event: React.MouseEvent) {\n return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nexport interface LinkProps\n extends Omit, \"href\"> {\n reloadDocument?: boolean;\n replace?: boolean;\n state?: any;\n to: To;\n}\n\n/**\n * The public API for rendering a history-aware .\n */\nexport const Link = React.forwardRef(\n function LinkWithRef(\n { onClick, reloadDocument, replace = false, state, target, to, ...rest },\n ref\n ) {\n let href = useHref(to);\n let internalOnClick = useLinkClickHandler(to, { replace, state, target });\n function handleClick(\n event: React.MouseEvent\n ) {\n if (onClick) onClick(event);\n if (!event.defaultPrevented && !reloadDocument) {\n internalOnClick(event);\n }\n }\n\n return (\n // eslint-disable-next-line jsx-a11y/anchor-has-content\n \n );\n }\n);\n\nif (__DEV__) {\n Link.displayName = \"Link\";\n}\n\nexport interface NavLinkProps\n extends Omit {\n children?:\n | React.ReactNode\n | ((props: { isActive: boolean }) => React.ReactNode);\n caseSensitive?: boolean;\n className?: string | ((props: { isActive: boolean }) => string | undefined);\n end?: boolean;\n style?:\n | React.CSSProperties\n | ((props: { isActive: boolean }) => React.CSSProperties);\n}\n\n/**\n * A wrapper that knows if it's \"active\" or not.\n */\nexport const NavLink = React.forwardRef(\n function NavLinkWithRef(\n {\n \"aria-current\": ariaCurrentProp = \"page\",\n caseSensitive = false,\n className: classNameProp = \"\",\n end = false,\n style: styleProp,\n to,\n children,\n ...rest\n },\n ref\n ) {\n let location = useLocation();\n let path = useResolvedPath(to);\n\n let locationPathname = location.pathname;\n let toPathname = path.pathname;\n if (!caseSensitive) {\n locationPathname = locationPathname.toLowerCase();\n toPathname = toPathname.toLowerCase();\n }\n\n let isActive =\n locationPathname === toPathname ||\n (!end &&\n locationPathname.startsWith(toPathname) &&\n locationPathname.charAt(toPathname.length) === \"/\");\n\n let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n\n let className: string | undefined;\n if (typeof classNameProp === \"function\") {\n className = classNameProp({ isActive });\n } else {\n // If the className prop is not a function, we use a default `active`\n // class for s that are active. In v5 `active` was the default\n // value for `activeClassName`, but we are removing that API and can still\n // use the old default behavior for a cleaner upgrade path and keep the\n // simple styling rules working as they currently do.\n className = [classNameProp, isActive ? \"active\" : null]\n .filter(Boolean)\n .join(\" \");\n }\n\n let style =\n typeof styleProp === \"function\" ? styleProp({ isActive }) : styleProp;\n\n return (\n \n {typeof children === \"function\" ? children({ isActive }) : children}\n \n );\n }\n);\n\nif (__DEV__) {\n NavLink.displayName = \"NavLink\";\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// HOOKS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Handles the click behavior for router `` components. This is useful if\n * you need to create custom `` components with the same click behavior we\n * use in our exported ``.\n */\nexport function useLinkClickHandler(\n to: To,\n {\n target,\n replace: replaceProp,\n state,\n }: {\n target?: React.HTMLAttributeAnchorTarget;\n replace?: boolean;\n state?: any;\n } = {}\n): (event: React.MouseEvent) => void {\n let navigate = useNavigate();\n let location = useLocation();\n let path = useResolvedPath(to);\n\n return React.useCallback(\n (event: React.MouseEvent) => {\n if (\n event.button === 0 && // Ignore everything but left clicks\n (!target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n !isModifiedEvent(event) // Ignore clicks with modifier keys\n ) {\n event.preventDefault();\n\n // If the URL hasn't changed, a regular will do a replace instead of\n // a push, so do the same here.\n let replace =\n !!replaceProp || createPath(location) === createPath(path);\n\n navigate(to, { replace, state });\n }\n },\n [location, navigate, path, replaceProp, state, target, to]\n );\n}\n\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nexport function useSearchParams(defaultInit?: URLSearchParamsInit) {\n warning(\n typeof URLSearchParams !== \"undefined\",\n `You cannot use the \\`useSearchParams\\` hook in a browser that does not ` +\n `support the URLSearchParams API. If you need to support Internet ` +\n `Explorer 11, we recommend you load a polyfill such as ` +\n `https://github.com/ungap/url-search-params\\n\\n` +\n `If you're unsure how to load polyfills, we recommend you check out ` +\n `https://polyfill.io/v3/ which provides some recommendations about how ` +\n `to load polyfills only for users that need them, instead of for every ` +\n `user.`\n );\n\n let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n\n let location = useLocation();\n let searchParams = React.useMemo(() => {\n let searchParams = createSearchParams(location.search);\n\n for (let key of defaultSearchParamsRef.current.keys()) {\n if (!searchParams.has(key)) {\n defaultSearchParamsRef.current.getAll(key).forEach((value) => {\n searchParams.append(key, value);\n });\n }\n }\n\n return searchParams;\n }, [location.search]);\n\n let navigate = useNavigate();\n let setSearchParams = React.useCallback(\n (\n nextInit: URLSearchParamsInit,\n navigateOptions?: { replace?: boolean; state?: any }\n ) => {\n navigate(\"?\" + createSearchParams(nextInit), navigateOptions);\n },\n [navigate]\n );\n\n return [searchParams, setSearchParams] as const;\n}\n\nexport type ParamKeyValuePair = [string, string];\n\nexport type URLSearchParamsInit =\n | string\n | ParamKeyValuePair[]\n | Record\n | URLSearchParams;\n\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n * let searchParams = new URLSearchParams([\n * ['sort', 'name'],\n * ['sort', 'price']\n * ]);\n *\n * you can do:\n *\n * let searchParams = createSearchParams({\n * sort: ['name', 'price']\n * });\n */\nexport function createSearchParams(\n init: URLSearchParamsInit = \"\"\n): URLSearchParams {\n return new URLSearchParams(\n typeof init === \"string\" ||\n Array.isArray(init) ||\n init instanceof URLSearchParams\n ? init\n : Object.keys(init).reduce((memo, key) => {\n let value = init[key];\n return memo.concat(\n Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]\n );\n }, [] as ParamKeyValuePair[])\n );\n}\n","declare global {\n interface HTMLElementTagNameMap {\n 'github-corners': GithubCorners;\n }\n namespace JSX {\n interface IntrinsicElements {\n 'github-corners': Partial | {\n style?: Partial | React.CSSProperties;\n };\n }\n }\n}\n\nconst GITHUB_CORNERS_TEMPLATE = document.createElement(\"template\");\nGITHUB_CORNERS_TEMPLATE.innerHTML = `\n\n\n \n \n \n \n \n \n \n\n`;\n\nexport class GithubCorners extends HTMLElement {\n /** Sets the z-order of a positioned element and its descendants or flex items. */\n 'z-index'?: string;\n height?: string | number;\n width?: string | number;\n href?: string;\n color?: string;\n fill?: string;\n position?: string;\n target?: string;\n top?: string;\n left?: string;\n right?: string = '0';\n bottom?: string;\n transform?: string;\n private shadow: ShadowRoot\n static get observedAttributes(): string[] {\n return ['style', 'z-index', 'target', 'height', 'width', 'href', 'color', 'fill', 'position', 'top', 'left', 'right', 'bottom', 'transform'];\n }\n constructor() {\n super();\n this.shadow = this.attachShadow({ mode: 'open' });\n this.shadow.appendChild(this.ownerDocument.importNode(GITHUB_CORNERS_TEMPLATE.content, true));\n this.update()\n }\n private setAttr(name: string, value: string) {\n const svg = this.shadow.querySelector('svg');\n if (/(href)/.test(name.toLocaleLowerCase())) {\n svg.lastElementChild.setAttribute('xlink:href', value);\n } else if (/(color|fill)/.test(name.toLocaleLowerCase())) {\n (svg.firstElementChild as HTMLAnchorElement).style[name as any] = value;\n } else if (/(z-index|position|top|left|right|bottom|transform)/.test(name.toLocaleLowerCase())) {\n svg.style[name as any] = value;\n } else {\n svg.setAttribute(name, value);\n }\n }\n private update() {\n ;[...this.getAttributeNames(), 'right'].forEach((name) => {\n const value = this.getAttribute(name) || this[name as keyof GithubCorners] as any || '';\n this.setAttr(name, value);\n });\n }\n attributeChangedCallback(name: string, oldValue: string, newValue: string) {\n if (oldValue !== newValue) {\n this.setAttr(name, newValue);\n }\n }\n}\n\ncustomElements.define('github-corners', GithubCorners);","import React from 'react';\nimport '@uiw/github-corners';\n\nexport interface GitHubCornersProps extends React.AnchorHTMLAttributes {\n /**\n * The link to your project page.\n */\n href?: string;\n /**\n * The width and height of the corner. \n * Default: `80`\n */\n size?: number;\n /**\n * The background color of the corner.\n * Default: `#151513`\n */\n bgColor?: string;\n /**\n * The Github logo color of the corner.\n * Default: `#fff`\n */\n color?: string;\n /**\n * The position of corner. \n * Default: `right`\n */\n position?: 'left' | 'right';\n /** Is it displayed at the bottom? */\n bottom?: boolean,\n /** \n * It is positioned relative to the initial containing block established.\n * Default: `false`\n */\n fixed?: boolean;\n /**\n * Sets the z-order of a positioned element and its descendants or flex items.\n */\n zIndex?: number;\n}\n\nexport default function githubCorners(props: GitHubCornersProps) {\n const { size = 80, fixed = false, bottom, zIndex, className, style, bgColor = '#151513', color = '#fff', position = 'right', ...otherProps } = props;\n const styl: React.CSSProperties = position === 'left' ? { left: 0, right: 'initial', transform: 'scale(-1, 1)' } : { right: 0, left: 'initial', transform: 'scale(1, 1)' };\n if (bottom) {\n styl.bottom = 0;\n styl.top = 'initial';\n styl.transform = position === 'left' ? 'scale(-1, -1)' : 'scale(1, -1)';\n } else {\n styl.bottom = 'initial';\n styl.top = 0;\n }\n return (\n \n );\n}","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\n/**\n * Stringify one point, a position (start and end points), or a node’s\n * positional information.\n *\n * @param {Node|NodeLike|Position|Point|null} [value]\n * @returns {string}\n */\nexport function stringifyPosition(value) {\n // Nothing.\n if (!value || typeof value !== 'object') {\n return ''\n }\n\n // Node.\n if ('position' in value || 'type' in value) {\n return position(value.position)\n }\n\n // Position.\n if ('start' in value || 'end' in value) {\n return position(value)\n }\n\n // Point.\n if ('line' in value || 'column' in value) {\n return point(value)\n }\n\n // ?\n return ''\n}\n\n/**\n * @param {Point|undefined} point\n * @returns {string}\n */\nfunction point(point) {\n return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position|undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number|undefined} value\n * @returns {number}\n */\nfunction index(value) {\n return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\nexport class VFileMessage extends Error {\n /**\n * Constructor of a message for `reason` at `place` from `origin`.\n * When an error is passed in as `reason`, copies the `stack`.\n *\n * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).\n * @param {string} [origin] Place in code the message originates from (`string`, optional).\n */\n constructor(reason, place, origin) {\n /** @type {[string|null, string|null]} */\n const parts = [null, null]\n /** @type {Position} */\n let position = {\n // @ts-expect-error: we always follows the structure of `position`.\n start: {line: null, column: null},\n // @ts-expect-error: \"\n end: {line: null, column: null}\n }\n\n super()\n\n if (typeof place === 'string') {\n origin = place\n place = undefined\n }\n\n if (typeof origin === 'string') {\n const index = origin.indexOf(':')\n\n if (index === -1) {\n parts[1] = origin\n } else {\n parts[0] = origin.slice(0, index)\n parts[1] = origin.slice(index + 1)\n }\n }\n\n if (place) {\n // Node.\n if ('type' in place || 'position' in place) {\n if (place.position) {\n position = place.position\n }\n }\n // Position.\n else if ('start' in place || 'end' in place) {\n position = place\n }\n // Point.\n else if ('line' in place || 'column' in place) {\n position.start = place\n }\n }\n\n // Fields from `Error`\n this.name = stringifyPosition(place) || '1:1'\n this.message = typeof reason === 'object' ? reason.message : reason\n this.stack = typeof reason === 'object' ? reason.stack : ''\n\n /**\n * Reason for message.\n * @type {string}\n */\n this.reason = this.message\n /**\n * If true, marks associated file as no longer processable.\n * @type {boolean?}\n */\n // eslint-disable-next-line no-unused-expressions\n this.fatal\n /**\n * Starting line of error.\n * @type {number?}\n */\n this.line = position.start.line\n /**\n * Starting column of error.\n * @type {number?}\n */\n this.column = position.start.column\n /**\n * Namespace of warning.\n * @type {string?}\n */\n this.source = parts[0]\n /**\n * Category of message.\n * @type {string?}\n */\n this.ruleId = parts[1]\n /**\n * Full range information, when available.\n * Has start and end properties, both set to an object with line and column, set to number?.\n * @type {Position?}\n */\n this.position = position\n\n // The following fields are “well known”.\n // Not standard.\n // Feel free to add other non-standard fields to your messages.\n\n /* eslint-disable no-unused-expressions */\n /**\n * You can use this to specify the source value that’s being reported, which\n * is deemed incorrect.\n * @type {string?}\n */\n this.actual\n /**\n * You can use this to suggest values that should be used instead of\n * `actual`, one or more values that are deemed as acceptable.\n * @type {Array?}\n */\n this.expected\n /**\n * You may add a file property with a path of a file (used throughout the VFile ecosystem).\n * @type {string?}\n */\n this.file\n /**\n * You may add a url property with a link to documentation for the message.\n * @type {string?}\n */\n this.url\n /**\n * You may add a note property with a long form description of the message (supported by vfile-reporter).\n * @type {string?}\n */\n this.note\n /* eslint-enable no-unused-expressions */\n }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// .\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// .\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\nfunction basename(path, ext) {\n if (ext !== undefined && typeof ext !== 'string') {\n throw new TypeError('\"ext\" argument must be a string')\n }\n\n assertPath(path)\n let start = 0\n let end = -1\n let index = path.length\n /** @type {boolean|undefined} */\n let seenNonSlash\n\n if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // path component.\n seenNonSlash = true\n end = index + 1\n }\n }\n\n return end < 0 ? '' : path.slice(start, end)\n }\n\n if (ext === path) {\n return ''\n }\n\n let firstNonSlashEnd = -1\n let extIndex = ext.length - 1\n\n while (index--) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (seenNonSlash) {\n start = index + 1\n break\n }\n } else {\n if (firstNonSlashEnd < 0) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching.\n seenNonSlash = true\n firstNonSlashEnd = index + 1\n }\n\n if (extIndex > -1) {\n // Try to match the explicit extension.\n if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n if (extIndex < 0) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = index\n }\n } else {\n // Extension does not match, so our result is the entire path\n // component\n extIndex = -1\n end = firstNonSlashEnd\n }\n }\n }\n }\n\n if (start === end) {\n end = firstNonSlashEnd\n } else if (end < 0) {\n end = path.length\n }\n\n return path.slice(start, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction dirname(path) {\n assertPath(path)\n\n if (path.length === 0) {\n return '.'\n }\n\n let end = -1\n let index = path.length\n /** @type {boolean|undefined} */\n let unmatchedSlash\n\n // Prefix `--` is important to not run on `0`.\n while (--index) {\n if (path.charCodeAt(index) === 47 /* `/` */) {\n if (unmatchedSlash) {\n end = index\n break\n }\n } else if (!unmatchedSlash) {\n // We saw the first non-path separator\n unmatchedSlash = true\n }\n }\n\n return end < 0\n ? path.charCodeAt(0) === 47 /* `/` */\n ? '/'\n : '.'\n : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n ? '//'\n : path.slice(0, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction extname(path) {\n assertPath(path)\n\n let index = path.length\n\n let end = -1\n let startPart = 0\n let startDot = -1\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find.\n let preDotState = 0\n /** @type {boolean|undefined} */\n let unmatchedSlash\n\n while (index--) {\n const code = path.charCodeAt(index)\n\n if (code === 47 /* `/` */) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now.\n if (unmatchedSlash) {\n startPart = index + 1\n break\n }\n\n continue\n }\n\n if (end < 0) {\n // We saw the first non-path separator, mark this as the end of our\n // extension.\n unmatchedSlash = true\n end = index + 1\n }\n\n if (code === 46 /* `.` */) {\n // If this is our first dot, mark it as the start of our extension.\n if (startDot < 0) {\n startDot = index\n } else if (preDotState !== 1) {\n preDotState = 1\n }\n } else if (startDot > -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension.\n preDotState = -1\n }\n }\n\n if (\n startDot < 0 ||\n end < 0 ||\n // We saw a non-dot character immediately before the dot.\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly `..`.\n (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n ) {\n return ''\n }\n\n return path.slice(startDot, end)\n}\n\n/**\n * @param {Array} segments\n * @returns {string}\n */\nfunction join(...segments) {\n let index = -1\n /** @type {string|undefined} */\n let joined\n\n while (++index < segments.length) {\n assertPath(segments[index])\n\n if (segments[index]) {\n joined =\n joined === undefined ? segments[index] : joined + '/' + segments[index]\n }\n }\n\n return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\nfunction normalize(path) {\n assertPath(path)\n\n const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n // Normalize the path according to POSIX rules.\n let value = normalizeString(path, !absolute)\n\n if (value.length === 0 && !absolute) {\n value = '.'\n }\n\n if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n value += '/'\n }\n\n return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * @param {boolean} allowAboveRoot\n * @returns {string}\n */\nfunction normalizeString(path, allowAboveRoot) {\n let result = ''\n let lastSegmentLength = 0\n let lastSlash = -1\n let dots = 0\n let index = -1\n /** @type {number|undefined} */\n let code\n /** @type {number} */\n let lastSlashIndex\n\n while (++index <= path.length) {\n if (index < path.length) {\n code = path.charCodeAt(index)\n } else if (code === 47 /* `/` */) {\n break\n } else {\n code = 47 /* `/` */\n }\n\n if (code === 47 /* `/` */) {\n if (lastSlash === index - 1 || dots === 1) {\n // Empty.\n } else if (lastSlash !== index - 1 && dots === 2) {\n if (\n result.length < 2 ||\n lastSegmentLength !== 2 ||\n result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n result.charCodeAt(result.length - 2) !== 46 /* `.` */\n ) {\n if (result.length > 2) {\n lastSlashIndex = result.lastIndexOf('/')\n\n if (lastSlashIndex !== result.length - 1) {\n if (lastSlashIndex < 0) {\n result = ''\n lastSegmentLength = 0\n } else {\n result = result.slice(0, lastSlashIndex)\n lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n }\n\n lastSlash = index\n dots = 0\n continue\n }\n } else if (result.length > 0) {\n result = ''\n lastSegmentLength = 0\n lastSlash = index\n dots = 0\n continue\n }\n }\n\n if (allowAboveRoot) {\n result = result.length > 0 ? result + '/..' : '..'\n lastSegmentLength = 2\n }\n } else {\n if (result.length > 0) {\n result += '/' + path.slice(lastSlash + 1, index)\n } else {\n result = path.slice(lastSlash + 1, index)\n }\n\n lastSegmentLength = index - lastSlash - 1\n }\n\n lastSlash = index\n dots = 0\n } else if (code === 46 /* `.` */ && dots > -1) {\n dots++\n } else {\n dots = -1\n }\n }\n\n return result\n}\n\n/**\n * @param {string} path\n */\nfunction assertPath(path) {\n if (typeof path !== 'string') {\n throw new TypeError(\n 'Path must be a string. Received ' + JSON.stringify(path)\n )\n }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// .\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: \nexport function isUrl(fileURLOrPath) {\n return (\n fileURLOrPath !== null &&\n typeof fileURLOrPath === 'object' &&\n // @ts-expect-error: indexable.\n fileURLOrPath.href &&\n // @ts-expect-error: indexable.\n fileURLOrPath.origin\n )\n}\n","/// \n\nimport {isUrl} from './minurl.shared.js'\n\n// See: \n\n/**\n * @param {string|URL} path\n */\nexport function urlToPath(path) {\n if (typeof path === 'string') {\n path = new URL(path)\n } else if (!isUrl(path)) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'The \"path\" argument must be of type string or an instance of URL. Received `' +\n path +\n '`'\n )\n error.code = 'ERR_INVALID_ARG_TYPE'\n throw error\n }\n\n if (path.protocol !== 'file:') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError('The URL must be of scheme file')\n error.code = 'ERR_INVALID_URL_SCHEME'\n throw error\n }\n\n return getPathFromURLPosix(path)\n}\n\n/**\n * @param {URL} url\n */\nfunction getPathFromURLPosix(url) {\n if (url.hostname !== '') {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL host must be \"localhost\" or empty on darwin'\n )\n error.code = 'ERR_INVALID_FILE_URL_HOST'\n throw error\n }\n\n const pathname = url.pathname\n let index = -1\n\n while (++index < pathname.length) {\n if (\n pathname.charCodeAt(index) === 37 /* `%` */ &&\n pathname.charCodeAt(index + 1) === 50 /* `2` */\n ) {\n const third = pathname.charCodeAt(index + 2)\n if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n /** @type {NodeJS.ErrnoException} */\n const error = new TypeError(\n 'File URL path must not include encoded / characters'\n )\n error.code = 'ERR_INVALID_FILE_URL_PATH'\n throw error\n }\n }\n }\n\n return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n * Encodings supported by the buffer class.\n * This is a copy of the typing from Node, copied to prevent Node globals from\n * being needed.\n * Copied from: \n *\n * @typedef {Value|Options|VFile|URL} Compatible\n * Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n * Raw source map, see:\n * .\n * @property {number} version\n * @property {Array} sources\n * @property {Array} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n * Configuration: a bunch of keys that will be shallow copied over to the new\n * file.\n *\n * @typedef {Record} ReporterSettings\n * @typedef {(files: Array, options: T) => string} Reporter\n */\n\nimport buffer from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n /**\n * Create a new virtual file.\n *\n * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.\n * If `options` is a `URL`, it’s treated as `{path: options}`.\n * If `options` is a `VFile`, shallow copies its data over to the new file.\n * All fields in `options` are set on the newly created `VFile`.\n *\n * Path related fields are set in the following order (least specific to\n * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n * `dirname`.\n *\n * It’s not possible to set either `dirname` or `extname` without setting\n * either `history`, `path`, `basename`, or `stem` as well.\n *\n * @param {Compatible} [value]\n */\n constructor(value) {\n /** @type {Options} */\n let options\n\n if (!value) {\n options = {}\n } else if (typeof value === 'string' || buffer(value)) {\n // @ts-expect-error Looks like a buffer.\n options = {value}\n } else if (isUrl(value)) {\n options = {path: value}\n } else {\n // @ts-expect-error Looks like file or options.\n options = value\n }\n\n /**\n * Place to store custom information (default: `{}`).\n * It’s OK to store custom data directly on the file but moving it to\n * `data` is recommended.\n * @type {Data}\n */\n this.data = {}\n\n /**\n * List of messages associated with the file.\n * @type {Array}\n */\n this.messages = []\n\n /**\n * List of filepaths the file moved between.\n * The first is the original path and the last is the current path.\n * @type {Array}\n */\n this.history = []\n\n /**\n * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n * @type {string}\n */\n this.cwd = proc.cwd()\n\n /* eslint-disable no-unused-expressions */\n /**\n * Raw value.\n * @type {Value}\n */\n this.value\n\n // The below are non-standard, they are “well-known”.\n // As in, used in several tools.\n\n /**\n * Whether a file was saved to disk.\n * This is used by vfile reporters.\n * @type {boolean}\n */\n this.stored\n\n /**\n * Sometimes files have a non-string, compiled, representation.\n * This can be stored in the `result` field.\n * One example is when turning markdown into React nodes.\n * This is used by unified to store non-string results.\n * @type {unknown}\n */\n this.result\n\n /**\n * Sometimes files have a source map associated with them.\n * This can be stored in the `map` field.\n * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n * type from the `source-map` module.\n * @type {Map|undefined}\n */\n this.map\n /* eslint-enable no-unused-expressions */\n\n // Set path related properties in the correct order.\n let index = -1\n\n while (++index < order.length) {\n const prop = order[index]\n\n // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n // `vfile`s too.\n if (prop in options && options[prop] !== undefined) {\n // @ts-expect-error: TS is confused by the different types for `history`.\n this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n }\n }\n\n /** @type {string} */\n let prop\n\n // Set non-path related properties.\n for (prop in options) {\n // @ts-expect-error: fine to set other things.\n if (!order.includes(prop)) this[prop] = options[prop]\n }\n }\n\n /**\n * Get the full path (example: `'~/index.min.js'`).\n * @returns {string}\n */\n get path() {\n return this.history[this.history.length - 1]\n }\n\n /**\n * Set the full path (example: `'~/index.min.js'`).\n * Cannot be nullified.\n * You can set a file URL (a `URL` object with a `file:` protocol) which will\n * be turned into a path with `url.fileURLToPath`.\n * @param {string|URL} path\n */\n set path(path) {\n if (isUrl(path)) {\n path = urlToPath(path)\n }\n\n assertNonEmpty(path, 'path')\n\n if (this.path !== path) {\n this.history.push(path)\n }\n }\n\n /**\n * Get the parent path (example: `'~'`).\n */\n get dirname() {\n return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n }\n\n /**\n * Set the parent path (example: `'~'`).\n * Cannot be set if there’s no `path` yet.\n */\n set dirname(dirname) {\n assertPath(this.basename, 'dirname')\n this.path = path.join(dirname || '', this.basename)\n }\n\n /**\n * Get the basename (including extname) (example: `'index.min.js'`).\n */\n get basename() {\n return typeof this.path === 'string' ? path.basename(this.path) : undefined\n }\n\n /**\n * Set basename (including extname) (`'index.min.js'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set basename(basename) {\n assertNonEmpty(basename, 'basename')\n assertPart(basename, 'basename')\n this.path = path.join(this.dirname || '', basename)\n }\n\n /**\n * Get the extname (including dot) (example: `'.js'`).\n */\n get extname() {\n return typeof this.path === 'string' ? path.extname(this.path) : undefined\n }\n\n /**\n * Set the extname (including dot) (example: `'.js'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be set if there’s no `path` yet.\n */\n set extname(extname) {\n assertPart(extname, 'extname')\n assertPath(this.dirname, 'extname')\n\n if (extname) {\n if (extname.charCodeAt(0) !== 46 /* `.` */) {\n throw new Error('`extname` must start with `.`')\n }\n\n if (extname.includes('.', 1)) {\n throw new Error('`extname` cannot contain multiple dots')\n }\n }\n\n this.path = path.join(this.dirname, this.stem + (extname || ''))\n }\n\n /**\n * Get the stem (basename w/o extname) (example: `'index.min'`).\n */\n get stem() {\n return typeof this.path === 'string'\n ? path.basename(this.path, this.extname)\n : undefined\n }\n\n /**\n * Set the stem (basename w/o extname) (example: `'index.min'`).\n * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n * on windows).\n * Cannot be nullified (use `file.path = file.dirname` instead).\n */\n set stem(stem) {\n assertNonEmpty(stem, 'stem')\n assertPart(stem, 'stem')\n this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n }\n\n /**\n * Serialize the file.\n *\n * @param {BufferEncoding} [encoding='utf8']\n * When `value` is a `Buffer`, `encoding` is a character encoding to\n * understand it as (default: `'utf8'`).\n * @returns {string}\n * Serialized file.\n */\n toString(encoding) {\n return (this.value || '').toString(encoding)\n }\n\n /**\n * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n * associates it with the file by adding it to `vfile.messages` and setting\n * `message.file` to the current filepath.\n *\n * @param {string|Error} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {VFileMessage}\n * Message.\n */\n message(reason, place, origin) {\n const message = new VFileMessage(reason, place, origin)\n\n if (this.path) {\n message.name = this.path + ':' + message.name\n message.file = this.path\n }\n\n message.fatal = false\n\n this.messages.push(message)\n\n return message\n }\n\n /**\n * Like `VFile#message()`, but associates an informational message where\n * `fatal` is set to `null`.\n *\n * @param {string|Error} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {VFileMessage}\n * Message.\n */\n info(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = null\n\n return message\n }\n\n /**\n * Like `VFile#message()`, but associates a fatal message where `fatal` is\n * set to `true`, and then immediately throws it.\n *\n * > 👉 **Note**: a fatal error means that a file is no longer processable.\n *\n * @param {string|Error} reason\n * Human readable reason for the message, uses the stack and message of the error if given.\n * @param {Node|NodeLike|Position|Point} [place]\n * Place where the message occurred in the file.\n * @param {string} [origin]\n * Computer readable reason for the message\n * @returns {never}\n * Message.\n */\n fail(reason, place, origin) {\n const message = this.message(reason, place, origin)\n\n message.fatal = true\n\n throw message\n }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\nfunction assertPart(part, name) {\n if (part && part.includes(path.sep)) {\n throw new Error(\n '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n )\n }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\n */\nfunction assertNonEmpty(part, name) {\n if (!part) {\n throw new Error('`' + name + '` cannot be empty')\n }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string|undefined} path\n * @param {string} name\n * @returns {asserts path is string}\n */\nfunction assertPath(path, name) {\n if (!path) {\n throw new Error('Setting `' + name + '` requires `path` to be set too')\n }\n}\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n * Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n if (error) {\n throw error\n }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array) => void} Callback\n * @typedef {(...input: Array) => any} Middleware\n *\n * @typedef {(...input: Array) => void} Run\n * Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n * Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n * Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n /** @type {Array} */\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} output\n */\n function next(error, ...output) {\n const fn = fns[++middlewareIndex]\n let index = -1\n\n if (error) {\n callback(error)\n return\n }\n\n // Copy non-nullish input into values.\n while (++index < values.length) {\n if (output[index] === null || output[index] === undefined) {\n output[index] = values[index]\n }\n }\n\n // Save the newly created `output` for the next call.\n values = output\n\n // Next or done.\n if (fn) {\n wrap(fn, next)(...output)\n } else {\n callback(null, ...output)\n }\n }\n }\n\n /** @type {Use} */\n function use(middelware) {\n if (typeof middelware !== 'function') {\n throw new TypeError(\n 'Expected `middelware` to be a function, not ' + middelware\n )\n }\n\n fns.push(middelware)\n return pipeline\n }\n}\n\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\nexport function wrap(middleware, callback) {\n /** @type {boolean} */\n let called\n\n return wrapped\n\n /**\n * Call `middleware`.\n * @this {any}\n * @param {Array} parameters\n * @returns {void}\n */\n function wrapped(...parameters) {\n const fnExpectsCallback = middleware.length > parameters.length\n /** @type {any} */\n let result\n\n if (fnExpectsCallback) {\n parameters.push(done)\n }\n\n try {\n result = middleware.apply(this, parameters)\n } catch (error) {\n const exception = /** @type {Error} */ (error)\n\n // Well, this is quite the pickle.\n // `middleware` received a callback and called it synchronously, but that\n // threw an error.\n // The only thing left to do is to throw the thing instead.\n if (fnExpectsCallback && called) {\n throw exception\n }\n\n return done(exception)\n }\n\n if (!fnExpectsCallback) {\n if (result instanceof Promise) {\n result.then(then, done)\n } else if (result instanceof Error) {\n done(result)\n } else {\n then(result)\n }\n }\n }\n\n /**\n * Call `callback`, only once.\n * @type {Callback}\n */\n function done(error, ...output) {\n if (!called) {\n called = true\n callback(error, ...output)\n }\n }\n\n /**\n * Call `done` with one value.\n *\n * @param {any} [value]\n */\n function then(value) {\n done(null, value)\n }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n const transformers = trough()\n /** @type {Processor['attachers']} */\n const attachers = []\n /** @type {Record} */\n let namespace = {}\n /** @type {boolean|undefined} */\n let frozen\n let freezeIndex = -1\n\n // Data management.\n // @ts-expect-error: overloads are handled.\n processor.data = data\n processor.Parser = undefined\n processor.Compiler = undefined\n\n // Lock.\n processor.freeze = freeze\n\n // Plugins.\n processor.attachers = attachers\n // @ts-expect-error: overloads are handled.\n processor.use = use\n\n // API.\n processor.parse = parse\n processor.stringify = stringify\n // @ts-expect-error: overloads are handled.\n processor.run = run\n processor.runSync = runSync\n // @ts-expect-error: overloads are handled.\n processor.process = process\n processor.processSync = processSync\n\n // Expose.\n return processor\n\n // Create a new processor based on the processor in the current scope.\n /** @type {Processor} */\n function processor() {\n const destination = base()\n let index = -1\n\n while (++index < attachers.length) {\n destination.use(...attachers[index])\n }\n\n destination.data(extend(true, {}, namespace))\n\n return destination\n }\n\n /**\n * @param {string|Record} [key]\n * @param {unknown} [value]\n * @returns {unknown}\n */\n function data(key, value) {\n if (typeof key === 'string') {\n // Set `key`.\n if (arguments.length === 2) {\n assertUnfrozen('data', frozen)\n namespace[key] = value\n return processor\n }\n\n // Get `key`.\n return (own.call(namespace, key) && namespace[key]) || null\n }\n\n // Set space.\n if (key) {\n assertUnfrozen('data', frozen)\n namespace = key\n return processor\n }\n\n // Get space.\n return namespace\n }\n\n /** @type {Processor['freeze']} */\n function freeze() {\n if (frozen) {\n return processor\n }\n\n while (++freezeIndex < attachers.length) {\n const [attacher, ...options] = attachers[freezeIndex]\n\n if (options[0] === false) {\n continue\n }\n\n if (options[0] === true) {\n options[0] = undefined\n }\n\n /** @type {Transformer|void} */\n const transformer = attacher.call(processor, ...options)\n\n if (typeof transformer === 'function') {\n transformers.use(transformer)\n }\n }\n\n frozen = true\n freezeIndex = Number.POSITIVE_INFINITY\n\n return processor\n }\n\n /**\n * @param {Pluggable|null|undefined} [value]\n * @param {...unknown} options\n * @returns {Processor}\n */\n function use(value, ...options) {\n /** @type {Record|undefined} */\n let settings\n\n assertUnfrozen('use', frozen)\n\n if (value === null || value === undefined) {\n // Empty.\n } else if (typeof value === 'function') {\n addPlugin(value, ...options)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n addList(value)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n\n if (settings) {\n namespace.settings = Object.assign(namespace.settings || {}, settings)\n }\n\n return processor\n\n /**\n * @param {import('..').Pluggable} value\n * @returns {void}\n */\n function add(value) {\n if (typeof value === 'function') {\n addPlugin(value)\n } else if (typeof value === 'object') {\n if (Array.isArray(value)) {\n const [plugin, ...options] = value\n addPlugin(plugin, ...options)\n } else {\n addPreset(value)\n }\n } else {\n throw new TypeError('Expected usable value, not `' + value + '`')\n }\n }\n\n /**\n * @param {Preset} result\n * @returns {void}\n */\n function addPreset(result) {\n addList(result.plugins)\n\n if (result.settings) {\n settings = Object.assign(settings || {}, result.settings)\n }\n }\n\n /**\n * @param {PluggableList|null|undefined} [plugins]\n * @returns {void}\n */\n function addList(plugins) {\n let index = -1\n\n if (plugins === null || plugins === undefined) {\n // Empty.\n } else if (Array.isArray(plugins)) {\n while (++index < plugins.length) {\n const thing = plugins[index]\n add(thing)\n }\n } else {\n throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n }\n }\n\n /**\n * @param {Plugin} plugin\n * @param {...unknown} [value]\n * @returns {void}\n */\n function addPlugin(plugin, value) {\n let index = -1\n /** @type {Processor['attachers'][number]|undefined} */\n let entry\n\n while (++index < attachers.length) {\n if (attachers[index][0] === plugin) {\n entry = attachers[index]\n break\n }\n }\n\n if (entry) {\n if (isPlainObj(entry[1]) && isPlainObj(value)) {\n value = extend(true, entry[1], value)\n }\n\n entry[1] = value\n } else {\n // @ts-expect-error: fine.\n attachers.push([...arguments])\n }\n }\n }\n\n /** @type {Processor['parse']} */\n function parse(doc) {\n processor.freeze()\n const file = vfile(doc)\n const Parser = processor.Parser\n assertParser('parse', Parser)\n\n if (newable(Parser, 'parse')) {\n // @ts-expect-error: `newable` checks this.\n return new Parser(String(file), file).parse()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Parser(String(file), file) // eslint-disable-line new-cap\n }\n\n /** @type {Processor['stringify']} */\n function stringify(node, doc) {\n processor.freeze()\n const file = vfile(doc)\n const Compiler = processor.Compiler\n assertCompiler('stringify', Compiler)\n assertNode(node)\n\n if (newable(Compiler, 'compile')) {\n // @ts-expect-error: `newable` checks this.\n return new Compiler(node, file).compile()\n }\n\n // @ts-expect-error: `newable` checks this.\n return Compiler(node, file) // eslint-disable-line new-cap\n }\n\n /**\n * @param {Node} node\n * @param {VFileCompatible|RunCallback} [doc]\n * @param {RunCallback} [callback]\n * @returns {Promise|void}\n */\n function run(node, doc, callback) {\n assertNode(node)\n processor.freeze()\n\n if (!callback && typeof doc === 'function') {\n callback = doc\n doc = undefined\n }\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((node: Node) => void)} resolve\n * @param {(error: Error) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n transformers.run(node, vfile(doc), done)\n\n /**\n * @param {Error|null} error\n * @param {Node} tree\n * @param {VFile} file\n * @returns {void}\n */\n function done(error, tree, file) {\n tree = tree || node\n if (error) {\n reject(error)\n } else if (resolve) {\n resolve(tree)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, tree, file)\n }\n }\n }\n }\n\n /** @type {Processor['runSync']} */\n function runSync(node, file) {\n /** @type {Node|undefined} */\n let result\n /** @type {boolean|undefined} */\n let complete\n\n processor.run(node, file, done)\n\n assertDone('runSync', 'run', complete)\n\n // @ts-expect-error: we either bailed on an error or have a tree.\n return result\n\n /**\n * @param {Error|null} [error]\n * @param {Node} [tree]\n * @returns {void}\n */\n function done(error, tree) {\n bail(error)\n result = tree\n complete = true\n }\n }\n\n /**\n * @param {VFileCompatible} doc\n * @param {ProcessCallback} [callback]\n * @returns {Promise|undefined}\n */\n function process(doc, callback) {\n processor.freeze()\n assertParser('process', processor.Parser)\n assertCompiler('process', processor.Compiler)\n\n if (!callback) {\n return new Promise(executor)\n }\n\n executor(null, callback)\n\n /**\n * @param {null|((file: VFile) => void)} resolve\n * @param {(error?: Error|null|undefined) => void} reject\n * @returns {void}\n */\n function executor(resolve, reject) {\n const file = vfile(doc)\n\n processor.run(processor.parse(file), file, (error, tree, file) => {\n if (error || !tree || !file) {\n done(error)\n } else {\n /** @type {unknown} */\n const result = processor.stringify(tree, file)\n\n if (result === undefined || result === null) {\n // Empty.\n } else if (looksLikeAVFileValue(result)) {\n file.value = result\n } else {\n file.result = result\n }\n\n done(error, file)\n }\n })\n\n /**\n * @param {Error|null|undefined} [error]\n * @param {VFile|undefined} [file]\n * @returns {void}\n */\n function done(error, file) {\n if (error || !file) {\n reject(error)\n } else if (resolve) {\n resolve(file)\n } else {\n // @ts-expect-error: `callback` is defined if `resolve` is not.\n callback(null, file)\n }\n }\n }\n }\n\n /** @type {Processor['processSync']} */\n function processSync(doc) {\n /** @type {boolean|undefined} */\n let complete\n\n processor.freeze()\n assertParser('processSync', processor.Parser)\n assertCompiler('processSync', processor.Compiler)\n\n const file = vfile(doc)\n\n processor.process(file, done)\n\n assertDone('processSync', 'process', complete)\n\n return file\n\n /**\n * @param {Error|null|undefined} [error]\n * @returns {void}\n */\n function done(error) {\n complete = true\n bail(error)\n }\n }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n return (\n typeof value === 'function' &&\n // Prototypes do exist.\n // type-coverage:ignore-next-line\n value.prototype &&\n // A function with keys in its prototype is probably a constructor.\n // Classes’ prototype methods are not enumerable, so we check if some value\n // exists in the prototype.\n // type-coverage:ignore-next-line\n (keys(value.prototype) || name in value.prototype)\n )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record} value\n * @returns {boolean}\n */\nfunction keys(value) {\n /** @type {string} */\n let key\n\n for (key in value) {\n if (own.call(value, key)) {\n return true\n }\n }\n\n return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Parser`')\n }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n if (typeof value !== 'function') {\n throw new TypeError('Cannot `' + name + '` without `Compiler`')\n }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n if (frozen) {\n throw new Error(\n 'Cannot call `' +\n name +\n '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n )\n }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n // type-coverage:ignore-next-line\n if (!isPlainObj(node) || typeof node.type !== 'string') {\n throw new TypeError('Expected node, got `' + node + '`')\n // Fine.\n }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n if (!complete) {\n throw new Error(\n '`' + name + '` finished async. Use `' + asyncName + '` instead'\n )\n }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n return Boolean(\n value &&\n typeof value === 'object' &&\n 'message' in value &&\n 'messages' in value\n )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n return typeof value === 'string' || isBuffer(value)\n}\n","/**\n * @typedef Options\n * @property {boolean} [includeImageAlt=true]\n */\n\n/**\n * Get the text content of a node.\n * Prefer the node’s plain-text fields, otherwise serialize its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} node\n * @param {Options} [options]\n * @returns {string}\n */\nexport function toString(node, options) {\n var {includeImageAlt = true} = options || {}\n return one(node, includeImageAlt)\n}\n\n/**\n * @param {unknown} node\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction one(node, includeImageAlt) {\n return (\n (node &&\n typeof node === 'object' &&\n // @ts-ignore looks like a literal.\n (node.value ||\n // @ts-ignore looks like an image.\n (includeImageAlt ? node.alt : '') ||\n // @ts-ignore looks like a parent.\n ('children' in node && all(node.children, includeImageAlt)) ||\n (Array.isArray(node) && all(node, includeImageAlt)))) ||\n ''\n )\n}\n\n/**\n * @param {Array.} values\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction all(values, includeImageAlt) {\n /** @type {Array.} */\n var result = []\n var index = -1\n\n while (++index < values.length) {\n result[index] = one(values[index], includeImageAlt)\n }\n\n return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n const contentStart = effects.attempt(\n this.parser.constructs.contentInitial,\n afterContentStartConstruct,\n paragraphInitial\n )\n /** @type {Token} */\n\n let previous\n return contentStart\n /** @type {State} */\n\n function afterContentStartConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEnding')\n effects.consume(code)\n effects.exit('lineEnding')\n return factorySpace(effects, contentStart, 'linePrefix')\n }\n /** @type {State} */\n\n function paragraphInitial(code) {\n effects.enter('paragraph')\n return lineStart(code)\n }\n /** @type {State} */\n\n function lineStart(code) {\n const token = effects.enter('chunkText', {\n contentType: 'text',\n previous\n })\n\n if (previous) {\n previous.next = token\n }\n\n previous = token\n return data(code)\n }\n /** @type {State} */\n\n function data(code) {\n if (code === null) {\n effects.exit('chunkText')\n effects.exit('paragraph')\n effects.consume(code)\n return\n }\n\n if (markdownLineEnding(code)) {\n effects.consume(code)\n effects.exit('chunkText')\n return lineStart\n } // Data.\n\n effects.consume(code)\n return data\n }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n const self = this\n /** @type {StackItem[]} */\n\n const stack = []\n let continued = 0\n /** @type {TokenizeContext|undefined} */\n\n let childFlow\n /** @type {Token|undefined} */\n\n let childToken\n /** @type {number} */\n\n let lineStartOffset\n return start\n /** @type {State} */\n\n function start(code) {\n // First we iterate through the open blocks, starting with the root\n // document, and descending through last children down to the last open\n // block.\n // Each block imposes a condition that the line must satisfy if the block is\n // to remain open.\n // For example, a block quote requires a `>` character.\n // A paragraph requires a non-blank line.\n // In this phase we may match all or just some of the open blocks.\n // But we cannot close unmatched blocks yet, because we may have a lazy\n // continuation line.\n if (continued < stack.length) {\n const item = stack[continued]\n self.containerState = item[1]\n return effects.attempt(\n item[0].continuation,\n documentContinue,\n checkNewContainers\n )(code)\n } // Done.\n\n return checkNewContainers(code)\n }\n /** @type {State} */\n\n function documentContinue(code) {\n continued++ // Note: this field is called `_closeFlow` but it also closes containers.\n // Perhaps a good idea to rename it but it’s already used in the wild by\n // extensions.\n\n if (self.containerState._closeFlow) {\n self.containerState._closeFlow = undefined\n\n if (childFlow) {\n closeFlow()\n } // Note: this algorithm for moving events around is similar to the\n // algorithm when dealing with lazy lines in `writeToChild`.\n\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {Point|undefined} */\n\n let point // Find the flow chunk.\n\n while (indexBeforeFlow--) {\n if (\n self.events[indexBeforeFlow][0] === 'exit' &&\n self.events[indexBeforeFlow][1].type === 'chunkFlow'\n ) {\n point = self.events[indexBeforeFlow][1].end\n break\n }\n }\n\n exitContainers(continued) // Fix positions.\n\n let index = indexBeforeExits\n\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n } // Inject the exits earlier (they’re still also at the end).\n\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n ) // Discard the duplicate exits.\n\n self.events.length = index\n return checkNewContainers(code)\n }\n\n return start(code)\n }\n /** @type {State} */\n\n function checkNewContainers(code) {\n // Next, after consuming the continuation markers for existing blocks, we\n // look for new block starts (e.g. `>` for a block quote).\n // If we encounter a new block start, we close any blocks unmatched in\n // step 1 before creating the new block as a child of the last matched\n // block.\n if (continued === stack.length) {\n // No need to `check` whether there’s a container, of `exitContainers`\n // would be moot.\n // We can instead immediately `attempt` to parse one.\n if (!childFlow) {\n return documentContinued(code)\n } // If we have concrete content, such as block HTML or fenced code,\n // we can’t have containers “pierce” into them, so we can immediately\n // start.\n\n if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n return flowStart(code)\n } // If we do have flow, it could still be a blank line,\n // but we’d be interrupting it w/ a new container if there’s a current\n // construct.\n\n self.interrupt = Boolean(\n childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n )\n } // Check if there is a new container.\n\n self.containerState = {}\n return effects.check(\n containerConstruct,\n thereIsANewContainer,\n thereIsNoNewContainer\n )(code)\n }\n /** @type {State} */\n\n function thereIsANewContainer(code) {\n if (childFlow) closeFlow()\n exitContainers(continued)\n return documentContinued(code)\n }\n /** @type {State} */\n\n function thereIsNoNewContainer(code) {\n self.parser.lazy[self.now().line] = continued !== stack.length\n lineStartOffset = self.now().offset\n return flowStart(code)\n }\n /** @type {State} */\n\n function documentContinued(code) {\n // Try new containers.\n self.containerState = {}\n return effects.attempt(\n containerConstruct,\n containerContinue,\n flowStart\n )(code)\n }\n /** @type {State} */\n\n function containerContinue(code) {\n continued++\n stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n return documentContinued(code)\n }\n /** @type {State} */\n\n function flowStart(code) {\n if (code === null) {\n if (childFlow) closeFlow()\n exitContainers(0)\n effects.consume(code)\n return\n }\n\n childFlow = childFlow || self.parser.flow(self.now())\n effects.enter('chunkFlow', {\n contentType: 'flow',\n previous: childToken,\n _tokenizer: childFlow\n })\n return flowContinue(code)\n }\n /** @type {State} */\n\n function flowContinue(code) {\n if (code === null) {\n writeToChild(effects.exit('chunkFlow'), true)\n exitContainers(0)\n effects.consume(code)\n return\n }\n\n if (markdownLineEnding(code)) {\n effects.consume(code)\n writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n continued = 0\n self.interrupt = undefined\n return start\n }\n\n effects.consume(code)\n return flowContinue\n }\n /**\n * @param {Token} token\n * @param {boolean} [eof]\n * @returns {void}\n */\n\n function writeToChild(token, eof) {\n const stream = self.sliceStream(token)\n if (eof) stream.push(null)\n token.previous = childToken\n if (childToken) childToken.next = token\n childToken = token\n childFlow.defineSkip(token.start)\n childFlow.write(stream) // Alright, so we just added a lazy line:\n //\n // ```markdown\n // > a\n // b.\n //\n // Or:\n //\n // > ~~~c\n // d\n //\n // Or:\n //\n // > | e |\n // f\n // ```\n //\n // The construct in the second example (fenced code) does not accept lazy\n // lines, so it marked itself as done at the end of its first line, and\n // then the content construct parses `d`.\n // Most constructs in markdown match on the first line: if the first line\n // forms a construct, a non-lazy line can’t “unmake” it.\n //\n // The construct in the third example is potentially a GFM table, and\n // those are *weird*.\n // It *could* be a table, from the first line, if the following line\n // matches a condition.\n // In this case, that second line is lazy, which “unmakes” the first line\n // and turns the whole into one content block.\n //\n // We’ve now parsed the non-lazy and the lazy line, and can figure out\n // whether the lazy line started a new flow block.\n // If it did, we exit the current containers between the two flow blocks.\n\n if (self.parser.lazy[token.start.line]) {\n let index = childFlow.events.length\n\n while (index--) {\n if (\n // The token starts before the line ending…\n childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n (!childFlow.events[index][1].end || // …or ends after it.\n childFlow.events[index][1].end.offset > lineStartOffset)\n ) {\n // Exit: there’s still something open, which means it’s a lazy line\n // part of something.\n return\n }\n } // Note: this algorithm for moving events around is similar to the\n // algorithm when closing flow in `documentContinue`.\n\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {boolean|undefined} */\n\n let seen\n /** @type {Point|undefined} */\n\n let point // Find the previous chunk (the one before the lazy line).\n\n while (indexBeforeFlow--) {\n if (\n self.events[indexBeforeFlow][0] === 'exit' &&\n self.events[indexBeforeFlow][1].type === 'chunkFlow'\n ) {\n if (seen) {\n point = self.events[indexBeforeFlow][1].end\n break\n }\n\n seen = true\n }\n }\n\n exitContainers(continued) // Fix positions.\n\n index = indexBeforeExits\n\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n } // Inject the exits earlier (they’re still also at the end).\n\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n ) // Discard the duplicate exits.\n\n self.events.length = index\n }\n }\n /**\n * @param {number} size\n * @returns {void}\n */\n\n function exitContainers(size) {\n let index = stack.length // Exit open containers.\n\n while (index-- > size) {\n const entry = stack[index]\n self.containerState = entry[1]\n entry[0].exit.call(self, effects)\n }\n\n stack.length = size\n }\n\n function closeFlow() {\n childFlow.write([null])\n childToken = undefined\n childFlow = undefined\n self.containerState._closeFlow = undefined\n }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n return factorySpace(\n effects,\n effects.attempt(this.parser.constructs.document, ok, nok),\n 'linePrefix',\n this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n )\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n const self = this\n const initial = effects.attempt(\n // Try to parse a blank line.\n blankLine,\n atBlankEnding, // Try to parse initial flow (essentially, only code).\n effects.attempt(\n this.parser.constructs.flowInitial,\n afterConstruct,\n factorySpace(\n effects,\n effects.attempt(\n this.parser.constructs.flow,\n afterConstruct,\n effects.attempt(content, afterConstruct)\n ),\n 'linePrefix'\n )\n )\n )\n return initial\n /** @type {State} */\n\n function atBlankEnding(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEndingBlank')\n effects.consume(code)\n effects.exit('lineEndingBlank')\n self.currentConstruct = undefined\n return initial\n }\n /** @type {State} */\n\n function afterConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEnding')\n effects.consume(code)\n effects.exit('lineEnding')\n self.currentConstruct = undefined\n return initial\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n return {\n tokenize: initializeText,\n resolveAll: createResolver(\n field === 'text' ? resolveAllLineSuffixes : undefined\n )\n }\n /** @type {Initializer} */\n\n function initializeText(effects) {\n const self = this\n const constructs = this.parser.constructs[field]\n const text = effects.attempt(constructs, start, notText)\n return start\n /** @type {State} */\n\n function start(code) {\n return atBreak(code) ? text(code) : notText(code)\n }\n /** @type {State} */\n\n function notText(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('data')\n effects.consume(code)\n return data\n }\n /** @type {State} */\n\n function data(code) {\n if (atBreak(code)) {\n effects.exit('data')\n return text(code)\n } // Data.\n\n effects.consume(code)\n return data\n }\n /**\n * @param {Code} code\n * @returns {boolean}\n */\n\n function atBreak(code) {\n if (code === null) {\n return true\n }\n\n const list = constructs[code]\n let index = -1\n\n if (list) {\n while (++index < list.length) {\n const item = list[index]\n\n if (!item.previous || item.previous.call(self, self.previous)) {\n return true\n }\n }\n }\n\n return false\n }\n }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n return resolveAllText\n /** @type {Resolver} */\n\n function resolveAllText(events, context) {\n let index = -1\n /** @type {number|undefined} */\n\n let enter // A rather boring computation (to merge adjacent `data` events) which\n // improves mm performance by 29%.\n\n while (++index <= events.length) {\n if (enter === undefined) {\n if (events[index] && events[index][1].type === 'data') {\n enter = index\n index++\n }\n } else if (!events[index] || events[index][1].type !== 'data') {\n // Don’t do anything if there is one data token.\n if (index !== enter + 2) {\n events[enter][1].end = events[index - 1][1].end\n events.splice(enter + 2, index - enter - 2)\n index = enter + 2\n }\n\n enter = undefined\n }\n }\n\n return extraResolver ? extraResolver(events, context) : events\n }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\nfunction resolveAllLineSuffixes(events, context) {\n let eventIndex = 0 // Skip first.\n\n while (++eventIndex <= events.length) {\n if (\n (eventIndex === events.length ||\n events[eventIndex][1].type === 'lineEnding') &&\n events[eventIndex - 1][1].type === 'data'\n ) {\n const data = events[eventIndex - 1][1]\n const chunks = context.sliceStream(data)\n let index = chunks.length\n let bufferIndex = -1\n let size = 0\n /** @type {boolean|undefined} */\n\n let tabs\n\n while (index--) {\n const chunk = chunks[index]\n\n if (typeof chunk === 'string') {\n bufferIndex = chunk.length\n\n while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n size++\n bufferIndex--\n }\n\n if (bufferIndex) break\n bufferIndex = -1\n } // Number\n else if (chunk === -2) {\n tabs = true\n size++\n } else if (chunk === -1) {\n // Empty\n } else {\n // Replacement character, exit.\n index++\n break\n }\n }\n\n if (size) {\n const token = {\n type:\n eventIndex === events.length || tabs || size < 2\n ? 'lineSuffix'\n : 'hardBreakTrailing',\n start: {\n line: data.end.line,\n column: data.end.column - size,\n offset: data.end.offset - size,\n _index: data.start._index + index,\n _bufferIndex: index\n ? bufferIndex\n : data.start._bufferIndex + bufferIndex\n },\n end: Object.assign({}, data.end)\n }\n data.end = Object.assign({}, token.start)\n\n if (data.start.offset === data.end.offset) {\n Object.assign(data, token)\n } else {\n events.splice(\n eventIndex,\n 0,\n ['enter', token, context],\n ['exit', token, context]\n )\n eventIndex += 2\n }\n }\n\n eventIndex++\n }\n }\n\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n * Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit} [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} */\n\n const columnStart = {}\n /** @type {Construct[]} */\n\n const resolveAllConstructs = []\n /** @type {Chunk[]} */\n\n let chunks = []\n /** @type {Token[]} */\n\n let stack = []\n /** @type {boolean|undefined} */\n\n let consumed = true\n /**\n * Tools used for tokenizing.\n *\n * @type {Effects}\n */\n\n const effects = {\n consume,\n enter,\n exit,\n attempt: constructFactory(onsuccessfulconstruct),\n check: constructFactory(onsuccessfulcheck),\n interrupt: constructFactory(onsuccessfulcheck, {\n interrupt: true\n })\n }\n /**\n * State and tools for resolving and serializing.\n *\n * @type {TokenizeContext}\n */\n\n const context = {\n previous: null,\n code: null,\n containerState: {},\n events: [],\n parser,\n sliceStream,\n sliceSerialize,\n now,\n defineSkip,\n write\n }\n /**\n * The state function.\n *\n * @type {State|void}\n */\n\n let state = initialize.tokenize.call(context, effects)\n /**\n * Track which character we expect to be consumed, to catch bugs.\n *\n * @type {Code}\n */\n\n let expectedCode\n\n if (initialize.resolveAll) {\n resolveAllConstructs.push(initialize)\n }\n\n return context\n /** @type {TokenizeContext['write']} */\n\n function write(slice) {\n chunks = push(chunks, slice)\n main() // Exit if we’re not done, resolve might change stuff.\n\n if (chunks[chunks.length - 1] !== null) {\n return []\n }\n\n addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n context.events = resolveAll(resolveAllConstructs, context.events, context)\n return context.events\n } //\n // Tools.\n //\n\n /** @type {TokenizeContext['sliceSerialize']} */\n\n function sliceSerialize(token, expandTabs) {\n return serializeChunks(sliceStream(token), expandTabs)\n }\n /** @type {TokenizeContext['sliceStream']} */\n\n function sliceStream(token) {\n return sliceChunks(chunks, token)\n }\n /** @type {TokenizeContext['now']} */\n\n function now() {\n return Object.assign({}, point)\n }\n /** @type {TokenizeContext['defineSkip']} */\n\n function defineSkip(value) {\n columnStart[value.line] = value.column\n accountForPotentialSkip()\n } //\n // State management.\n //\n\n /**\n * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n * `consume`).\n * Here is where we walk through the chunks, which either include strings of\n * several characters, or numerical character codes.\n * The reason to do this in a loop instead of a call is so the stack can\n * drain.\n *\n * @returns {void}\n */\n\n function main() {\n /** @type {number} */\n let chunkIndex\n\n while (point._index < chunks.length) {\n const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n if (typeof chunk === 'string') {\n chunkIndex = point._index\n\n if (point._bufferIndex < 0) {\n point._bufferIndex = 0\n }\n\n while (\n point._index === chunkIndex &&\n point._bufferIndex < chunk.length\n ) {\n go(chunk.charCodeAt(point._bufferIndex))\n }\n } else {\n go(chunk)\n }\n }\n }\n /**\n * Deal with one code.\n *\n * @param {Code} code\n * @returns {void}\n */\n\n function go(code) {\n consumed = undefined\n expectedCode = code\n state = state(code)\n }\n /** @type {Effects['consume']} */\n\n function consume(code) {\n if (markdownLineEnding(code)) {\n point.line++\n point.column = 1\n point.offset += code === -3 ? 2 : 1\n accountForPotentialSkip()\n } else if (code !== -1) {\n point.column++\n point.offset++\n } // Not in a string chunk.\n\n if (point._bufferIndex < 0) {\n point._index++\n } else {\n point._bufferIndex++ // At end of string chunk.\n // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n // strings.\n\n if (point._bufferIndex === chunks[point._index].length) {\n point._bufferIndex = -1\n point._index++\n }\n } // Expose the previous character.\n\n context.previous = code // Mark as consumed.\n\n consumed = true\n }\n /** @type {Effects['enter']} */\n\n function enter(type, fields) {\n /** @type {Token} */\n // @ts-expect-error Patch instead of assign required fields to help GC.\n const token = fields || {}\n token.type = type\n token.start = now()\n context.events.push(['enter', token, context])\n stack.push(token)\n return token\n }\n /** @type {Effects['exit']} */\n\n function exit(type) {\n const token = stack.pop()\n token.end = now()\n context.events.push(['exit', token, context])\n return token\n }\n /**\n * Use results.\n *\n * @type {ReturnHandle}\n */\n\n function onsuccessfulconstruct(construct, info) {\n addResult(construct, info.from)\n }\n /**\n * Discard results.\n *\n * @type {ReturnHandle}\n */\n\n function onsuccessfulcheck(_, info) {\n info.restore()\n }\n /**\n * Factory to attempt/check/interrupt.\n *\n * @param {ReturnHandle} onreturn\n * @param {Record} [fields]\n */\n\n function constructFactory(onreturn, fields) {\n return hook\n /**\n * Handle either an object mapping codes to constructs, a list of\n * constructs, or a single construct.\n *\n * @param {Construct|Construct[]|ConstructRecord} constructs\n * @param {State} returnState\n * @param {State} [bogusState]\n * @returns {State}\n */\n\n function hook(constructs, returnState, bogusState) {\n /** @type {Construct[]} */\n let listOfConstructs\n /** @type {number} */\n\n let constructIndex\n /** @type {Construct} */\n\n let currentConstruct\n /** @type {Info} */\n\n let info\n return Array.isArray(constructs)\n ? /* c8 ignore next 1 */\n handleListOfConstructs(constructs)\n : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n ? handleListOfConstructs([constructs])\n : handleMapOfConstructs(constructs)\n /**\n * Handle a list of construct.\n *\n * @param {ConstructRecord} map\n * @returns {State}\n */\n\n function handleMapOfConstructs(map) {\n return start\n /** @type {State} */\n\n function start(code) {\n const def = code !== null && map[code]\n const all = code !== null && map.null\n const list = [\n // To do: add more extension tests.\n\n /* c8 ignore next 2 */\n ...(Array.isArray(def) ? def : def ? [def] : []),\n ...(Array.isArray(all) ? all : all ? [all] : [])\n ]\n return handleListOfConstructs(list)(code)\n }\n }\n /**\n * Handle a list of construct.\n *\n * @param {Construct[]} list\n * @returns {State}\n */\n\n function handleListOfConstructs(list) {\n listOfConstructs = list\n constructIndex = 0\n\n if (list.length === 0) {\n return bogusState\n }\n\n return handleConstruct(list[constructIndex])\n }\n /**\n * Handle a single construct.\n *\n * @param {Construct} construct\n * @returns {State}\n */\n\n function handleConstruct(construct) {\n return start\n /** @type {State} */\n\n function start(code) {\n // To do: not needed to store if there is no bogus state, probably?\n // Currently doesn’t work because `inspect` in document does a check\n // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n // by not storing.\n info = store()\n currentConstruct = construct\n\n if (!construct.partial) {\n context.currentConstruct = construct\n }\n\n if (\n construct.name &&\n context.parser.constructs.disable.null.includes(construct.name)\n ) {\n return nok(code)\n }\n\n return construct.tokenize.call(\n // If we do have fields, create an object w/ `context` as its\n // prototype.\n // This allows a “live binding”, which is needed for `interrupt`.\n fields ? Object.assign(Object.create(context), fields) : context,\n effects,\n ok,\n nok\n )(code)\n }\n }\n /** @type {State} */\n\n function ok(code) {\n consumed = true\n onreturn(currentConstruct, info)\n return returnState\n }\n /** @type {State} */\n\n function nok(code) {\n consumed = true\n info.restore()\n\n if (++constructIndex < listOfConstructs.length) {\n return handleConstruct(listOfConstructs[constructIndex])\n }\n\n return bogusState\n }\n }\n }\n /**\n * @param {Construct} construct\n * @param {number} from\n * @returns {void}\n */\n\n function addResult(construct, from) {\n if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n resolveAllConstructs.push(construct)\n }\n\n if (construct.resolve) {\n splice(\n context.events,\n from,\n context.events.length - from,\n construct.resolve(context.events.slice(from), context)\n )\n }\n\n if (construct.resolveTo) {\n context.events = construct.resolveTo(context.events, context)\n }\n }\n /**\n * Store state.\n *\n * @returns {Info}\n */\n\n function store() {\n const startPoint = now()\n const startPrevious = context.previous\n const startCurrentConstruct = context.currentConstruct\n const startEventsIndex = context.events.length\n const startStack = Array.from(stack)\n return {\n restore,\n from: startEventsIndex\n }\n /**\n * Restore state.\n *\n * @returns {void}\n */\n\n function restore() {\n point = startPoint\n context.previous = startPrevious\n context.currentConstruct = startCurrentConstruct\n context.events.length = startEventsIndex\n stack = startStack\n accountForPotentialSkip()\n }\n }\n /**\n * Move the current point a bit forward in the line when it’s on a column\n * skip.\n *\n * @returns {void}\n */\n\n function accountForPotentialSkip() {\n if (point.line in columnStart && point.column < 2) {\n point.column = columnStart[point.line]\n point.offset += columnStart[point.line] - 1\n }\n }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Chunk[]} chunks\n * @param {Pick} token\n * @returns {Chunk[]}\n */\n\nfunction sliceChunks(chunks, token) {\n const startIndex = token.start._index\n const startBufferIndex = token.start._bufferIndex\n const endIndex = token.end._index\n const endBufferIndex = token.end._bufferIndex\n /** @type {Chunk[]} */\n\n let view\n\n if (startIndex === endIndex) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n } else {\n view = chunks.slice(startIndex, endIndex)\n\n if (startBufferIndex > -1) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view[0] = view[0].slice(startBufferIndex)\n }\n\n if (endBufferIndex > 0) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view.push(chunks[endIndex].slice(0, endBufferIndex))\n }\n }\n\n return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Chunk[]} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n let index = -1\n /** @type {string[]} */\n\n const result = []\n /** @type {boolean|undefined} */\n\n let atTab\n\n while (++index < chunks.length) {\n const chunk = chunks[index]\n /** @type {string} */\n\n let value\n\n if (typeof chunk === 'string') {\n value = chunk\n } else\n switch (chunk) {\n case -5: {\n value = '\\r'\n break\n }\n\n case -4: {\n value = '\\n'\n break\n }\n\n case -3: {\n value = '\\r' + '\\n'\n break\n }\n\n case -2: {\n value = expandTabs ? ' ' : '\\t'\n break\n }\n\n case -1: {\n if (!expandTabs && atTab) continue\n value = ' '\n break\n }\n\n default: {\n // Currently only replacement character.\n value = String.fromCharCode(chunk)\n }\n }\n\n atTab = chunk === -2\n result.push(value)\n }\n\n return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n attention,\n autolink,\n blockQuote,\n characterEscape,\n characterReference,\n codeFenced,\n codeIndented,\n codeText,\n definition,\n hardBreakEscape,\n headingAtx,\n htmlFlow,\n htmlText,\n labelEnd,\n labelStartImage,\n labelStartLink,\n lineEnding,\n list,\n setextUnderline,\n thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\nexport const document = {\n [42]: list,\n [43]: list,\n [45]: list,\n [48]: list,\n [49]: list,\n [50]: list,\n [51]: list,\n [52]: list,\n [53]: list,\n [54]: list,\n [55]: list,\n [56]: list,\n [57]: list,\n [62]: blockQuote\n}\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n [-2]: codeIndented,\n [-1]: codeIndented,\n [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\nexport const flow = {\n [35]: headingAtx,\n [42]: thematicBreak,\n [45]: [setextUnderline, thematicBreak],\n [60]: htmlFlow,\n [61]: setextUnderline,\n [95]: thematicBreak,\n [96]: codeFenced,\n [126]: codeFenced\n}\n/** @type {Extension['string']} */\n\nexport const string = {\n [38]: characterReference,\n [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\nexport const text = {\n [-5]: lineEnding,\n [-4]: lineEnding,\n [-3]: lineEnding,\n [33]: labelStartImage,\n [38]: characterReference,\n [42]: attention,\n [60]: [autolink, htmlText],\n [91]: labelStartLink,\n [92]: [hardBreakEscape, characterEscape],\n [93]: labelEnd,\n [95]: attention,\n [96]: codeText\n}\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Chunk[]}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n let column = 1\n let buffer = ''\n /** @type {boolean|undefined} */\n\n let start = true\n /** @type {boolean|undefined} */\n\n let atCarriageReturn\n return preprocessor\n /** @type {Preprocessor} */\n\n function preprocessor(value, encoding, end) {\n /** @type {Chunk[]} */\n const chunks = []\n /** @type {RegExpMatchArray|null} */\n\n let match\n /** @type {number} */\n\n let next\n /** @type {number} */\n\n let startPosition\n /** @type {number} */\n\n let endPosition\n /** @type {Code} */\n\n let code // @ts-expect-error `Buffer` does allow an encoding.\n\n value = buffer + value.toString(encoding)\n startPosition = 0\n buffer = ''\n\n if (start) {\n if (value.charCodeAt(0) === 65279) {\n startPosition++\n }\n\n start = undefined\n }\n\n while (startPosition < value.length) {\n search.lastIndex = startPosition\n match = search.exec(value)\n endPosition =\n match && match.index !== undefined ? match.index : value.length\n code = value.charCodeAt(endPosition)\n\n if (!match) {\n buffer = value.slice(startPosition)\n break\n }\n\n if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n chunks.push(-3)\n atCarriageReturn = undefined\n } else {\n if (atCarriageReturn) {\n chunks.push(-5)\n atCarriageReturn = undefined\n }\n\n if (startPosition < endPosition) {\n chunks.push(value.slice(startPosition, endPosition))\n column += endPosition - startPosition\n }\n\n switch (code) {\n case 0: {\n chunks.push(65533)\n column++\n break\n }\n\n case 9: {\n next = Math.ceil(column / 4) * 4\n chunks.push(-2)\n\n while (column++ < next) chunks.push(-1)\n\n break\n }\n\n case 10: {\n chunks.push(-4)\n column = 1\n break\n }\n\n default: {\n atCarriageReturn = true\n column = 1\n }\n }\n }\n\n startPosition = endPosition + 1\n }\n\n if (end) {\n if (atCarriageReturn) chunks.push(-5)\n if (buffer) chunks.push(buffer)\n chunks.push(null)\n }\n\n return chunks\n }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * @param {string} value\n * Value to decode.\n * @param {number} base\n * Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n const code = Number.parseInt(value, base)\n\n if (\n // C0 except for HT, LF, FF, CR, space\n code < 9 ||\n code === 11 ||\n (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n (code > 55295 && code < 57344) || // Noncharacters.\n (code > 64975 && code < 65008) ||\n (code & 65535) === 65535 ||\n (code & 65535) === 65534 || // Out of range\n code > 1114111\n ) {\n return '\\uFFFD'\n }\n\n return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n return value.replace(characterEscapeOrReference, decode)\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n if ($1) {\n // Escape.\n return $1\n } // Reference.\n\n const head = $2.charCodeAt(0)\n\n if (head === 35) {\n const head = $2.charCodeAt(1)\n const hex = head === 120 || head === 88\n return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n }\n\n return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {Extract} Parent\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {UnistParent & {type: 'fragment', children: Array}} Fragment\n */\n\n/**\n * @typedef _CompileDataFields\n * @property {boolean|undefined} expectingFirstListItemValue\n * @property {boolean|undefined} flowCodeInside\n * @property {boolean|undefined} setextHeadingSlurpLineEnding\n * @property {boolean|undefined} atHardBreak\n * @property {'collapsed'|'full'} referenceType\n * @property {boolean|undefined} inReference\n * @property {'characterReferenceMarkerHexadecimal'|'characterReferenceMarkerNumeric'} characterReferenceType\n *\n * @typedef {Record & Partial<_CompileDataFields>} CompileData\n *\n * @typedef {(tree: Root) => Root|void} Transform\n * @typedef {(this: CompileContext, token: Token) => void} Handle\n * @typedef {Record} Handles\n * Token types mapping to handles\n * @typedef {Record|Array> & {canContainEols: Array, transforms: Array, enter: Handles, exit: Handles}} NormalizedExtension\n * @typedef {Partial} Extension\n * An mdast extension changes how markdown tokens are turned into mdast.\n *\n * @typedef {(this: Omit, left: Token|undefined, right: Token) => void} OnEnterError\n * @typedef {(this: Omit, left: Token, right: Token) => void} OnExitError\n *\n * @typedef CompileContext\n * mdast compiler context\n * @property {Array} stack\n * @property {Array<[Token, OnEnterError|undefined]>} tokenStack\n * @property {(key: string, value?: unknown) => void} setData\n * Set data into the key-value store.\n * @property {(key: K) => CompileData[K]} getData\n * Get data from the key-value store.\n * @property {(this: CompileContext) => void} buffer\n * Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n * Stop capturing and access the output data.\n * @property {(this: CompileContext, node: N, token: Token, onError?: OnEnterError) => N} enter\n * Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n * Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n * Get the string value of a token.\n * @property {NormalizedExtension} config\n * Configuration.\n *\n * @typedef {{mdastExtensions?: Array>}} FromMarkdownOptions\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n */\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n/**\n * @param value Markdown to parse (`string` or `Buffer`).\n * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).\n * @param [options] Configuration\n */\n\nexport const fromMarkdown =\n /**\n * @type {(\n * ((value: Value, encoding: Encoding, options?: Options) => Root) &\n * ((value: Value, options?: Options) => Root)\n * )}\n */\n\n /**\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {Options} [options]\n * @returns {Root}\n */\n function (value, encoding, options) {\n if (typeof encoding !== 'string') {\n options = encoding\n encoding = undefined\n }\n\n return compiler(options)(\n postprocess(\n parse(options).document().write(preprocess()(value, encoding, true))\n )\n )\n }\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options} [options]\n */\n\nfunction compiler(options = {}) {\n /** @type {NormalizedExtension} */\n // @ts-expect-error: our base has all required fields, so the result will too.\n const config = configure(\n {\n transforms: [],\n canContainEols: [\n 'emphasis',\n 'fragment',\n 'heading',\n 'paragraph',\n 'strong'\n ],\n enter: {\n autolink: opener(link),\n autolinkProtocol: onenterdata,\n autolinkEmail: onenterdata,\n atxHeading: opener(heading),\n blockQuote: opener(blockQuote),\n characterEscape: onenterdata,\n characterReference: onenterdata,\n codeFenced: opener(codeFlow),\n codeFencedFenceInfo: buffer,\n codeFencedFenceMeta: buffer,\n codeIndented: opener(codeFlow, buffer),\n codeText: opener(codeText, buffer),\n codeTextData: onenterdata,\n data: onenterdata,\n codeFlowValue: onenterdata,\n definition: opener(definition),\n definitionDestinationString: buffer,\n definitionLabelString: buffer,\n definitionTitleString: buffer,\n emphasis: opener(emphasis),\n hardBreakEscape: opener(hardBreak),\n hardBreakTrailing: opener(hardBreak),\n htmlFlow: opener(html, buffer),\n htmlFlowData: onenterdata,\n htmlText: opener(html, buffer),\n htmlTextData: onenterdata,\n image: opener(image),\n label: buffer,\n link: opener(link),\n listItem: opener(listItem),\n listItemValue: onenterlistitemvalue,\n listOrdered: opener(list, onenterlistordered),\n listUnordered: opener(list),\n paragraph: opener(paragraph),\n reference: onenterreference,\n referenceString: buffer,\n resourceDestinationString: buffer,\n resourceTitleString: buffer,\n setextHeading: opener(heading),\n strong: opener(strong),\n thematicBreak: opener(thematicBreak)\n },\n exit: {\n atxHeading: closer(),\n atxHeadingSequence: onexitatxheadingsequence,\n autolink: closer(),\n autolinkEmail: onexitautolinkemail,\n autolinkProtocol: onexitautolinkprotocol,\n blockQuote: closer(),\n characterEscapeValue: onexitdata,\n characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n characterReferenceValue: onexitcharacterreferencevalue,\n codeFenced: closer(onexitcodefenced),\n codeFencedFence: onexitcodefencedfence,\n codeFencedFenceInfo: onexitcodefencedfenceinfo,\n codeFencedFenceMeta: onexitcodefencedfencemeta,\n codeFlowValue: onexitdata,\n codeIndented: closer(onexitcodeindented),\n codeText: closer(onexitcodetext),\n codeTextData: onexitdata,\n data: onexitdata,\n definition: closer(),\n definitionDestinationString: onexitdefinitiondestinationstring,\n definitionLabelString: onexitdefinitionlabelstring,\n definitionTitleString: onexitdefinitiontitlestring,\n emphasis: closer(),\n hardBreakEscape: closer(onexithardbreak),\n hardBreakTrailing: closer(onexithardbreak),\n htmlFlow: closer(onexithtmlflow),\n htmlFlowData: onexitdata,\n htmlText: closer(onexithtmltext),\n htmlTextData: onexitdata,\n image: closer(onexitimage),\n label: onexitlabel,\n labelText: onexitlabeltext,\n lineEnding: onexitlineending,\n link: closer(onexitlink),\n listItem: closer(),\n listOrdered: closer(),\n listUnordered: closer(),\n paragraph: closer(),\n referenceString: onexitreferencestring,\n resourceDestinationString: onexitresourcedestinationstring,\n resourceTitleString: onexitresourcetitlestring,\n resource: onexitresource,\n setextHeading: closer(onexitsetextheading),\n setextHeadingLineSequence: onexitsetextheadinglinesequence,\n setextHeadingText: onexitsetextheadingtext,\n strong: closer(),\n thematicBreak: closer()\n }\n },\n options.mdastExtensions || []\n )\n /** @type {CompileData} */\n\n const data = {}\n return compile\n /**\n * @param {Array} events\n * @returns {Root}\n */\n\n function compile(events) {\n /** @type {Root} */\n let tree = {\n type: 'root',\n children: []\n }\n /** @type {CompileContext['stack']} */\n\n const stack = [tree]\n /** @type {CompileContext['tokenStack']} */\n\n const tokenStack = []\n /** @type {Array} */\n\n const listStack = []\n /** @type {Omit} */\n\n const context = {\n stack,\n tokenStack,\n config,\n enter,\n exit,\n buffer,\n resume,\n setData,\n getData\n }\n let index = -1\n\n while (++index < events.length) {\n // We preprocess lists to add `listItem` tokens, and to infer whether\n // items the list itself are spread out.\n if (\n events[index][1].type === 'listOrdered' ||\n events[index][1].type === 'listUnordered'\n ) {\n if (events[index][0] === 'enter') {\n listStack.push(index)\n } else {\n const tail = listStack.pop()\n index = prepareList(events, tail, index)\n }\n }\n }\n\n index = -1\n\n while (++index < events.length) {\n const handler = config[events[index][0]]\n\n if (own.call(handler, events[index][1].type)) {\n handler[events[index][1].type].call(\n Object.assign(\n {\n sliceSerialize: events[index][2].sliceSerialize\n },\n context\n ),\n events[index][1]\n )\n }\n }\n\n if (tokenStack.length > 0) {\n const tail = tokenStack[tokenStack.length - 1]\n const handler = tail[1] || defaultOnError\n handler.call(context, undefined, tail[0])\n } // Figure out `root` position.\n\n tree.position = {\n start: point(\n events.length > 0\n ? events[0][1].start\n : {\n line: 1,\n column: 1,\n offset: 0\n }\n ),\n end: point(\n events.length > 0\n ? events[events.length - 2][1].end\n : {\n line: 1,\n column: 1,\n offset: 0\n }\n )\n }\n index = -1\n\n while (++index < config.transforms.length) {\n tree = config.transforms[index](tree) || tree\n }\n\n return tree\n }\n /**\n * @param {Array} events\n * @param {number} start\n * @param {number} length\n * @returns {number}\n */\n\n function prepareList(events, start, length) {\n let index = start - 1\n let containerBalance = -1\n let listSpread = false\n /** @type {Token|undefined} */\n\n let listItem\n /** @type {number|undefined} */\n\n let lineIndex\n /** @type {number|undefined} */\n\n let firstBlankLineIndex\n /** @type {boolean|undefined} */\n\n let atMarker\n\n while (++index <= length) {\n const event = events[index]\n\n if (\n event[1].type === 'listUnordered' ||\n event[1].type === 'listOrdered' ||\n event[1].type === 'blockQuote'\n ) {\n if (event[0] === 'enter') {\n containerBalance++\n } else {\n containerBalance--\n }\n\n atMarker = undefined\n } else if (event[1].type === 'lineEndingBlank') {\n if (event[0] === 'enter') {\n if (\n listItem &&\n !atMarker &&\n !containerBalance &&\n !firstBlankLineIndex\n ) {\n firstBlankLineIndex = index\n }\n\n atMarker = undefined\n }\n } else if (\n event[1].type === 'linePrefix' ||\n event[1].type === 'listItemValue' ||\n event[1].type === 'listItemMarker' ||\n event[1].type === 'listItemPrefix' ||\n event[1].type === 'listItemPrefixWhitespace'\n ) {\n // Empty.\n } else {\n atMarker = undefined\n }\n\n if (\n (!containerBalance &&\n event[0] === 'enter' &&\n event[1].type === 'listItemPrefix') ||\n (containerBalance === -1 &&\n event[0] === 'exit' &&\n (event[1].type === 'listUnordered' ||\n event[1].type === 'listOrdered'))\n ) {\n if (listItem) {\n let tailIndex = index\n lineIndex = undefined\n\n while (tailIndex--) {\n const tailEvent = events[tailIndex]\n\n if (\n tailEvent[1].type === 'lineEnding' ||\n tailEvent[1].type === 'lineEndingBlank'\n ) {\n if (tailEvent[0] === 'exit') continue\n\n if (lineIndex) {\n events[lineIndex][1].type = 'lineEndingBlank'\n listSpread = true\n }\n\n tailEvent[1].type = 'lineEnding'\n lineIndex = tailIndex\n } else if (\n tailEvent[1].type === 'linePrefix' ||\n tailEvent[1].type === 'blockQuotePrefix' ||\n tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n tailEvent[1].type === 'blockQuoteMarker' ||\n tailEvent[1].type === 'listItemIndent'\n ) {\n // Empty\n } else {\n break\n }\n }\n\n if (\n firstBlankLineIndex &&\n (!lineIndex || firstBlankLineIndex < lineIndex)\n ) {\n // @ts-expect-error Patched.\n listItem._spread = true\n } // Fix position.\n\n listItem.end = Object.assign(\n {},\n lineIndex ? events[lineIndex][1].start : event[1].end\n )\n events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n index++\n length++\n } // Create a new list item.\n\n if (event[1].type === 'listItemPrefix') {\n listItem = {\n type: 'listItem',\n // @ts-expect-error Patched\n _spread: false,\n start: Object.assign({}, event[1].start)\n } // @ts-expect-error: `listItem` is most definitely defined, TS...\n\n events.splice(index, 0, ['enter', listItem, event[2]])\n index++\n length++\n firstBlankLineIndex = undefined\n atMarker = true\n }\n }\n } // @ts-expect-error Patched.\n\n events[start][1]._spread = listSpread\n return length\n }\n /**\n * @type {CompileContext['setData']}\n * @param [value]\n */\n\n function setData(key, value) {\n data[key] = value\n }\n /**\n * @type {CompileContext['getData']}\n * @template {string} K\n * @param {K} key\n * @returns {CompileData[K]}\n */\n\n function getData(key) {\n return data[key]\n }\n /**\n * @param {Point} d\n * @returns {Point}\n */\n\n function point(d) {\n return {\n line: d.line,\n column: d.column,\n offset: d.offset\n }\n }\n /**\n * @param {(token: Token) => Node} create\n * @param {Handle} [and]\n * @returns {Handle}\n */\n\n function opener(create, and) {\n return open\n /**\n * @this {CompileContext}\n * @param {Token} token\n * @returns {void}\n */\n\n function open(token) {\n enter.call(this, create(token), token)\n if (and) and.call(this, token)\n }\n }\n /** @type {CompileContext['buffer']} */\n\n function buffer() {\n this.stack.push({\n type: 'fragment',\n children: []\n })\n }\n /**\n * @type {CompileContext['enter']}\n * @template {Node} N\n * @this {CompileContext}\n * @param {N} node\n * @param {Token} token\n * @param {OnEnterError} [errorHandler]\n * @returns {N}\n */\n\n function enter(node, token, errorHandler) {\n const parent = this.stack[this.stack.length - 1]\n // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n parent.children.push(node)\n this.stack.push(node)\n this.tokenStack.push([token, errorHandler]) // @ts-expect-error: `end` will be patched later.\n\n node.position = {\n start: point(token.start)\n }\n return node\n }\n /**\n * @param {Handle} [and]\n * @returns {Handle}\n */\n\n function closer(and) {\n return close\n /**\n * @this {CompileContext}\n * @param {Token} token\n * @returns {void}\n */\n\n function close(token) {\n if (and) and.call(this, token)\n exit.call(this, token)\n }\n }\n /**\n * @type {CompileContext['exit']}\n * @this {CompileContext}\n * @param {Token} token\n * @param {OnExitError} [onExitError]\n * @returns {Node}\n */\n\n function exit(token, onExitError) {\n const node = this.stack.pop()\n const open = this.tokenStack.pop()\n\n if (!open) {\n throw new Error(\n 'Cannot close `' +\n token.type +\n '` (' +\n stringifyPosition({\n start: token.start,\n end: token.end\n }) +\n '): it’s not open'\n )\n } else if (open[0].type !== token.type) {\n if (onExitError) {\n onExitError.call(this, token, open[0])\n } else {\n const handler = open[1] || defaultOnError\n handler.call(this, token, open[0])\n }\n }\n\n node.position.end = point(token.end)\n return node\n }\n /**\n * @this {CompileContext}\n * @returns {string}\n */\n\n function resume() {\n return toString(this.stack.pop())\n } //\n // Handlers.\n //\n\n /** @type {Handle} */\n\n function onenterlistordered() {\n setData('expectingFirstListItemValue', true)\n }\n /** @type {Handle} */\n\n function onenterlistitemvalue(token) {\n if (getData('expectingFirstListItemValue')) {\n const ancestor =\n /** @type {List} */\n this.stack[this.stack.length - 2]\n ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n setData('expectingFirstListItemValue')\n }\n }\n /** @type {Handle} */\n\n function onexitcodefencedfenceinfo() {\n const data = this.resume()\n const node =\n /** @type {Code} */\n this.stack[this.stack.length - 1]\n node.lang = data\n }\n /** @type {Handle} */\n\n function onexitcodefencedfencemeta() {\n const data = this.resume()\n const node =\n /** @type {Code} */\n this.stack[this.stack.length - 1]\n node.meta = data\n }\n /** @type {Handle} */\n\n function onexitcodefencedfence() {\n // Exit if this is the closing fence.\n if (getData('flowCodeInside')) return\n this.buffer()\n setData('flowCodeInside', true)\n }\n /** @type {Handle} */\n\n function onexitcodefenced() {\n const data = this.resume()\n const node =\n /** @type {Code} */\n this.stack[this.stack.length - 1]\n node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n setData('flowCodeInside')\n }\n /** @type {Handle} */\n\n function onexitcodeindented() {\n const data = this.resume()\n const node =\n /** @type {Code} */\n this.stack[this.stack.length - 1]\n node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n }\n /** @type {Handle} */\n\n function onexitdefinitionlabelstring(token) {\n // Discard label, use the source content instead.\n const label = this.resume()\n const node =\n /** @type {Definition} */\n this.stack[this.stack.length - 1]\n node.label = label\n node.identifier = normalizeIdentifier(\n this.sliceSerialize(token)\n ).toLowerCase()\n }\n /** @type {Handle} */\n\n function onexitdefinitiontitlestring() {\n const data = this.resume()\n const node =\n /** @type {Definition} */\n this.stack[this.stack.length - 1]\n node.title = data\n }\n /** @type {Handle} */\n\n function onexitdefinitiondestinationstring() {\n const data = this.resume()\n const node =\n /** @type {Definition} */\n this.stack[this.stack.length - 1]\n node.url = data\n }\n /** @type {Handle} */\n\n function onexitatxheadingsequence(token) {\n const node =\n /** @type {Heading} */\n this.stack[this.stack.length - 1]\n\n if (!node.depth) {\n const depth = this.sliceSerialize(token).length\n node.depth = depth\n }\n }\n /** @type {Handle} */\n\n function onexitsetextheadingtext() {\n setData('setextHeadingSlurpLineEnding', true)\n }\n /** @type {Handle} */\n\n function onexitsetextheadinglinesequence(token) {\n const node =\n /** @type {Heading} */\n this.stack[this.stack.length - 1]\n node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n }\n /** @type {Handle} */\n\n function onexitsetextheading() {\n setData('setextHeadingSlurpLineEnding')\n }\n /** @type {Handle} */\n\n function onenterdata(token) {\n const parent =\n /** @type {Parent} */\n this.stack[this.stack.length - 1]\n /** @type {Node} */\n\n let tail = parent.children[parent.children.length - 1]\n\n if (!tail || tail.type !== 'text') {\n // Add a new text node.\n tail = text() // @ts-expect-error: we’ll add `end` later.\n\n tail.position = {\n start: point(token.start)\n } // @ts-expect-error: Assume `parent` accepts `text`.\n\n parent.children.push(tail)\n }\n\n this.stack.push(tail)\n }\n /** @type {Handle} */\n\n function onexitdata(token) {\n const tail = this.stack.pop()\n tail.value += this.sliceSerialize(token)\n tail.position.end = point(token.end)\n }\n /** @type {Handle} */\n\n function onexitlineending(token) {\n const context = this.stack[this.stack.length - 1]\n\n // If we’re at a hard break, include the line ending in there.\n if (getData('atHardBreak')) {\n const tail = context.children[context.children.length - 1]\n tail.position.end = point(token.end)\n setData('atHardBreak')\n return\n }\n\n if (\n !getData('setextHeadingSlurpLineEnding') &&\n config.canContainEols.includes(context.type)\n ) {\n onenterdata.call(this, token)\n onexitdata.call(this, token)\n }\n }\n /** @type {Handle} */\n\n function onexithardbreak() {\n setData('atHardBreak', true)\n }\n /** @type {Handle} */\n\n function onexithtmlflow() {\n const data = this.resume()\n const node =\n /** @type {HTML} */\n this.stack[this.stack.length - 1]\n node.value = data\n }\n /** @type {Handle} */\n\n function onexithtmltext() {\n const data = this.resume()\n const node =\n /** @type {HTML} */\n this.stack[this.stack.length - 1]\n node.value = data\n }\n /** @type {Handle} */\n\n function onexitcodetext() {\n const data = this.resume()\n const node =\n /** @type {InlineCode} */\n this.stack[this.stack.length - 1]\n node.value = data\n }\n /** @type {Handle} */\n\n function onexitlink() {\n const context =\n /** @type {Link & {identifier: string, label: string}} */\n this.stack[this.stack.length - 1] // To do: clean.\n\n if (getData('inReference')) {\n context.type += 'Reference' // @ts-expect-error: mutate.\n\n context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n delete context.url\n delete context.title\n } else {\n // @ts-expect-error: mutate.\n delete context.identifier // @ts-expect-error: mutate.\n\n delete context.label\n }\n\n setData('referenceType')\n }\n /** @type {Handle} */\n\n function onexitimage() {\n const context =\n /** @type {Image & {identifier: string, label: string}} */\n this.stack[this.stack.length - 1] // To do: clean.\n\n if (getData('inReference')) {\n context.type += 'Reference' // @ts-expect-error: mutate.\n\n context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n delete context.url\n delete context.title\n } else {\n // @ts-expect-error: mutate.\n delete context.identifier // @ts-expect-error: mutate.\n\n delete context.label\n }\n\n setData('referenceType')\n }\n /** @type {Handle} */\n\n function onexitlabeltext(token) {\n const ancestor =\n /** @type {(Link|Image) & {identifier: string, label: string}} */\n this.stack[this.stack.length - 2]\n const string = this.sliceSerialize(token)\n ancestor.label = decodeString(string)\n ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n }\n /** @type {Handle} */\n\n function onexitlabel() {\n const fragment =\n /** @type {Fragment} */\n this.stack[this.stack.length - 1]\n const value = this.resume()\n const node =\n /** @type {(Link|Image) & {identifier: string, label: string}} */\n this.stack[this.stack.length - 1] // Assume a reference.\n\n setData('inReference', true)\n\n if (node.type === 'link') {\n // @ts-expect-error: Assume static phrasing content.\n node.children = fragment.children\n } else {\n node.alt = value\n }\n }\n /** @type {Handle} */\n\n function onexitresourcedestinationstring() {\n const data = this.resume()\n const node =\n /** @type {Link|Image} */\n this.stack[this.stack.length - 1]\n node.url = data\n }\n /** @type {Handle} */\n\n function onexitresourcetitlestring() {\n const data = this.resume()\n const node =\n /** @type {Link|Image} */\n this.stack[this.stack.length - 1]\n node.title = data\n }\n /** @type {Handle} */\n\n function onexitresource() {\n setData('inReference')\n }\n /** @type {Handle} */\n\n function onenterreference() {\n setData('referenceType', 'collapsed')\n }\n /** @type {Handle} */\n\n function onexitreferencestring(token) {\n const label = this.resume()\n const node =\n /** @type {LinkReference|ImageReference} */\n this.stack[this.stack.length - 1]\n node.label = label\n node.identifier = normalizeIdentifier(\n this.sliceSerialize(token)\n ).toLowerCase()\n setData('referenceType', 'full')\n }\n /** @type {Handle} */\n\n function onexitcharacterreferencemarker(token) {\n setData('characterReferenceType', token.type)\n }\n /** @type {Handle} */\n\n function onexitcharacterreferencevalue(token) {\n const data = this.sliceSerialize(token)\n const type = getData('characterReferenceType')\n /** @type {string} */\n\n let value\n\n if (type) {\n value = decodeNumericCharacterReference(\n data,\n type === 'characterReferenceMarkerNumeric' ? 10 : 16\n )\n setData('characterReferenceType')\n } else {\n // @ts-expect-error `decodeNamedCharacterReference` can return false for\n // invalid named character references, but everything we’ve tokenized is\n // valid.\n value = decodeNamedCharacterReference(data)\n }\n\n const tail = this.stack.pop()\n tail.value += value\n tail.position.end = point(token.end)\n }\n /** @type {Handle} */\n\n function onexitautolinkprotocol(token) {\n onexitdata.call(this, token)\n const node =\n /** @type {Link} */\n this.stack[this.stack.length - 1]\n node.url = this.sliceSerialize(token)\n }\n /** @type {Handle} */\n\n function onexitautolinkemail(token) {\n onexitdata.call(this, token)\n const node =\n /** @type {Link} */\n this.stack[this.stack.length - 1]\n node.url = 'mailto:' + this.sliceSerialize(token)\n } //\n // Creaters.\n //\n\n /** @returns {Blockquote} */\n\n function blockQuote() {\n return {\n type: 'blockquote',\n children: []\n }\n }\n /** @returns {Code} */\n\n function codeFlow() {\n return {\n type: 'code',\n lang: null,\n meta: null,\n value: ''\n }\n }\n /** @returns {InlineCode} */\n\n function codeText() {\n return {\n type: 'inlineCode',\n value: ''\n }\n }\n /** @returns {Definition} */\n\n function definition() {\n return {\n type: 'definition',\n identifier: '',\n label: null,\n title: null,\n url: ''\n }\n }\n /** @returns {Emphasis} */\n\n function emphasis() {\n return {\n type: 'emphasis',\n children: []\n }\n }\n /** @returns {Heading} */\n\n function heading() {\n // @ts-expect-error `depth` will be set later.\n return {\n type: 'heading',\n depth: undefined,\n children: []\n }\n }\n /** @returns {Break} */\n\n function hardBreak() {\n return {\n type: 'break'\n }\n }\n /** @returns {HTML} */\n\n function html() {\n return {\n type: 'html',\n value: ''\n }\n }\n /** @returns {Image} */\n\n function image() {\n return {\n type: 'image',\n title: null,\n url: '',\n alt: null\n }\n }\n /** @returns {Link} */\n\n function link() {\n return {\n type: 'link',\n title: null,\n url: '',\n children: []\n }\n }\n /**\n * @param {Token} token\n * @returns {List}\n */\n\n function list(token) {\n return {\n type: 'list',\n ordered: token.type === 'listOrdered',\n start: null,\n // @ts-expect-error Patched.\n spread: token._spread,\n children: []\n }\n }\n /**\n * @param {Token} token\n * @returns {ListItem}\n */\n\n function listItem(token) {\n return {\n type: 'listItem',\n // @ts-expect-error Patched.\n spread: token._spread,\n checked: null,\n children: []\n }\n }\n /** @returns {Paragraph} */\n\n function paragraph() {\n return {\n type: 'paragraph',\n children: []\n }\n }\n /** @returns {Strong} */\n\n function strong() {\n return {\n type: 'strong',\n children: []\n }\n }\n /** @returns {Text} */\n\n function text() {\n return {\n type: 'text',\n value: ''\n }\n }\n /** @returns {ThematicBreak} */\n\n function thematicBreak() {\n return {\n type: 'thematicBreak'\n }\n }\n}\n/**\n * @param {Extension} combined\n * @param {Array>} extensions\n * @returns {Extension}\n */\n\nfunction configure(combined, extensions) {\n let index = -1\n\n while (++index < extensions.length) {\n const value = extensions[index]\n\n if (Array.isArray(value)) {\n configure(combined, value)\n } else {\n extension(combined, value)\n }\n }\n\n return combined\n}\n/**\n * @param {Extension} combined\n * @param {Extension} extension\n * @returns {void}\n */\n\nfunction extension(combined, extension) {\n /** @type {string} */\n let key\n\n for (key in extension) {\n if (own.call(extension, key)) {\n const list = key === 'canContainEols' || key === 'transforms'\n const maybe = own.call(combined, key) ? combined[key] : undefined\n /* c8 ignore next */\n\n const left = maybe || (combined[key] = list ? [] : {})\n const right = extension[key]\n\n if (right) {\n if (list) {\n // @ts-expect-error: `left` is an array.\n combined[key] = [...left, ...right]\n } else {\n Object.assign(left, right)\n }\n }\n }\n }\n}\n/** @type {OnEnterError} */\n\nfunction defaultOnError(left, right) {\n if (left) {\n throw new Error(\n 'Cannot close `' +\n left.type +\n '` (' +\n stringifyPosition({\n start: left.start,\n end: left.end\n }) +\n '): a different token (`' +\n right.type +\n '`, ' +\n stringifyPosition({\n start: right.start,\n end: right.end\n }) +\n ') is open'\n )\n } else {\n throw new Error(\n 'Cannot close document, a token (`' +\n right.type +\n '`, ' +\n stringifyPosition({\n start: right.start,\n end: right.end\n }) +\n ') is still open'\n )\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Event[]} events\n * @returns {Event[]}\n */\n\nexport function postprocess(events) {\n while (!subtokenize(events)) {\n // Empty\n }\n\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n /** @type {FullNormalizedExtension} */\n // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n const constructs = combineExtensions(\n // @ts-expect-error Same as above.\n [defaultConstructs].concat(options.extensions || [])\n )\n /** @type {ParseContext} */\n\n const parser = {\n defined: [],\n lazy: {},\n constructs,\n content: create(content),\n document: create(document),\n flow: create(flow),\n string: create(string),\n text: create(text)\n }\n return parser\n /**\n * @param {InitialConstruct} initial\n */\n\n function create(initial) {\n return creator\n /** @type {Create} */\n\n function creator(from) {\n return createTokenizer(parser, initial, from)\n }\n }\n}\n","import remarkParse from './lib/index.js'\n\nexport default remarkParse\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */\nexport default function remarkParse(options) {\n /** @type {import('unified').ParserFunction} */\n const parser = (doc) => {\n // Assume options.\n const settings = /** @type {Options} */ (this.data('settings'))\n\n return fromMarkdown(\n doc,\n Object.assign({}, settings, options, {\n // Note: these options are not in the readme.\n // The goal is for them to be set by plugins on `data` instead of being\n // passed by users.\n extensions: this.data('micromarkExtensions') || [],\n mdastExtensions: this.data('fromMarkdownExtensions') || []\n })\n )\n }\n\n Object.assign(this, {Parser: parser})\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist').Literal} Literal\n * @typedef {Object.} Props\n * @typedef {Array.|string} ChildrenOrValue\n *\n * @typedef {(, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps\n * @typedef {(>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps\n * @typedef {(>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps\n * @typedef {((type: T, children: C) => {type: T, children: C})} BuildParent\n * @typedef {((type: T, value: string) => {type: T, value: string})} BuildLiteral\n * @typedef {((type: T) => {type: T})} BuildVoid\n */\n\nexport var u = /**\n * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}\n */ (\n /**\n * @param {string} type Type of node\n * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)\n * @param {ChildrenOrValue} [value] `children` or `value` of node\n * @returns {Node}\n */\n function (type, props, value) {\n /** @type {Node} */\n var node = {type: String(type)}\n\n if (\n (value === undefined || value === null) &&\n (typeof props === 'string' || Array.isArray(props))\n ) {\n value = props\n } else {\n Object.assign(node, props)\n }\n\n if (Array.isArray(value)) {\n node.children = value\n } else if (value !== undefined && value !== null) {\n node.value = String(value)\n }\n\n return node\n }\n)\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\nexport const is =\n /**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @type {(\n * ((node: unknown, test: T['type']|Partial|TestFunctionPredicate|Array.|TestFunctionPredicate>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n * ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n * )}\n */\n (\n /**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @param {unknown} [node] Node to check\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @param {number|null|undefined} [index] Position of `node` in `parent`\n * @param {Parent|null|undefined} [parent] Parent of `node`\n * @param {unknown} [context] Context object to invoke `test` with\n * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n */\n // eslint-disable-next-line max-params\n function is(node, test, index, parent, context) {\n const check = convert(test)\n\n if (\n index !== undefined &&\n index !== null &&\n (typeof index !== 'number' ||\n index < 0 ||\n index === Number.POSITIVE_INFINITY)\n ) {\n throw new Error('Expected positive finite index')\n }\n\n if (\n parent !== undefined &&\n parent !== null &&\n (!is(parent) || !parent.children)\n ) {\n throw new Error('Expected parent node')\n }\n\n if (\n (parent === undefined || parent === null) !==\n (index === undefined || index === null)\n ) {\n throw new Error('Expected both parent and index')\n }\n\n // @ts-expect-error Looks like a node.\n return node && node.type && typeof node.type === 'string'\n ? Boolean(check.call(context, node, index, parent))\n : false\n }\n )\n\nexport const convert =\n /**\n * @type {(\n * ((test: T['type']|Partial|TestFunctionPredicate) => AssertPredicate) &\n * ((test?: Test) => AssertAnything)\n * )}\n */\n (\n /**\n * Generate an assertion from a check.\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @returns {AssertAnything}\n */\n function (test) {\n if (test === undefined || test === null) {\n return ok\n }\n\n if (typeof test === 'string') {\n return typeFactory(test)\n }\n\n if (typeof test === 'object') {\n return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n }\n\n if (typeof test === 'function') {\n return castFactory(test)\n }\n\n throw new Error('Expected function, string, or object as test')\n }\n )\n/**\n * @param {Array.} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n /** @type {Array.} */\n const checks = []\n let index = -1\n\n while (++index < tests.length) {\n checks[index] = convert(tests[index])\n }\n\n return castFactory(any)\n\n /**\n * @this {unknown}\n * @param {unknown[]} parameters\n * @returns {boolean}\n */\n function any(...parameters) {\n let index = -1\n\n while (++index < checks.length) {\n if (checks[index].call(this, ...parameters)) return true\n }\n\n return false\n }\n}\n\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n return castFactory(all)\n\n /**\n * @param {Node} node\n * @returns {boolean}\n */\n function all(node) {\n /** @type {string} */\n let key\n\n for (key in check) {\n // @ts-expect-error: hush, it sure works as an index.\n if (node[key] !== check[key]) return false\n }\n\n return true\n }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\n */\nfunction typeFactory(check) {\n return castFactory(type)\n\n /**\n * @param {Node} node\n */\n function type(node) {\n return node && node.type === check\n }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n return assertion\n\n /**\n * @this {unknown}\n * @param {Array.} parameters\n * @returns {boolean}\n */\n function assertion(...parameters) {\n // @ts-expect-error: spreading is fine.\n return Boolean(check.call(this, ...parameters))\n }\n}\n\n// Utility to return true.\nfunction ok() {\n return true\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types').Action} Action\n * @typedef {import('./complex-types').Index} Index\n * @typedef {import('./complex-types').ActionTuple} ActionTuple\n * @typedef {import('./complex-types').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = true\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = 'skip'\n/**\n * Stop traversing immediately\n */\nexport const EXIT = false\n\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test node, optional\n * @param visitor Function to run for each node\n * @param reverse Visit the tree in reverse order, defaults to false\n */\nexport const visitParents =\n /**\n * @type {(\n * ((tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor, reverse?: boolean) => void) &\n * ((tree: Tree, visitor: import('./complex-types').BuildVisitor, reverse?: boolean) => void)\n * )}\n */\n (\n /**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor} visitor\n * @param {boolean} [reverse]\n */\n function (tree, test, visitor, reverse) {\n if (typeof test === 'function' && typeof visitor !== 'function') {\n reverse = visitor\n // @ts-expect-error no visitor given, so `visitor` is test.\n visitor = test\n test = null\n }\n\n const is = convert(test)\n const step = reverse ? -1 : 1\n\n factory(tree, null, [])()\n\n /**\n * @param {Node} node\n * @param {number?} index\n * @param {Array.} parents\n */\n function factory(node, index, parents) {\n /** @type {Object.} */\n // @ts-expect-error: hush\n const value = typeof node === 'object' && node !== null ? node : {}\n /** @type {string|undefined} */\n let name\n\n if (typeof value.type === 'string') {\n name =\n typeof value.tagName === 'string'\n ? value.tagName\n : typeof value.name === 'string'\n ? value.name\n : undefined\n\n Object.defineProperty(visit, 'name', {\n value:\n 'node (' +\n color(value.type + (name ? '<' + name + '>' : '')) +\n ')'\n })\n }\n\n return visit\n\n function visit() {\n /** @type {ActionTuple} */\n let result = []\n /** @type {ActionTuple} */\n let subresult\n /** @type {number} */\n let offset\n /** @type {Array.} */\n let grandparents\n\n if (!test || is(node, index, parents[parents.length - 1] || null)) {\n result = toResult(visitor(node, parents))\n\n if (result[0] === EXIT) {\n return result\n }\n }\n\n // @ts-expect-error looks like a parent.\n if (node.children && result[0] !== SKIP) {\n // @ts-expect-error looks like a parent.\n offset = (reverse ? node.children.length : -1) + step\n // @ts-expect-error looks like a parent.\n grandparents = parents.concat(node)\n\n // @ts-expect-error looks like a parent.\n while (offset > -1 && offset < node.children.length) {\n // @ts-expect-error looks like a parent.\n subresult = factory(node.children[offset], offset, grandparents)()\n\n if (subresult[0] === EXIT) {\n return subresult\n }\n\n offset =\n typeof subresult[1] === 'number' ? subresult[1] : offset + step\n }\n }\n\n return result\n }\n }\n }\n )\n\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\n */\nfunction toResult(value) {\n if (Array.isArray(value)) {\n return value\n }\n\n if (typeof value === 'number') {\n return [CONTINUE, value]\n }\n\n return [value]\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\n\nimport {visitParents, CONTINUE, SKIP, EXIT} from 'unist-util-visit-parents'\n\nexport {CONTINUE, SKIP, EXIT}\n\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test, optional\n * @param visitor Function to run for each node\n * @param reverse Fisit the tree in reverse, defaults to false\n */\nexport const visit =\n /**\n * @type {(\n * ((tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor, reverse?: boolean) => void) &\n * ((tree: Tree, visitor: import('./complex-types').BuildVisitor, reverse?: boolean) => void)\n * )}\n */\n (\n /**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor} visitor\n * @param {boolean} [reverse]\n */\n function (tree, test, visitor, reverse) {\n if (typeof test === 'function' && typeof visitor !== 'function') {\n reverse = visitor\n visitor = test\n test = null\n }\n\n visitParents(tree, test, overload, reverse)\n\n /**\n * @param {Node} node\n * @param {Array.} parents\n */\n function overload(node, parents) {\n const parent = parents[parents.length - 1]\n return visitor(\n node,\n parent ? parent.children.indexOf(node) : null,\n parent\n )\n }\n }\n )\n","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {Record & {type: string, position?: PositionLike|undefined}} NodeLike\n * @typedef {import('unist').Point} Point\n *\n * @typedef {Partial} PointLike\n *\n * @typedef PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n */\n\nexport const pointStart = point('start')\nexport const pointEnd = point('end')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Position}\n */\nexport function position(node) {\n return {start: pointStart(node), end: pointEnd(node)}\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'start'|'end'} type\n */\nfunction point(type) {\n return point\n\n /**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Point}\n */\n function point(node) {\n const point = (node && node.position && node.position[type]) || {}\n\n return {\n line: point.line || null,\n column: point.column || null,\n offset: point.offset > -1 ? point.offset : null\n }\n }\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n * @typedef {import('mdast').Definition} Definition\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `node`.\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} node\n */\nexport function definitions(node) {\n /** @type {Record} */\n const cache = Object.create(null)\n\n if (!node || !node.type) {\n throw new Error('mdast-util-definitions expected node')\n }\n\n visit(node, 'definition', (definition) => {\n const id = clean(definition.identifier)\n if (id && !own.call(cache, id)) {\n cache[id] = definition\n }\n })\n\n return definition\n\n /**\n * Get a node from the bound definition cache.\n *\n * @param {string} identifier\n * @returns {Definition|null}\n */\n function definition(identifier) {\n const id = clean(identifier)\n return id && own.call(cache, id) ? cache[id] : null\n }\n}\n\n/**\n * @param {string} [value]\n * @returns {string}\n */\nfunction clean(value) {\n return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('./index.js').H} H\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Transform an unknown node.\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction unknown(h, node) {\n const data = node.data || {}\n\n if (\n 'value' in node &&\n !(\n own.call(data, 'hName') ||\n own.call(data, 'hProperties') ||\n own.call(data, 'hChildren')\n )\n ) {\n return h.augment(node, u('text', node.value))\n }\n\n return h(node, 'div', all(h, node))\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nexport function one(h, node, parent) {\n const type = node && node.type\n /** @type {Handler} */\n let fn\n\n // Fail on non-nodes.\n if (!type) {\n throw new Error('Expected node, got `' + node + '`')\n }\n\n if (own.call(h.handlers, type)) {\n fn = h.handlers[type]\n } else if (h.passThrough && h.passThrough.includes(type)) {\n fn = returnNode\n } else {\n fn = h.unknownHandler\n }\n\n return (typeof fn === 'function' ? fn : unknown)(h, node, parent)\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction returnNode(h, node) {\n // @ts-expect-error: Pass through custom node.\n return 'children' in node ? {...node, children: all(h, node)} : node\n}\n\n/**\n * @param {H} h\n * @param {MdastNode} parent\n */\nexport function all(h, parent) {\n /** @type {Array} */\n const values = []\n\n if ('children' in parent) {\n const nodes = parent.children\n let index = -1\n\n while (++index < nodes.length) {\n const result = one(h, nodes[index], parent)\n\n if (result) {\n if (index && nodes[index - 1].type === 'break') {\n if (!Array.isArray(result) && result.type === 'text') {\n result.value = result.value.replace(/^\\s+/, '')\n }\n\n if (!Array.isArray(result) && result.type === 'element') {\n const head = result.children[0]\n\n if (head && head.type === 'text') {\n head.value = head.value.replace(/^\\s+/, '')\n }\n }\n }\n\n if (Array.isArray(result)) {\n values.push(...result)\n } else {\n values.push(result)\n }\n }\n }\n }\n\n return values\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, a regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,\n * or `/^https?$/i` for `img[src]`.\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\nexport function sanitizeUri(url, protocol) {\n const value = encode(normalizeUri(url || ''))\n\n if (!protocol) {\n return value\n }\n\n const colon = value.indexOf(':')\n const questionMark = value.indexOf('?')\n const numberSign = value.indexOf('#')\n const slash = value.indexOf('/')\n\n if (\n // If there is no protocol, it’s relative.\n colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n (slash > -1 && colon > slash) ||\n (questionMark > -1 && colon > questionMark) ||\n (numberSign > -1 && colon > numberSign) || // It is a protocol, it should be allowed.\n protocol.test(value.slice(0, colon))\n ) {\n return value\n }\n\n return ''\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\n\nfunction normalizeUri(value) {\n /** @type {string[]} */\n const result = []\n let index = -1\n let start = 0\n let skip = 0\n\n while (++index < value.length) {\n const code = value.charCodeAt(index)\n /** @type {string} */\n\n let replace = '' // A correct percent encoded value.\n\n if (\n code === 37 &&\n asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n asciiAlphanumeric(value.charCodeAt(index + 2))\n ) {\n skip = 2\n } // ASCII.\n else if (code < 128) {\n if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n replace = String.fromCharCode(code)\n }\n } // Astral.\n else if (code > 55295 && code < 57344) {\n const next = value.charCodeAt(index + 1) // A correct surrogate pair.\n\n if (code < 56320 && next > 56319 && next < 57344) {\n replace = String.fromCharCode(code, next)\n skip = 1\n } // Lone surrogate.\n else {\n replace = '\\uFFFD'\n }\n } // Unicode.\n else {\n replace = String.fromCharCode(code)\n }\n\n if (replace) {\n result.push(value.slice(start, index), encodeURIComponent(replace))\n start = index + skip + 1\n replace = ''\n }\n\n if (skip) {\n index += skip\n skip = 0\n }\n }\n\n return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Wrap `nodes` with line feeds between each entry.\n * Optionally adds line feeds at the start and end.\n *\n * @param {Array} nodes\n * @param {boolean} [loose=false]\n * @returns {Array}\n */\nexport function wrap(nodes, loose) {\n /** @type {Array} */\n const result = []\n let index = -1\n\n if (loose) {\n result.push(u('text', '\\n'))\n }\n\n while (++index < nodes.length) {\n if (index) result.push(u('text', '\\n'))\n result.push(nodes[index])\n }\n\n if (loose && nodes.length > 0) {\n result.push(u('text', '\\n'))\n }\n\n return result\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {sanitizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {FootnoteReference} node\n */\nexport function footnoteReference(h, node) {\n const id = String(node.identifier)\n const safeId = sanitizeUri(id.toLowerCase())\n const index = h.footnoteOrder.indexOf(id)\n /** @type {number} */\n let counter\n\n if (index === -1) {\n h.footnoteOrder.push(id)\n h.footnoteCounts[id] = 1\n counter = h.footnoteOrder.length\n } else {\n h.footnoteCounts[id]++\n counter = index + 1\n }\n\n const reuseCounter = h.footnoteCounts[id]\n\n return h(node, 'sup', [\n h(\n node.position,\n 'a',\n {\n href: '#' + h.clobberPrefix + 'fn-' + safeId,\n id:\n h.clobberPrefix +\n 'fnref-' +\n safeId +\n (reuseCounter > 1 ? '-' + reuseCounter : ''),\n dataFootnoteRef: true,\n ariaDescribedBy: 'footnote-label'\n },\n [u('text', String(counter))]\n )\n ])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @type {Handler}\n * @param {ImageReference|LinkReference} node\n * @returns {Content|Array}\n */\nexport function revert(h, node) {\n const subtype = node.referenceType\n let suffix = ']'\n\n if (subtype === 'collapsed') {\n suffix += '[]'\n } else if (subtype === 'full') {\n suffix += '[' + (node.label || node.identifier) + ']'\n }\n\n if (node.type === 'imageReference') {\n return u('text', '![' + node.alt + suffix)\n }\n\n const contents = all(h, node)\n const head = contents[0]\n\n if (head && head.type === 'text') {\n head.value = '[' + head.value\n } else {\n contents.unshift(u('text', '['))\n }\n\n const tail = contents[contents.length - 1]\n\n if (tail && tail.type === 'text') {\n tail.value += suffix\n } else {\n contents.push(u('text', suffix))\n }\n\n return contents\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {ListItem} node\n * @param {List} parent\n */\nexport function listItem(h, node, parent) {\n const result = all(h, node)\n const loose = parent ? listLoose(parent) : listItemLoose(node)\n /** @type {Properties} */\n const props = {}\n /** @type {Array} */\n const wrapped = []\n\n if (typeof node.checked === 'boolean') {\n /** @type {Element} */\n let paragraph\n\n if (\n result[0] &&\n result[0].type === 'element' &&\n result[0].tagName === 'p'\n ) {\n paragraph = result[0]\n } else {\n paragraph = h(null, 'p', [])\n result.unshift(paragraph)\n }\n\n if (paragraph.children.length > 0) {\n paragraph.children.unshift(u('text', ' '))\n }\n\n paragraph.children.unshift(\n h(null, 'input', {\n type: 'checkbox',\n checked: node.checked,\n disabled: true\n })\n )\n\n // According to github-markdown-css, this class hides bullet.\n // See: .\n props.className = ['task-list-item']\n }\n\n let index = -1\n\n while (++index < result.length) {\n const child = result[index]\n\n // Add eols before nodes, except if this is a loose, first paragraph.\n if (\n loose ||\n index !== 0 ||\n child.type !== 'element' ||\n child.tagName !== 'p'\n ) {\n wrapped.push(u('text', '\\n'))\n }\n\n if (child.type === 'element' && child.tagName === 'p' && !loose) {\n wrapped.push(...child.children)\n } else {\n wrapped.push(child)\n }\n }\n\n const tail = result[result.length - 1]\n\n // Add a final eol.\n if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {\n wrapped.push(u('text', '\\n'))\n }\n\n return h(node, 'li', props, wrapped)\n}\n\n/**\n * @param {List} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n let loose = node.spread\n const children = node.children\n let index = -1\n\n while (!loose && ++index < children.length) {\n loose = listItemLoose(children[index])\n }\n\n return Boolean(loose)\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n const spread = node.spread\n\n return spread === undefined || spread === null\n ? node.children.length > 1\n : spread\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n * Value to trim.\n * @returns {string}\n * Trimmed value.\n */\nexport function trimLines(value) {\n const source = String(value)\n const search = /\\r?\\n|\\r/g\n let match = search.exec(source)\n let last = 0\n /** @type {Array} */\n const lines = []\n\n while (match) {\n lines.push(\n trimLine(source.slice(last, match.index), last > 0, true),\n match[0]\n )\n\n last = match.index + match[0].length\n match = search.exec(source)\n }\n\n lines.push(trimLine(source.slice(last), last > 0, false))\n\n return lines.join('')\n}\n\n/**\n * @param {string} value\n * Line to trim.\n * @param {boolean} start\n * Whether to trim the start of the line.\n * @param {boolean} end\n * Whether to trim the end of the line.\n * @returns {string}\n * Trimmed line.\n */\nfunction trimLine(value, start, end) {\n let startIndex = 0\n let endIndex = value.length\n\n if (start) {\n let code = value.codePointAt(startIndex)\n\n while (code === tab || code === space) {\n startIndex++\n code = value.codePointAt(startIndex)\n }\n }\n\n if (end) {\n let code = value.codePointAt(endIndex - 1)\n\n while (code === tab || code === space) {\n endIndex--\n code = value.codePointAt(endIndex - 1)\n }\n }\n\n return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {footnote} from './footnote.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\nexport const handlers = {\n blockquote,\n break: hardBreak,\n code,\n delete: strikethrough,\n emphasis,\n footnoteReference,\n footnote,\n heading,\n html,\n imageReference,\n image,\n inlineCode,\n linkReference,\n link,\n listItem,\n list,\n paragraph,\n root,\n strong,\n table,\n text,\n thematicBreak,\n toml: ignore,\n yaml: ignore,\n definition: ignore,\n footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n return null\n}\n","/**\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Blockquote} node\n */\nexport function blockquote(h, node) {\n return h(node, 'blockquote', wrap(all(h, node), true))\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Break} node\n * @returns {Array}\n */\nexport function hardBreak(h, node) {\n return [h(node, 'br'), u('text', '\\n')]\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Code} node\n */\nexport function code(h, node) {\n const value = node.value ? node.value + '\\n' : ''\n // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n // on for years in remark now.\n const lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/)\n /** @type {Properties} */\n const props = {}\n\n if (lang) {\n props.className = ['language-' + lang]\n }\n\n const code = h(node, 'code', props, [u('text', value)])\n\n if (node.meta) {\n code.data = {meta: node.meta}\n }\n\n return h(node.position, 'pre', [code])\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Delete} node\n */\nexport function strikethrough(h, node) {\n return h(node, 'del', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Emphasis} node\n */\nexport function emphasis(h, node) {\n return h(node, 'em', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../index.js').Handler} Handler\n *\n * @todo\n * `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)\n * that does not exist in GFM.\n * We still have support for it, so that things remain working with\n * `micromark-extension-footnote` and `mdast-util-footnote`, but in the future\n * we might be able to remove it?\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n/**\n * @type {Handler}\n * @param {Footnote} node\n */\nexport function footnote(h, node) {\n const footnoteById = h.footnoteById\n let no = 1\n\n while (no in footnoteById) no++\n\n const identifier = String(no)\n\n footnoteById[identifier] = {\n type: 'footnoteDefinition',\n identifier,\n children: [{type: 'paragraph', children: node.children}],\n position: node.position\n }\n\n return footnoteReference(h, {\n type: 'footnoteReference',\n identifier,\n position: node.position\n })\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Heading} node\n */\nexport function heading(h, node) {\n return h(node, 'h' + node.depth, all(h, node))\n}\n","/**\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Return either a `raw` node in dangerous mode, otherwise nothing.\n *\n * @type {Handler}\n * @param {HTML} node\n */\nexport function html(h, node) {\n return h.dangerous ? h.augment(node, u('raw', node.value)) : null\n}\n","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {revert} from '../revert.js'\n\n/**\n * @type {Handler}\n * @param {ImageReference} node\n */\nexport function imageReference(h, node) {\n const def = h.definition(node.identifier)\n\n if (!def) {\n return revert(h, node)\n }\n\n /** @type {Properties} */\n const props = {src: normalize(def.url || ''), alt: node.alt}\n\n if (def.title !== null && def.title !== undefined) {\n props.title = def.title\n }\n\n return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\n\n/**\n * @type {Handler}\n * @param {Image} node\n */\nexport function image(h, node) {\n /** @type {Properties} */\n const props = {src: normalize(node.url), alt: node.alt}\n\n if (node.title !== null && node.title !== undefined) {\n props.title = node.title\n }\n\n return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {InlineCode} node\n */\nexport function inlineCode(h, node) {\n return h(node, 'code', [u('text', node.value.replace(/\\r?\\n|\\r/g, ' '))])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {revert} from '../revert.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {LinkReference} node\n */\nexport function linkReference(h, node) {\n const def = h.definition(node.identifier)\n\n if (!def) {\n return revert(h, node)\n }\n\n /** @type {Properties} */\n const props = {href: normalize(def.url || '')}\n\n if (def.title !== null && def.title !== undefined) {\n props.title = def.title\n }\n\n return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Link} node\n */\nexport function link(h, node) {\n /** @type {Properties} */\n const props = {href: normalize(node.url)}\n\n if (node.title !== null && node.title !== undefined) {\n props.title = node.title\n }\n\n return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {List} node\n * @returns {Element}\n */\nexport function list(h, node) {\n /** @type {Properties} */\n const props = {}\n const name = node.ordered ? 'ol' : 'ul'\n const items = all(h, node)\n let index = -1\n\n if (typeof node.start === 'number' && node.start !== 1) {\n props.start = node.start\n }\n\n // Like GitHub, add a class for custom styling.\n while (++index < items.length) {\n const item = items[index]\n\n if (\n item.type === 'element' &&\n item.tagName === 'li' &&\n item.properties &&\n Array.isArray(item.properties.className) &&\n item.properties.className.includes('task-list-item')\n ) {\n props.className = ['contains-task-list']\n break\n }\n }\n\n return h(node, name, props, wrap(items, true))\n}\n","/**\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Paragraph} node\n */\nexport function paragraph(h, node) {\n return h(node, 'p', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\nimport {wrap} from '../wrap.js'\n\n/**\n * @type {Handler}\n * @param {Root} node\n */\nexport function root(h, node) {\n // @ts-expect-error `root`s are also fine.\n return h.augment(node, u('root', wrap(all(h, node))))\n}\n","/**\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Strong} node\n */\nexport function strong(h, node) {\n return h(node, 'strong', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Table} node\n */\nexport function table(h, node) {\n const rows = node.children\n let index = -1\n const align = node.align || []\n /** @type {Array} */\n const result = []\n\n while (++index < rows.length) {\n const row = rows[index].children\n const name = index === 0 ? 'th' : 'td'\n /** @type {Array} */\n const out = []\n let cellIndex = -1\n const length = node.align ? align.length : row.length\n\n while (++cellIndex < length) {\n const cell = row[cellIndex]\n out.push(\n h(cell, name, {align: align[cellIndex]}, cell ? all(h, cell) : [])\n )\n }\n\n result[index] = h(rows[index], 'tr', wrap(out, true))\n }\n\n return h(\n node,\n 'table',\n wrap(\n [h(result[0].position, 'thead', wrap([result[0]], true))].concat(\n result[1]\n ? h(\n {\n start: pointStart(result[1]),\n end: pointEnd(result[result.length - 1])\n },\n 'tbody',\n wrap(result.slice(1), true)\n )\n : []\n ),\n true\n )\n )\n}\n","/**\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {trimLines} from 'trim-lines'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Text} node\n */\nexport function text(h, node) {\n return h.augment(node, u('text', trimLines(String(node.value))))\n}\n","/**\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n */\n\n/**\n * @type {Handler}\n * @param {ThematicBreak} [node]\n * @returns {Element}\n */\nexport function thematicBreak(h, node) {\n return h(node, 'hr')\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').ElementContent} Content\n * @typedef {import('unist-util-position').PositionLike} PositionLike\n *\n * @typedef EmbeddedHastFields\n * @property {string} [hName] Defines the tag name of an element\n * @property {Properties} [hProperties] Defines the properties of an element\n * @property {Array} [hChildren] Defines the (hast) children of an element\n *\n * @typedef {Record & EmbeddedHastFields} Data unist data with embedded hast fields\n *\n * @typedef {MdastNode & {data?: Data}} NodeWithData unist node with embedded hast data\n *\n * @callback Handler\n * @param {H} h Handle context\n * @param {any} node mdast node to handle\n * @param {Parent|null} parent Parent of `node`\n * @returns {Content|Array|null|undefined} hast node\n *\n * @callback HFunctionProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Properties} props Properties\n * @param {Array?} [children] hast content\n * @returns {Element}\n *\n * @callback HFunctionNoProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Array?} [children] hast content\n * @returns {Element}\n *\n * @typedef HFields\n * @property {boolean} dangerous Whether HTML is allowed\n * @property {string} clobberPrefix Prefix to use to prevent DOM clobbering\n * @property {string} footnoteLabel Label to use to introduce the footnote section\n * @property {string} footnoteLabelTagName HTML used for the footnote label\n * @property {Properties} footnoteLabelProperties properties on the HTML tag used for the footnote label\n * @property {string} footnoteBackLabel Label to use to go back to a footnote call from the footnote section\n * @property {(identifier: string) => Definition|null} definition Definition cache\n * @property {Record} footnoteById Footnote cache\n * @property {Array} footnoteOrder Order in which footnotes occur\n * @property {Record} footnoteCounts Counts the same footnote was used\n * @property {Handlers} handlers Applied handlers\n * @property {Handler} unknownHandler Handler for any none not in `passThrough` or otherwise handled\n * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment Like `h` but lower-level and usable on non-elements.\n * @property {Array} passThrough List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n * @property {boolean} [allowDangerousHtml=false]\n * Whether to allow `html` nodes and inject them as `raw` HTML\n * @property {string} [clobberPrefix='user-content-']\n * Prefix to use before the `id` attribute to prevent it from *clobbering*.\n * attributes.\n * DOM clobbering is this:\n *\n * ```html\n *

\n * \n * ```\n *\n * Elements by their ID are made available in browsers on the `window` object.\n * Using a prefix prevents this from being a problem.\n * @property {string} [footnoteLabel='Footnotes']\n * Label to use for the footnotes section.\n * Affects screen reader users.\n * Change it if you’re authoring in a different language.\n * @property {string} [footnoteLabelTagName='h2']\n * HTML tag to use for the footnote label.\n * Can be changed to match your document structure and play well with your choice of css.\n * @property {Properties} [footnoteLabelProperties={id: 'footnote-label', className: ['sr-only']}]\n * Properties to use on the footnote label.\n * A 'sr-only' class is added by default to hide this from sighted users.\n * Change it to make the label visible, or add classes for other purposes.\n * @property {string} [footnoteBackLabel='Back to content']\n * Label to use from backreferences back to their footnote call.\n * Affects screen reader users.\n * Change it if you’re authoring in a different language.\n * @property {Handlers} [handlers]\n * Object mapping mdast nodes to functions handling them\n * @property {Array} [passThrough]\n * List of custom mdast node types to pass through (keep) in hast\n * @property {Handler} [unknownHandler]\n * Handler for all unknown nodes.\n *\n * @typedef {Record} Handlers\n * Map of node types to handlers\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} H\n * Handle context\n */\n\nimport {u} from 'unist-builder'\nimport {visit} from 'unist-util-visit'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {one} from './traverse.js'\nimport {footer} from './footer.js'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Factory to transform.\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {H} `h` function\n */\nfunction factory(tree, options) {\n const settings = options || {}\n const dangerous = settings.allowDangerousHtml || false\n /** @type {Record} */\n const footnoteById = {}\n\n h.dangerous = dangerous\n h.clobberPrefix =\n settings.clobberPrefix === undefined || settings.clobberPrefix === null\n ? 'user-content-'\n : settings.clobberPrefix\n h.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n h.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n h.footnoteLabelProperties = settings.footnoteLabelProperties || {\n id: 'footnote-label',\n className: ['sr-only']\n }\n h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n h.definition = definitions(tree)\n h.footnoteById = footnoteById\n /** @type {Array} */\n h.footnoteOrder = []\n /** @type {Record} */\n h.footnoteCounts = {}\n h.augment = augment\n h.handlers = {...handlers, ...settings.handlers}\n h.unknownHandler = settings.unknownHandler\n h.passThrough = settings.passThrough\n\n visit(tree, 'footnoteDefinition', (definition) => {\n const id = String(definition.identifier).toUpperCase()\n\n // Mimick CM behavior of link definitions.\n // See: .\n if (!own.call(footnoteById, id)) {\n footnoteById[id] = definition\n }\n })\n\n // @ts-expect-error Hush, it’s fine!\n return h\n\n /**\n * Finalise the created `right`, a hast node, from `left`, an mdast node.\n * @param {(NodeWithData|PositionLike)?} left\n * @param {Content} right\n * @returns {Content}\n */\n function augment(left, right) {\n // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n if (left && 'data' in left && left.data) {\n /** @type {Data} */\n const data = left.data\n\n if (data.hName) {\n if (right.type !== 'element') {\n right = {\n type: 'element',\n tagName: '',\n properties: {},\n children: []\n }\n }\n\n right.tagName = data.hName\n }\n\n if (right.type === 'element' && data.hProperties) {\n right.properties = {...right.properties, ...data.hProperties}\n }\n\n if ('children' in right && right.children && data.hChildren) {\n right.children = data.hChildren\n }\n }\n\n if (left) {\n const ctx = 'type' in left ? left : {position: left}\n\n if (!generated(ctx)) {\n // @ts-expect-error: fine.\n right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n }\n }\n\n return right\n }\n\n /**\n * Create an element for `node`.\n *\n * @type {HFunctionProps}\n */\n function h(node, tagName, props, children) {\n if (Array.isArray(props)) {\n children = props\n props = {}\n }\n\n // @ts-expect-error augmenting an element yields an element.\n return augment(node, {\n type: 'element',\n tagName,\n properties: props || {},\n children: children || []\n })\n }\n}\n\n/**\n * Transform `tree` (an mdast node) to a hast node.\n *\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {HastNode|null|undefined} hast node\n */\nexport function toHast(tree, options) {\n const h = factory(tree, options)\n const node = one(h, tree, null)\n const foot = footer(h)\n\n if (foot) {\n // @ts-expect-error If there’s a footer, there were definitions, meaning block\n // content.\n // So assume `node` is a parent node.\n node.children.push(u('text', '\\n'), foot)\n }\n\n return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n\nexport {handlers as defaultHandlers} from './handlers/index.js'\n","/**\n * @typedef {Object} PointLike\n * @property {number} [line]\n * @property {number} [column]\n * @property {number} [offset]\n *\n * @typedef {Object} PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n *\n * @typedef {Object} NodeLike\n * @property {PositionLike} [position]\n */\n\n/**\n * Check if `node` is *generated*.\n *\n * @param {NodeLike} [node]\n * @returns {boolean}\n */\nexport function generated(node) {\n return (\n !node ||\n !node.position ||\n !node.position.start ||\n !node.position.start.line ||\n !node.position.start.column ||\n !node.position.end ||\n !node.position.end.line ||\n !node.position.end.column\n )\n}\n","/**\n * @typedef {import('mdast').BlockContent} BlockContent\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('./index.js').H} H\n */\n\nimport {sanitizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\nimport {wrap} from './wrap.js'\n\n/**\n * @param {H} h\n * @returns {Element|null}\n */\nexport function footer(h) {\n let index = -1\n /** @type {Array} */\n const listItems = []\n\n while (++index < h.footnoteOrder.length) {\n const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()]\n\n if (!def) {\n continue\n }\n\n const content = all(h, def)\n const id = String(def.identifier)\n const safeId = sanitizeUri(id.toLowerCase())\n let referenceIndex = 0\n /** @type {Array} */\n const backReferences = []\n\n while (++referenceIndex <= h.footnoteCounts[id]) {\n /** @type {Element} */\n const backReference = {\n type: 'element',\n tagName: 'a',\n properties: {\n href:\n '#' +\n h.clobberPrefix +\n 'fnref-' +\n safeId +\n (referenceIndex > 1 ? '-' + referenceIndex : ''),\n dataFootnoteBackref: true,\n className: ['data-footnote-backref'],\n ariaLabel: h.footnoteBackLabel\n },\n children: [{type: 'text', value: '↩'}]\n }\n\n if (referenceIndex > 1) {\n backReference.children.push({\n type: 'element',\n tagName: 'sup',\n children: [{type: 'text', value: String(referenceIndex)}]\n })\n }\n\n if (backReferences.length > 0) {\n backReferences.push({type: 'text', value: ' '})\n }\n\n backReferences.push(backReference)\n }\n\n const tail = content[content.length - 1]\n\n if (tail && tail.type === 'element' && tail.tagName === 'p') {\n const tailTail = tail.children[tail.children.length - 1]\n if (tailTail && tailTail.type === 'text') {\n tailTail.value += ' '\n } else {\n tail.children.push({type: 'text', value: ' '})\n }\n\n tail.children.push(...backReferences)\n } else {\n content.push(...backReferences)\n }\n\n /** @type {Element} */\n const listItem = {\n type: 'element',\n tagName: 'li',\n properties: {id: h.clobberPrefix + 'fn-' + safeId},\n children: wrap(content, true)\n }\n\n if (def.position) {\n listItem.position = def.position\n }\n\n listItems.push(listItem)\n }\n\n if (listItems.length === 0) {\n return null\n }\n\n return {\n type: 'element',\n tagName: 'section',\n properties: {dataFootnotes: true, className: ['footnotes']},\n children: [\n {\n type: 'element',\n tagName: h.footnoteLabelTagName,\n properties: JSON.parse(JSON.stringify(h.footnoteLabelProperties)),\n children: [u('text', h.footnoteLabel)]\n },\n {type: 'text', value: '\\n'},\n {\n type: 'element',\n tagName: 'ol',\n properties: {},\n children: wrap(listItems, true)\n },\n {type: 'text', value: '\\n'}\n ]\n }\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * * If a destination processor is given, that processor runs with a new HTML\n * (hast) tree (bridge-mode).\n * As the given processor runs with a hast tree, and rehype plugins support\n * hast, that means rehype plugins can be used with the given processor.\n * The hast tree is discarded in the end.\n * It’s highly unlikely that you want to do this.\n * * The common case is to not pass a destination processor, in which case the\n * current processor continues running with a new HTML (hast) tree\n * (mutate-mode).\n * As the current processor continues with a hast tree, and rehype plugins\n * support hast, that means rehype plugins can be used after\n * `remark-rehype`.\n * It’s likely that this is what you want to do.\n *\n * @param destination\n * Optional unified processor.\n * @param options\n * Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n (\n function (destination, options) {\n return destination && 'run' in destination\n ? bridge(destination, options)\n : mutate(destination || options)\n }\n )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n return (node, file, next) => {\n destination.run(toHast(node, options), file, (error) => {\n next(error)\n })\n }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n return (node) => toHast(node, options)\n}\n","import {visit} from 'unist-util-visit'\n\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array} [allowedElements]\n * @property {Array} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\nexport default function rehypeFilter(options) {\n if (options.allowedElements && options.disallowedElements) {\n throw new TypeError(\n 'Only one of `allowedElements` and `disallowedElements` should be defined'\n )\n }\n\n if (\n options.allowedElements ||\n options.disallowedElements ||\n options.allowElement\n ) {\n return (tree) => {\n visit(tree, 'element', (node, index, parent_) => {\n const parent = /** @type {Element|Root} */ (parent_)\n /** @type {boolean|undefined} */\n let remove\n\n if (options.allowedElements) {\n remove = !options.allowedElements.includes(node.tagName)\n } else if (options.disallowedElements) {\n remove = options.disallowedElements.includes(node.tagName)\n }\n\n if (!remove && options.allowElement && typeof index === 'number') {\n remove = !options.allowElement(node, index, parent)\n }\n\n if (remove && typeof index === 'number') {\n if (options.unwrapDisallowed && node.children) {\n parent.children.splice(index, 1, ...node.children)\n } else {\n parent.children.splice(index, 1)\n }\n\n return index\n }\n\n return undefined\n })\n }\n }\n}\n","const protocols = ['http', 'https', 'mailto', 'tel']\n\n/**\n * @param {string} uri\n * @returns {string}\n */\nexport function uriTransformer(uri) {\n const url = (uri || '').trim()\n const first = url.charAt(0)\n\n if (first === '#' || first === '/') {\n return url\n }\n\n const colon = url.indexOf(':')\n if (colon === -1) {\n return url\n }\n\n let index = -1\n\n while (++index < protocols.length) {\n const protocol = protocols[index]\n\n if (\n colon === protocol.length &&\n url.slice(0, protocol.length).toLowerCase() === protocol\n ) {\n return url\n }\n }\n\n index = url.indexOf('?')\n if (index !== -1 && colon > index) {\n return url\n }\n\n index = url.indexOf('#')\n if (index !== -1 && colon > index) {\n return url\n }\n\n // eslint-disable-next-line no-script-url\n return 'javascript:void(0)'\n}\n","/**\n * @param {unknown} thing\n * @returns {boolean}\n */\nexport function whitespace(thing) {\n /** @type {string} */\n var value =\n // @ts-ignore looks like a node.\n thing && typeof thing === 'object' && thing.type === 'text'\n ? // @ts-ignore looks like a text.\n thing.value || ''\n : thing\n\n // HTML whitespace expression.\n // See .\n return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === ''\n}\n","export const hastToReact = {\n classId: 'classID',\n dataType: 'datatype',\n itemId: 'itemID',\n strokeDashArray: 'strokeDasharray',\n strokeDashOffset: 'strokeDashoffset',\n strokeLineCap: 'strokeLinecap',\n strokeLineJoin: 'strokeLinejoin',\n strokeMiterLimit: 'strokeMiterlimit',\n typeOf: 'typeof',\n xLinkActuate: 'xlinkActuate',\n xLinkArcRole: 'xlinkArcrole',\n xLinkHref: 'xlinkHref',\n xLinkRole: 'xlinkRole',\n xLinkShow: 'xlinkShow',\n xLinkTitle: 'xlinkTitle',\n xLinkType: 'xlinkType',\n xmlnsXLink: 'xmlnsXlink'\n}\n","/**\n * @template T\n * @typedef {import('react').ComponentType} ComponentType\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef} ComponentPropsWithoutRef\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType} CodeComponent\n * @typedef {ComponentType} HeadingComponent\n * @typedef {ComponentType} LiComponent\n * @typedef {ComponentType} OrderedListComponent\n * @typedef {ComponentType} TableCellComponent\n * @typedef {ComponentType} TableRowComponent\n * @typedef {ComponentType} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nimport React from 'react'\nimport ReactIs from 'react-is'\nimport {whitespace} from 'hast-util-whitespace'\nimport {svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\n\nconst own = {}.hasOwnProperty\n\n// The table-related elements that must not contain whitespace text according\n// to React.\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr'])\n\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\nexport function childrenToReact(context, node) {\n /** @type {Array} */\n const children = []\n let childIndex = -1\n /** @type {Comment|Doctype|Element|Raw|Text} */\n let child\n\n while (++childIndex < node.children.length) {\n child = node.children[childIndex]\n\n if (child.type === 'element') {\n children.push(toReact(context, child, childIndex, node))\n } else if (child.type === 'text') {\n // Currently, a warning is triggered by react for *any* white space in\n // tables.\n // So we drop it.\n // See: .\n // See: .\n // See: .\n // See: .\n if (\n node.type !== 'element' ||\n !tableElements.has(node.tagName) ||\n !whitespace(child)\n ) {\n children.push(child.value)\n }\n } else if (child.type === 'raw' && !context.options.skipHtml) {\n // Default behavior is to show (encoded) HTML.\n children.push(child.value)\n }\n }\n\n return children\n}\n\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\nfunction toReact(context, node, index, parent) {\n const options = context.options\n const parentSchema = context.schema\n /** @type {ReactMarkdownNames} */\n // @ts-expect-error assume a known HTML/SVG element.\n const name = node.tagName\n /** @type {Record} */\n const properties = {}\n let schema = parentSchema\n /** @type {string} */\n let property\n\n if (parentSchema.space === 'html' && name === 'svg') {\n schema = svg\n context.schema = schema\n }\n\n if (node.properties) {\n for (property in node.properties) {\n if (own.call(node.properties, property)) {\n addProperty(properties, property, node.properties[property], context)\n }\n }\n }\n\n if (name === 'ol' || name === 'ul') {\n context.listDepth++\n }\n\n const children = childrenToReact(context, node)\n\n if (name === 'ol' || name === 'ul') {\n context.listDepth--\n }\n\n // Restore parent schema.\n context.schema = parentSchema\n\n // Nodes created by plugins do not have positional info, in which case we use\n // an object that matches the position interface.\n const position = node.position || {\n start: {line: null, column: null, offset: null},\n end: {line: null, column: null, offset: null}\n }\n const component =\n options.components && own.call(options.components, name)\n ? options.components[name]\n : name\n const basic = typeof component === 'string' || component === React.Fragment\n\n if (!ReactIs.isValidElementType(component)) {\n throw new TypeError(\n `Component for name \\`${name}\\` not defined or is not renderable`\n )\n }\n\n properties.key = [\n name,\n position.start.line,\n position.start.column,\n index\n ].join('-')\n\n if (name === 'a' && options.linkTarget) {\n properties.target =\n typeof options.linkTarget === 'function'\n ? options.linkTarget(\n String(properties.href || ''),\n node.children,\n typeof properties.title === 'string' ? properties.title : null\n )\n : options.linkTarget\n }\n\n if (name === 'a' && options.transformLinkUri) {\n properties.href = options.transformLinkUri(\n String(properties.href || ''),\n node.children,\n typeof properties.title === 'string' ? properties.title : null\n )\n }\n\n if (\n !basic &&\n name === 'code' &&\n parent.type === 'element' &&\n parent.tagName !== 'pre'\n ) {\n properties.inline = true\n }\n\n if (\n !basic &&\n (name === 'h1' ||\n name === 'h2' ||\n name === 'h3' ||\n name === 'h4' ||\n name === 'h5' ||\n name === 'h6')\n ) {\n properties.level = Number.parseInt(name.charAt(1), 10)\n }\n\n if (name === 'img' && options.transformImageUri) {\n properties.src = options.transformImageUri(\n String(properties.src || ''),\n String(properties.alt || ''),\n typeof properties.title === 'string' ? properties.title : null\n )\n }\n\n if (!basic && name === 'li' && parent.type === 'element') {\n const input = getInputElement(node)\n properties.checked =\n input && input.properties ? Boolean(input.properties.checked) : null\n properties.index = getElementsBeforeCount(parent, node)\n properties.ordered = parent.tagName === 'ol'\n }\n\n if (!basic && (name === 'ol' || name === 'ul')) {\n properties.ordered = name === 'ol'\n properties.depth = context.listDepth\n }\n\n if (name === 'td' || name === 'th') {\n if (properties.align) {\n if (!properties.style) properties.style = {}\n // @ts-expect-error assume `style` is an object\n properties.style.textAlign = properties.align\n delete properties.align\n }\n\n if (!basic) {\n properties.isHeader = name === 'th'\n }\n }\n\n if (!basic && name === 'tr' && parent.type === 'element') {\n properties.isHeader = Boolean(parent.tagName === 'thead')\n }\n\n // If `sourcePos` is given, pass source information (line/column info from markdown source).\n if (options.sourcePos) {\n properties['data-sourcepos'] = flattenPosition(position)\n }\n\n if (!basic && options.rawSourcePos) {\n properties.sourcePosition = node.position\n }\n\n // If `includeElementIndex` is given, pass node index info to components.\n if (!basic && options.includeElementIndex) {\n properties.index = getElementsBeforeCount(parent, node)\n properties.siblingCount = getElementsBeforeCount(parent)\n }\n\n if (!basic) {\n properties.node = node\n }\n\n // Ensure no React warnings are emitted for void elements w/ children.\n return children.length > 0\n ? React.createElement(component, properties, children)\n : React.createElement(component, properties)\n}\n\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\nfunction getInputElement(node) {\n let index = -1\n\n while (++index < node.children.length) {\n const child = node.children[index]\n\n if (child.type === 'element' && child.tagName === 'input') {\n return child\n }\n }\n\n return null\n}\n\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\nfunction getElementsBeforeCount(parent, node) {\n let index = -1\n let count = 0\n\n while (++index < parent.children.length) {\n if (parent.children[index] === node) break\n if (parent.children[index].type === 'element') count++\n }\n\n return count\n}\n\n/**\n * @param {Record} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\nfunction addProperty(props, prop, value, ctx) {\n const info = find(ctx.schema, prop)\n let result = value\n\n // Ignore nullish and `NaN` values.\n // eslint-disable-next-line no-self-compare\n if (result === null || result === undefined || result !== result) {\n return\n }\n\n // Accept `array`.\n // Most props are space-separated.\n if (Array.isArray(result)) {\n result = info.commaSeparated ? commas(result) : spaces(result)\n }\n\n if (info.property === 'style' && typeof result === 'string') {\n result = parseStyle(result)\n }\n\n if (info.space && info.property) {\n props[\n own.call(hastToReact, info.property)\n ? hastToReact[info.property]\n : info.property\n ] = result\n } else if (info.attribute) {\n props[info.attribute] = result\n }\n}\n\n/**\n * @param {string} value\n * @returns {Record}\n */\nfunction parseStyle(value) {\n /** @type {Record} */\n const result = {}\n\n try {\n style(value, iterator)\n } catch {\n // Silent.\n }\n\n return result\n\n /**\n * @param {string} name\n * @param {string} v\n */\n function iterator(name, v) {\n const k = name.slice(0, 4) === '-ms-' ? `ms-${name.slice(4)}` : name\n result[k.replace(/-([a-z])/g, styleReplacer)] = v\n }\n}\n\n/**\n * @param {unknown} _\n * @param {string} $1\n */\nfunction styleReplacer(_, $1) {\n return $1.toUpperCase()\n}\n\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\nfunction flattenPosition(pos) {\n return [\n pos.start.line,\n ':',\n pos.start.column,\n '-',\n pos.end.line,\n ':',\n pos.end.column\n ]\n .map((d) => String(d))\n .join('')\n}\n","/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\nimport React from 'react'\nimport {VFile} from 'vfile'\nimport {unified} from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport PropTypes from 'prop-types'\nimport {html} from 'property-information'\nimport rehypeFilter from './rehype-filter.js'\nimport {uriTransformer} from './uri-transformer.js'\nimport {childrenToReact} from './ast-to-react.js'\n\nconst own = {}.hasOwnProperty\nconst changelog =\n 'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {Record} */\nconst deprecated = {\n plugins: {to: 'plugins', id: 'change-plugins-to-remarkplugins'},\n renderers: {to: 'components', id: 'change-renderers-to-components'},\n astPlugins: {id: 'remove-buggy-html-in-markdown-parser'},\n allowDangerousHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n escapeHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n source: {to: 'children', id: 'change-source-to-children'},\n allowNode: {\n to: 'allowElement',\n id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n },\n allowedTypes: {\n to: 'allowedElements',\n id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n },\n disallowedTypes: {\n to: 'disallowedElements',\n id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n },\n includeNodeIndex: {\n to: 'includeElementIndex',\n id: 'change-includenodeindex-to-includeelementindex'\n }\n}\n\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\nexport function ReactMarkdown(options) {\n for (const key in deprecated) {\n if (own.call(deprecated, key) && own.call(options, key)) {\n const deprecation = deprecated[key]\n console.warn(\n `[react-markdown] Warning: please ${\n deprecation.to ? `use \\`${deprecation.to}\\` instead of` : 'remove'\n } \\`${key}\\` (see <${changelog}#${deprecation.id}> for more info)`\n )\n delete deprecated[key]\n }\n }\n\n const processor = unified()\n .use(remarkParse)\n .use(options.remarkPlugins || [])\n .use(remarkRehype, {\n ...options.remarkRehypeOptions,\n allowDangerousHtml: true\n })\n .use(options.rehypePlugins || [])\n .use(rehypeFilter, options)\n\n const file = new VFile()\n\n if (typeof options.children === 'string') {\n file.value = options.children\n } else if (options.children !== undefined && options.children !== null) {\n console.warn(\n `[react-markdown] Warning: please pass a string as \\`children\\` (not: \\`${options.children}\\`)`\n )\n }\n\n const hastNode = processor.runSync(processor.parse(file), file)\n\n if (hastNode.type !== 'root') {\n throw new TypeError('Expected a `root` node')\n }\n\n /** @type {ReactElement} */\n let result = React.createElement(\n React.Fragment,\n {},\n childrenToReact({options, schema: html, listDepth: 0}, hastNode)\n )\n\n if (options.className) {\n result = React.createElement('div', {className: options.className}, result)\n }\n\n return result\n}\n\nReactMarkdown.defaultProps = {transformLinkUri: uriTransformer}\n\nReactMarkdown.propTypes = {\n // Core options:\n children: PropTypes.string,\n // Layout options:\n className: PropTypes.string,\n // Filter options:\n allowElement: PropTypes.func,\n allowedElements: PropTypes.arrayOf(PropTypes.string),\n disallowedElements: PropTypes.arrayOf(PropTypes.string),\n unwrapDisallowed: PropTypes.bool,\n // Plugin options:\n remarkPlugins: PropTypes.arrayOf(\n PropTypes.oneOfType([\n PropTypes.object,\n PropTypes.func,\n PropTypes.arrayOf(\n PropTypes.oneOfType([\n PropTypes.bool,\n PropTypes.string,\n PropTypes.object,\n PropTypes.func,\n PropTypes.arrayOf(\n // prettier-ignore\n // type-coverage:ignore-next-line\n PropTypes.any\n )\n ])\n )\n ])\n ),\n rehypePlugins: PropTypes.arrayOf(\n PropTypes.oneOfType([\n PropTypes.object,\n PropTypes.func,\n PropTypes.arrayOf(\n PropTypes.oneOfType([\n PropTypes.bool,\n PropTypes.string,\n PropTypes.object,\n PropTypes.func,\n PropTypes.arrayOf(\n // prettier-ignore\n // type-coverage:ignore-next-line\n PropTypes.any\n )\n ])\n )\n ])\n ),\n // Transform options:\n sourcePos: PropTypes.bool,\n rawSourcePos: PropTypes.bool,\n skipHtml: PropTypes.bool,\n includeElementIndex: PropTypes.bool,\n transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n transformImageUri: PropTypes.func,\n components: PropTypes.object\n}\n","/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n * Value to search in.\n * @param {string} character\n * Character (or substring) to look for.\n * @return {number}\n * Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n const source = String(value)\n\n if (typeof character !== 'string') {\n throw new TypeError('Expected character')\n }\n\n let count = 0\n let index = source.indexOf(character)\n\n while (index !== -1) {\n count++\n index = source.indexOf(character, index + character.length)\n }\n\n return count\n}\n","/**\n * @typedef Options\n * Configuration (optional).\n * @property {Test} [ignore]\n * `unist-util-is` test used to assert parents\n *\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Text} Text\n * @typedef {Content|Root} Node\n * @typedef {Exclude, Root>} Parent\n *\n * @typedef {import('unist-util-visit-parents').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n *\n * @typedef RegExpMatchObject\n * @property {number} index\n * @property {string} input\n * @property {[Root, ...Array, Text]} stack\n *\n * @typedef {string|RegExp} Find\n * @typedef {string|ReplaceFunction} Replace\n *\n * @typedef {[Find, Replace]} FindAndReplaceTuple\n * @typedef {Record} FindAndReplaceSchema\n * @typedef {Array} FindAndReplaceList\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n * @typedef {Array} Pairs\n */\n\n/**\n * @callback ReplaceFunction\n * @param {...any} parameters\n * @returns {Array|PhrasingContent|string|false|undefined|null}\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param tree mdast tree\n * @param find Value to find and remove. When `string`, escaped and made into a global `RegExp`\n * @param [replace] Value to insert.\n * * When `string`, turned into a Text node.\n * * When `Function`, called with the results of calling `RegExp.exec` as\n * arguments, in which case it can return a single or a list of `Node`,\n * a `string` (which is wrapped in a `Text` node), or `false` to not replace\n * @param [options] Configuration.\n */\nexport const findAndReplace =\n /**\n * @type {(\n * ((tree: Node, find: Find, replace?: Replace, options?: Options) => Node) &\n * ((tree: Node, schema: FindAndReplaceSchema|FindAndReplaceList, options?: Options) => Node)\n * )}\n **/\n (\n /**\n * @param {Node} tree\n * @param {Find|FindAndReplaceSchema|FindAndReplaceList} find\n * @param {Replace|Options} [replace]\n * @param {Options} [options]\n */\n function (tree, find, replace, options) {\n /** @type {Options|undefined} */\n let settings\n /** @type {FindAndReplaceSchema|FindAndReplaceList} */\n let schema\n\n if (typeof find === 'string' || find instanceof RegExp) {\n // @ts-expect-error don’t expect options twice.\n schema = [[find, replace]]\n settings = options\n } else {\n schema = find\n // @ts-expect-error don’t expect replace twice.\n settings = replace\n }\n\n if (!settings) {\n settings = {}\n }\n\n const ignored = convert(settings.ignore || [])\n const pairs = toPairs(schema)\n let pairIndex = -1\n\n while (++pairIndex < pairs.length) {\n visitParents(tree, 'text', visitor)\n }\n\n return tree\n\n /** @type {import('unist-util-visit-parents/complex-types').BuildVisitor} */\n function visitor(node, parents) {\n let index = -1\n /** @type {Parent|undefined} */\n let grandparent\n\n while (++index < parents.length) {\n const parent = /** @type {Parent} */ (parents[index])\n\n if (\n ignored(\n parent,\n // @ts-expect-error mdast vs. unist parent.\n grandparent ? grandparent.children.indexOf(parent) : undefined,\n grandparent\n )\n ) {\n return\n }\n\n grandparent = parent\n }\n\n if (grandparent) {\n // @ts-expect-error: stack is fine.\n return handler(node, parents)\n }\n }\n\n /**\n * @param {Text} node\n * @param {[Root, ...Array]} parents\n * @returns {VisitorResult}\n */\n function handler(node, parents) {\n const parent = parents[parents.length - 1]\n const find = pairs[pairIndex][0]\n const replace = pairs[pairIndex][1]\n let start = 0\n // @ts-expect-error: TS is wrong, some of these children can be text.\n const index = parent.children.indexOf(node)\n let change = false\n /** @type {Array} */\n let nodes = []\n /** @type {number|undefined} */\n let position\n\n find.lastIndex = 0\n\n let match = find.exec(node.value)\n\n while (match) {\n position = match.index\n /** @type {RegExpMatchObject} */\n const matchObject = {\n index: match.index,\n input: match.input,\n stack: [...parents, node]\n }\n let value = replace(...match, matchObject)\n\n if (typeof value === 'string') {\n value = value.length > 0 ? {type: 'text', value} : undefined\n }\n\n if (value !== false) {\n if (start !== position) {\n nodes.push({\n type: 'text',\n value: node.value.slice(start, position)\n })\n }\n\n if (Array.isArray(value)) {\n nodes.push(...value)\n } else if (value) {\n nodes.push(value)\n }\n\n start = position + match[0].length\n change = true\n }\n\n if (!find.global) {\n break\n }\n\n match = find.exec(node.value)\n }\n\n if (change) {\n if (start < node.value.length) {\n nodes.push({type: 'text', value: node.value.slice(start)})\n }\n\n parent.children.splice(index, 1, ...nodes)\n } else {\n nodes = [node]\n }\n\n return index + nodes.length\n }\n }\n )\n\n/**\n * @param {FindAndReplaceSchema|FindAndReplaceList} schema\n * @returns {Pairs}\n */\nfunction toPairs(schema) {\n /** @type {Pairs} */\n const result = []\n\n if (typeof schema !== 'object') {\n throw new TypeError('Expected array or object as schema')\n }\n\n if (Array.isArray(schema)) {\n let index = -1\n\n while (++index < schema.length) {\n result.push([\n toExpression(schema[index][0]),\n toFunction(schema[index][1])\n ])\n }\n } else {\n /** @type {string} */\n let key\n\n for (key in schema) {\n if (own.call(schema, key)) {\n result.push([toExpression(key), toFunction(schema[key])])\n }\n }\n }\n\n return result\n}\n\n/**\n * @param {Find} find\n * @returns {RegExp}\n */\nfunction toExpression(find) {\n return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * @param {Replace} replace\n * @returns {ReplaceFunction}\n */\nfunction toFunction(replace) {\n return typeof replace === 'function' ? replace : () => replace\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown/lib/types.js').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject\n * @typedef {import('mdast-util-find-and-replace').PhrasingContent} PhrasingContent\n */\n\nimport {ccount} from 'ccount'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\n\nconst inConstruct = 'phrasing'\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n/** @type {FromMarkdownExtension} */\nexport const gfmAutolinkLiteralFromMarkdown = {\n transforms: [transformGfmAutolinkLiterals],\n enter: {\n literalAutolink: enterLiteralAutolink,\n literalAutolinkEmail: enterLiteralAutolinkValue,\n literalAutolinkHttp: enterLiteralAutolinkValue,\n literalAutolinkWww: enterLiteralAutolinkValue\n },\n exit: {\n literalAutolink: exitLiteralAutolink,\n literalAutolinkEmail: exitLiteralAutolinkEmail,\n literalAutolinkHttp: exitLiteralAutolinkHttp,\n literalAutolinkWww: exitLiteralAutolinkWww\n }\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmAutolinkLiteralToMarkdown = {\n unsafe: [\n {\n character: '@',\n before: '[+\\\\-.\\\\w]',\n after: '[\\\\-.\\\\w]',\n inConstruct,\n notInConstruct\n },\n {\n character: '.',\n before: '[Ww]',\n after: '[\\\\-.\\\\w]',\n inConstruct,\n notInConstruct\n },\n {character: ':', before: '[ps]', after: '\\\\/', inConstruct, notInConstruct}\n ]\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterLiteralAutolink(token) {\n this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterLiteralAutolinkValue(token) {\n this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkHttp(token) {\n this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkWww(token) {\n this.config.exit.data.call(this, token)\n const node = /** @type {Link} */ (this.stack[this.stack.length - 1])\n node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolinkEmail(token) {\n this.config.exit.autolinkEmail.call(this, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitLiteralAutolink(token) {\n this.exit(token)\n}\n\n/** @type {FromMarkdownTransform} */\nfunction transformGfmAutolinkLiterals(tree) {\n findAndReplace(\n tree,\n [\n [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/gi, findUrl],\n [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/g, findEmail]\n ],\n {ignore: ['link', 'linkReference']}\n )\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} protocol\n * @param {string} domain\n * @param {string} path\n * @param {RegExpMatchObject} match\n */\n// eslint-disable-next-line max-params\nfunction findUrl(_, protocol, domain, path, match) {\n let prefix = ''\n\n // Not an expected previous character.\n if (!previous(match)) {\n return false\n }\n\n // Treat `www` as part of the domain.\n if (/^w/i.test(protocol)) {\n domain = protocol + domain\n protocol = ''\n prefix = 'http://'\n }\n\n if (!isCorrectDomain(domain)) {\n return false\n }\n\n const parts = splitUrl(domain + path)\n\n if (!parts[0]) return false\n\n /** @type {PhrasingContent} */\n const result = {\n type: 'link',\n title: null,\n url: prefix + protocol + parts[0],\n children: [{type: 'text', value: protocol + parts[0]}]\n }\n\n if (parts[1]) {\n return [result, {type: 'text', value: parts[1]}]\n }\n\n return result\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} atext\n * @param {string} label\n * @param {RegExpMatchObject} match\n */\nfunction findEmail(_, atext, label, match) {\n if (\n // Not an expected previous character.\n !previous(match, true) ||\n // Label ends in not allowed character.\n /[_-\\d]$/.test(label)\n ) {\n return false\n }\n\n return {\n type: 'link',\n title: null,\n url: 'mailto:' + atext + '@' + label,\n children: [{type: 'text', value: atext + '@' + label}]\n }\n}\n\n/**\n * @param {string} domain\n * @returns {boolean}\n */\nfunction isCorrectDomain(domain) {\n const parts = domain.split('.')\n\n if (\n parts.length < 2 ||\n (parts[parts.length - 1] &&\n (/_/.test(parts[parts.length - 1]) ||\n !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n (parts[parts.length - 2] &&\n (/_/.test(parts[parts.length - 2]) ||\n !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n ) {\n return false\n }\n\n return true\n}\n\n/**\n * @param {string} url\n * @returns {[string, string|undefined]}\n */\nfunction splitUrl(url) {\n const trailExec = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n /** @type {number} */\n let closingParenIndex\n /** @type {number} */\n let openingParens\n /** @type {number} */\n let closingParens\n /** @type {string|undefined} */\n let trail\n\n if (trailExec) {\n url = url.slice(0, trailExec.index)\n trail = trailExec[0]\n closingParenIndex = trail.indexOf(')')\n openingParens = ccount(url, '(')\n closingParens = ccount(url, ')')\n\n while (closingParenIndex !== -1 && openingParens > closingParens) {\n url += trail.slice(0, closingParenIndex + 1)\n trail = trail.slice(closingParenIndex + 1)\n closingParenIndex = trail.indexOf(')')\n closingParens++\n }\n }\n\n return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean} [email=false]\n * @returns {boolean}\n */\nfunction previous(match, email) {\n const code = match.input.charCodeAt(match.index - 1)\n\n return (\n (match.index === 0 ||\n unicodeWhitespace(code) ||\n unicodePunctuation(code)) &&\n (!email || code !== 47)\n )\n}\n","/**\n * @typedef {import('mdast').Association} Association\n */\n\nimport {decodeString} from 'micromark-util-decode-string'\n\n/**\n * The `label` of an association is the string value: character escapes and\n * references work, and casing is intact.\n * The `identifier` is used to match one association to another: controversially,\n * character escapes and references don’t work in this matching: `©` does\n * not match `©`, and `\\+` does not match `+`.\n * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\\nb`\n * matches `a b`.\n * So, we do prefer the label when figuring out how we’re going to serialize:\n * it has whitespace, casing, and we can ignore most useless character escapes\n * and all character references.\n *\n * @param {Association} node\n * @returns {string}\n */\nexport function association(node) {\n if (node.label || !node.identifier) {\n return node.label || ''\n }\n\n return decodeString(node.identifier)\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('../types.js').TrackFields} TrackFields\n */\n\n/**\n * Functions to track output positions.\n * This info isn’t used yet but suchs functionality allows line wrapping,\n * and theoretically source maps (though, is there practical use in that?).\n *\n * @param {TrackFields} options_\n */\nexport function track(options_) {\n // Defaults are used to prevent crashes when older utilities somehow activate\n // this code.\n /* c8 ignore next 5 */\n const options = options_ || {}\n const now = options.now || {}\n let lineShift = options.lineShift || 0\n let line = now.line || 1\n let column = now.column || 1\n\n return {move, current, shift}\n\n /**\n * Get the current tracked info.\n *\n * @returns {{now: Point, lineShift: number}}\n */\n function current() {\n return {now: {line, column}, lineShift}\n }\n\n /**\n * Define an increased line shift (the typical indent for lines).\n *\n * @param {number} value\n */\n function shift(value) {\n lineShift += value\n }\n\n /**\n * Move past a string.\n *\n * @param {string} value\n * @returns {string}\n */\n function move(value = '') {\n const chunks = value.split(/\\r?\\n|\\r/g)\n const tail = chunks[chunks.length - 1]\n line += chunks.length - 1\n column =\n chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift\n return value\n }\n}\n","/**\n * @typedef {import('../types.js').Node} Node\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').Join} Join\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').TrackFields} TrackFields\n */\n\nimport {track} from './track.js'\n\n/**\n * @param {Parent} parent\n * @param {Context} context\n * @param {TrackFields} safeOptions\n * @returns {string}\n */\nexport function containerFlow(parent, context, safeOptions) {\n const indexStack = context.indexStack\n const children = parent.children || []\n const tracker = track(safeOptions)\n /** @type {Array} */\n const results = []\n let index = -1\n\n indexStack.push(-1)\n\n while (++index < children.length) {\n const child = children[index]\n\n indexStack[indexStack.length - 1] = index\n\n results.push(\n tracker.move(\n context.handle(child, parent, context, {\n before: '\\n',\n after: '\\n',\n ...tracker.current()\n })\n )\n )\n\n if (child.type !== 'list') {\n context.bulletLastUsed = undefined\n }\n\n if (index < children.length - 1) {\n results.push(tracker.move(between(child, children[index + 1])))\n }\n }\n\n indexStack.pop()\n\n return results.join('')\n\n /**\n * @param {Node} left\n * @param {Node} right\n * @returns {string}\n */\n function between(left, right) {\n let index = context.join.length\n\n while (index--) {\n const result = context.join[index](left, right, parent, context)\n\n if (result === true || result === 1) {\n break\n }\n\n if (typeof result === 'number') {\n return '\\n'.repeat(1 + result)\n }\n\n if (result === false) {\n return '\\n\\n\\n\\n'\n }\n }\n\n return '\\n\\n'\n }\n}\n","/**\n * @callback Map\n * @param {string} value\n * @param {number} line\n * @param {boolean} blank\n * @returns {string}\n */\n\nconst eol = /\\r?\\n|\\r/g\n\n/**\n * @param {string} value\n * @param {Map} map\n * @returns {string}\n */\nexport function indentLines(value, map) {\n /** @type {Array} */\n const result = []\n let start = 0\n let line = 0\n /** @type {RegExpExecArray|null} */\n let match\n\n while ((match = eol.exec(value))) {\n one(value.slice(start, match.index))\n result.push(match[0])\n start = match.index + match[0].length\n line++\n }\n\n one(value.slice(start))\n\n return result.join('')\n\n /**\n * @param {string} value\n */\n function one(value) {\n result.push(map(value, line, !value))\n }\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Unsafe} pattern\n * @returns {RegExp}\n */\nexport function patternCompile(pattern) {\n if (!pattern._compiled) {\n const before =\n (pattern.atBreak ? '[\\\\r\\\\n][\\\\t ]*' : '') +\n (pattern.before ? '(?:' + pattern.before + ')' : '')\n\n pattern._compiled = new RegExp(\n (before ? '(' + before + ')' : '') +\n (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') +\n pattern.character +\n (pattern.after ? '(?:' + pattern.after + ')' : ''),\n 'g'\n )\n }\n\n return pattern._compiled\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Array} 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} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n if (!list) {\n return none\n }\n\n if (typeof list === 'string') {\n list = [list]\n }\n\n let index = -1\n\n while (++index < list.length) {\n if (stack.includes(list[index])) {\n return true\n }\n }\n\n return false\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').SafeOptions} SafeOptions\n */\n\nimport {patternCompile} from './pattern-compile.js'\nimport {patternInScope} from './pattern-in-scope.js'\n\n/**\n * @param {Context} context\n * @param {string|null|undefined} input\n * @param {SafeOptions & {encode?: Array}} config\n * @returns {string}\n */\nexport function safe(context, input, config) {\n const value = (config.before || '') + (input || '') + (config.after || '')\n /** @type {Array} */\n const positions = []\n /** @type {Array} */\n const result = []\n /** @type {Record} */\n const infos = {}\n let index = -1\n\n while (++index < context.unsafe.length) {\n const pattern = context.unsafe[index]\n\n if (!patternInScope(context.stack, pattern)) {\n continue\n }\n\n const expression = patternCompile(pattern)\n /** @type {RegExpExecArray|null} */\n let match\n\n while ((match = expression.exec(value))) {\n const before = 'before' in pattern || Boolean(pattern.atBreak)\n const after = 'after' in pattern\n const position = match.index + (before ? match[1].length : 0)\n\n if (positions.includes(position)) {\n if (infos[position].before && !before) {\n infos[position].before = false\n }\n\n if (infos[position].after && !after) {\n infos[position].after = false\n }\n } else {\n positions.push(position)\n infos[position] = {before, after}\n }\n }\n }\n\n positions.sort(numerical)\n\n let start = config.before ? config.before.length : 0\n const end = value.length - (config.after ? config.after.length : 0)\n index = -1\n\n while (++index < positions.length) {\n const position = positions[index]\n\n // Character before or after matched:\n if (position < start || position >= end) {\n continue\n }\n\n // If this character is supposed to be escaped because it has a condition on\n // the next character, and the next character is definitly being escaped,\n // then skip this escape.\n if (\n (position + 1 < end &&\n positions[index + 1] === position + 1 &&\n infos[position].after &&\n !infos[position + 1].before &&\n !infos[position + 1].after) ||\n (positions[index - 1] === position - 1 &&\n infos[position].before &&\n !infos[position - 1].before &&\n !infos[position - 1].after)\n ) {\n continue\n }\n\n if (start !== position) {\n // If we have to use a character reference, an ampersand would be more\n // correct, but as backslashes only care about punctuation, either will\n // do the trick\n result.push(escapeBackslashes(value.slice(start, position), '\\\\'))\n }\n\n start = position\n\n if (\n /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&\n (!config.encode || !config.encode.includes(value.charAt(position)))\n ) {\n // Character escape.\n result.push('\\\\')\n } else {\n // Character reference.\n result.push(\n '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'\n )\n start++\n }\n }\n\n result.push(escapeBackslashes(value.slice(start, end), config.after))\n\n return result.join('')\n}\n\n/**\n * @param {number} a\n * @param {number} b\n * @returns {number}\n */\nfunction numerical(a, b) {\n return a - b\n}\n\n/**\n * @param {string} value\n * @param {string} after\n * @returns {string}\n */\nfunction escapeBackslashes(value, after) {\n const expression = /\\\\(?=[!-/:-@[-`{-~])/g\n /** @type {Array} */\n const positions = []\n /** @type {Array} */\n const results = []\n const whole = value + after\n let index = -1\n let start = 0\n /** @type {RegExpExecArray|null} */\n let match\n\n while ((match = expression.exec(whole))) {\n positions.push(match.index)\n }\n\n while (++index < positions.length) {\n if (start !== positions[index]) {\n results.push(value.slice(start, positions[index]))\n }\n\n results.push('\\\\')\n start = positions[index]\n }\n\n results.push(value.slice(start))\n\n return results.join('')\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Map} Map\n */\n\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {association} from 'mdast-util-to-markdown/lib/util/association.js'\nimport {containerFlow} from 'mdast-util-to-markdown/lib/util/container-flow.js'\nimport {indentLines} from 'mdast-util-to-markdown/lib/util/indent-lines.js'\nimport {safe} from 'mdast-util-to-markdown/lib/util/safe.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/**\n * @returns {FromMarkdownExtension}\n */\nexport function gfmFootnoteFromMarkdown() {\n return {\n enter: {\n gfmFootnoteDefinition: enterFootnoteDefinition,\n gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,\n gfmFootnoteCall: enterFootnoteCall,\n gfmFootnoteCallString: enterFootnoteCallString\n },\n exit: {\n gfmFootnoteDefinition: exitFootnoteDefinition,\n gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,\n gfmFootnoteCall: exitFootnoteCall,\n gfmFootnoteCallString: exitFootnoteCallString\n }\n }\n\n /** @type {FromMarkdownHandle} */\n function enterFootnoteDefinition(token) {\n this.enter(\n {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n token\n )\n }\n\n /** @type {FromMarkdownHandle} */\n function enterFootnoteDefinitionLabelString() {\n this.buffer()\n }\n\n /** @type {FromMarkdownHandle} */\n function exitFootnoteDefinitionLabelString(token) {\n const label = this.resume()\n const node = /** @type {FootnoteDefinition} */ (\n this.stack[this.stack.length - 1]\n )\n node.label = label\n node.identifier = normalizeIdentifier(\n this.sliceSerialize(token)\n ).toLowerCase()\n }\n\n /** @type {FromMarkdownHandle} */\n function exitFootnoteDefinition(token) {\n this.exit(token)\n }\n\n /** @type {FromMarkdownHandle} */\n function enterFootnoteCall(token) {\n this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n }\n\n /** @type {FromMarkdownHandle} */\n function enterFootnoteCallString() {\n this.buffer()\n }\n\n /** @type {FromMarkdownHandle} */\n function exitFootnoteCallString(token) {\n const label = this.resume()\n const node = /** @type {FootnoteDefinition} */ (\n this.stack[this.stack.length - 1]\n )\n node.label = label\n node.identifier = normalizeIdentifier(\n this.sliceSerialize(token)\n ).toLowerCase()\n }\n\n /** @type {FromMarkdownHandle} */\n function exitFootnoteCall(token) {\n this.exit(token)\n }\n}\n\n/**\n * @returns {ToMarkdownExtension}\n */\nexport function gfmFootnoteToMarkdown() {\n footnoteReference.peek = footnoteReferencePeek\n\n return {\n // This is on by default already.\n unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],\n handlers: {footnoteDefinition, footnoteReference}\n }\n\n /**\n * @type {ToMarkdownHandle}\n * @param {FootnoteReference} node\n */\n function footnoteReference(node, _, context, safeOptions) {\n const tracker = track(safeOptions)\n let value = tracker.move('[^')\n const exit = context.enter('footnoteReference')\n const subexit = context.enter('reference')\n value += tracker.move(\n safe(context, association(node), {\n ...tracker.current(),\n before: value,\n after: ']'\n })\n )\n subexit()\n exit()\n value += tracker.move(']')\n return value\n }\n\n /** @type {ToMarkdownHandle} */\n function footnoteReferencePeek() {\n return '['\n }\n\n /**\n * @type {ToMarkdownHandle}\n * @param {FootnoteDefinition} node\n */\n function footnoteDefinition(node, _, context, safeOptions) {\n const tracker = track(safeOptions)\n let value = tracker.move('[^')\n const exit = context.enter('footnoteDefinition')\n const subexit = context.enter('label')\n value += tracker.move(\n safe(context, association(node), {\n ...tracker.current(),\n before: value,\n after: ']'\n })\n )\n subexit()\n value += tracker.move(\n ']:' + (node.children && node.children.length > 0 ? ' ' : '')\n )\n tracker.shift(4)\n value += tracker.move(\n indentLines(containerFlow(node, context, tracker.current()), map)\n )\n exit()\n\n return value\n\n /** @type {Map} */\n function map(line, index, blank) {\n if (index) {\n return (blank ? '' : ' ') + line\n }\n\n return line\n }\n }\n}\n","/**\n * @typedef {import('../types.js').Node} Node\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').SafeOptions} SafeOptions\n * @typedef {import('../types.js').Context} Context\n */\n\nimport {track} from './track.js'\n\n/**\n * @param {Parent} parent\n * @param {Context} context\n * @param {SafeOptions} safeOptions\n * @returns {string}\n */\nexport function containerPhrasing(parent, context, safeOptions) {\n const indexStack = context.indexStack\n const children = parent.children || []\n /** @type {Array} */\n const results = []\n let index = -1\n let before = safeOptions.before\n\n indexStack.push(-1)\n let tracker = track(safeOptions)\n\n while (++index < children.length) {\n const child = children[index]\n /** @type {string} */\n let after\n\n indexStack[indexStack.length - 1] = index\n\n if (index + 1 < children.length) {\n // @ts-expect-error: hush, it’s actually a `zwitch`.\n let handle = context.handle.handlers[children[index + 1].type]\n if (handle && handle.peek) handle = handle.peek\n after = handle\n ? handle(children[index + 1], parent, context, {\n before: '',\n after: '',\n ...tracker.current()\n }).charAt(0)\n : ''\n } else {\n after = safeOptions.after\n }\n\n // In some cases, html (text) can be found in phrasing right after an eol.\n // When we’d serialize that, in most cases that would be seen as html\n // (flow).\n // As we can’t escape or so to prevent it from happening, we take a somewhat\n // reasonable approach: replace that eol with a space.\n // See: \n if (\n results.length > 0 &&\n (before === '\\r' || before === '\\n') &&\n child.type === 'html'\n ) {\n results[results.length - 1] = results[results.length - 1].replace(\n /(\\r?\\n|\\r)$/,\n ' '\n )\n before = ' '\n\n // To do: does this work to reset tracker?\n tracker = track(safeOptions)\n tracker.move(results.join(''))\n }\n\n results.push(\n tracker.move(\n context.handle(child, parent, context, {\n ...tracker.current(),\n before,\n after\n })\n )\n )\n\n before = results[results.length - 1].slice(-1)\n }\n\n indexStack.pop()\n\n return results.join('')\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmStrikethroughFromMarkdown = {\n canContainEols: ['delete'],\n enter: {strikethrough: enterStrikethrough},\n exit: {strikethrough: exitStrikethrough}\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmStrikethroughToMarkdown = {\n unsafe: [{character: '~', inConstruct: 'phrasing'}],\n handlers: {delete: handleDelete}\n}\n\nhandleDelete.peek = peekDelete\n\n/** @type {FromMarkdownHandle} */\nfunction enterStrikethrough(token) {\n this.enter({type: 'delete', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitStrikethrough(token) {\n this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, context, safeOptions) {\n const tracker = track(safeOptions)\n const exit = context.enter('emphasis')\n let value = tracker.move('~~')\n value += containerPhrasing(node, context, {\n ...tracker.current(),\n before: value,\n after: '~'\n })\n value += tracker.move('~~')\n exit()\n return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction peekDelete() {\n return '~'\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../types.js').Handle} Handle\n */\n\nimport {patternCompile} from '../util/pattern-compile.js'\n\ninlineCode.peek = inlineCodePeek\n\n/**\n * @type {Handle}\n * @param {InlineCode} node\n */\nexport function inlineCode(node, _, context) {\n let value = node.value || ''\n let sequence = '`'\n let index = -1\n\n // If there is a single grave accent on its own in the code, use a fence of\n // two.\n // If there are two in a row, use one.\n while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n sequence += '`'\n }\n\n // If this is not just spaces or eols (tabs don’t count), and either the\n // first or last character are a space, eol, or tick, then pad with spaces.\n if (\n /[^ \\r\\n]/.test(value) &&\n ((/^[ \\r\\n]/.test(value) && /[ \\r\\n]$/.test(value)) || /^`|`$/.test(value))\n ) {\n value = ' ' + value + ' '\n }\n\n // We have a potential problem: certain characters after eols could result in\n // blocks being seen.\n // For example, if someone injected the string `'\\n# b'`, then that would\n // result in an ATX heading.\n // We can’t escape characters in `inlineCode`, but because eols are\n // transformed to spaces when going from markdown to HTML anyway, we can swap\n // them out.\n while (++index < context.unsafe.length) {\n const pattern = context.unsafe[index]\n const expression = patternCompile(pattern)\n /** @type {RegExpExecArray|null} */\n let match\n\n // Only look for `atBreak`s.\n // Btw: note that `atBreak` patterns will always start the regex at LF or\n // CR.\n if (!pattern.atBreak) continue\n\n while ((match = expression.exec(value))) {\n let position = match.index\n\n // Support CRLF (patterns only look for one of the characters).\n if (\n value.charCodeAt(position) === 10 /* `\\n` */ &&\n value.charCodeAt(position - 1) === 13 /* `\\r` */\n ) {\n position--\n }\n\n value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n }\n }\n\n return sequence + value + sequence\n}\n\n/**\n * @type {Handle}\n */\nfunction inlineCodePeek() {\n return '`'\n}\n","/**\n * @typedef Options\n * Configuration (optional).\n * @property {string|null|Array} [align]\n * One style for all columns, or styles for their respective columns.\n * Each style is either `'l'` (left), `'r'` (right), or `'c'` (center).\n * Other values are treated as `''`, which doesn’t place the colon in the\n * alignment row but does align left.\n * *Only the lowercased first character is used, so `Right` is fine.*\n * @property {boolean} [padding=true]\n * Whether to add a space of padding between delimiters and cells.\n *\n * When `true`, there is padding:\n *\n * ```markdown\n * | Alpha | B |\n * | ----- | ----- |\n * | C | Delta |\n * ```\n *\n * When `false`, there is no padding:\n *\n * ```markdown\n * |Alpha|B |\n * |-----|-----|\n * |C |Delta|\n * ```\n * @property {boolean} [delimiterStart=true]\n * Whether to begin each row with the delimiter.\n *\n * > 👉 **Note**: please don’t use this: it could create fragile structures\n * > that aren’t understandable to some markdown parsers.\n *\n * When `true`, there are starting delimiters:\n *\n * ```markdown\n * | Alpha | B |\n * | ----- | ----- |\n * | C | Delta |\n * ```\n *\n * When `false`, there are no starting delimiters:\n *\n * ```markdown\n * Alpha | B |\n * ----- | ----- |\n * C | Delta |\n * ```\n * @property {boolean} [delimiterEnd=true]\n * Whether to end each row with the delimiter.\n *\n * > 👉 **Note**: please don’t use this: it could create fragile structures\n * > that aren’t understandable to some markdown parsers.\n *\n * When `true`, there are ending delimiters:\n *\n * ```markdown\n * | Alpha | B |\n * | ----- | ----- |\n * | C | Delta |\n * ```\n *\n * When `false`, there are no ending delimiters:\n *\n * ```markdown\n * | Alpha | B\n * | ----- | -----\n * | C | Delta\n * ```\n * @property {boolean} [alignDelimiters=true]\n * Whether to align the delimiters.\n * By default, they are aligned:\n *\n * ```markdown\n * | Alpha | B |\n * | ----- | ----- |\n * | C | Delta |\n * ```\n *\n * Pass `false` to make them staggered:\n *\n * ```markdown\n * | Alpha | B |\n * | - | - |\n * | C | Delta |\n * ```\n * @property {(value: string) => number} [stringLength]\n * Function to detect the length of table cell content.\n * This is used when aligning the delimiters (`|`) between table cells.\n * Full-width characters and emoji mess up delimiter alignment when viewing\n * the markdown source.\n * To fix this, you can pass this function, which receives the cell content\n * and returns its “visible” size.\n * Note that what is and isn’t visible depends on where the text is displayed.\n *\n * Without such a function, the following:\n *\n * ```js\n * markdownTable([\n * ['Alpha', 'Bravo'],\n * ['中文', 'Charlie'],\n * ['👩‍❤️‍👩', 'Delta']\n * ])\n * ```\n *\n * Yields:\n *\n * ```markdown\n * | Alpha | Bravo |\n * | - | - |\n * | 中文 | Charlie |\n * | 👩‍❤️‍👩 | Delta |\n * ```\n *\n * With [`string-width`](https://github.com/sindresorhus/string-width):\n *\n * ```js\n * import stringWidth from 'string-width'\n *\n * markdownTable(\n * [\n * ['Alpha', 'Bravo'],\n * ['中文', 'Charlie'],\n * ['👩‍❤️‍👩', 'Delta']\n * ],\n * {stringLength: stringWidth}\n * )\n * ```\n *\n * Yields:\n *\n * ```markdown\n * | Alpha | Bravo |\n * | ----- | ------- |\n * | 中文 | Charlie |\n * | 👩‍❤️‍👩 | Delta |\n * ```\n */\n\n/**\n * @typedef {Options} MarkdownTableOptions\n * @todo\n * Remove next major.\n */\n\n/**\n * Generate a markdown ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables)) table..\n *\n * @param {Array>} 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} Character codes as symbols for alignment per column. */\n const alignments = []\n /** @type {Array>} Cells per row. */\n const cellMatrix = []\n /** @type {Array>} Sizes of each cell per row. */\n const sizeMatrix = []\n /** @type {Array} */\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} */\n const row = []\n /** @type {Array} */\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} */\n const row = []\n /** @type {Array} */\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} */\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} */\n const line = []\n\n while (++columnIndex < mostCellsPerRow) {\n const cell = row[columnIndex] || ''\n let before = ''\n let after = ''\n\n if (options.alignDelimiters !== false) {\n const size =\n longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0)\n const code = alignments[columnIndex]\n\n if (code === 114 /* `r` */) {\n before = ' '.repeat(size)\n } else if (code === 99 /* `c` */) {\n if (size % 2) {\n before = ' '.repeat(size / 2 + 0.5)\n after = ' '.repeat(size / 2 - 0.5)\n } else {\n before = ' '.repeat(size / 2)\n after = before\n }\n } else {\n after = ' '.repeat(size)\n }\n }\n\n if (options.delimiterStart !== false && !columnIndex) {\n line.push('|')\n }\n\n if (\n options.padding !== false &&\n // Don’t add the opening space if we’re not aligning and the cell is\n // empty: there will be a closing space.\n !(options.alignDelimiters === false && cell === '') &&\n (options.delimiterStart !== false || columnIndex)\n ) {\n line.push(' ')\n }\n\n if (options.alignDelimiters !== false) {\n line.push(before)\n }\n\n line.push(cell)\n\n if (options.alignDelimiters !== false) {\n line.push(after)\n }\n\n if (options.padding !== false) {\n line.push(' ')\n }\n\n if (\n options.delimiterEnd !== false ||\n columnIndex !== mostCellsPerRow - 1\n ) {\n line.push('|')\n }\n }\n\n lines.push(\n options.delimiterEnd === false\n ? line.join('').replace(/ +$/, '')\n : line.join('')\n )\n }\n\n return lines.join('\\n')\n}\n\n/**\n * @param {string|null|undefined} [value]\n * @returns {string}\n */\nfunction serialize(value) {\n return value === null || value === undefined ? '' : String(value)\n}\n\n/**\n * @param {string} value\n * @returns {number}\n */\nfunction defaultStringLength(value) {\n return value.length\n}\n\n/**\n * @param {string|null|undefined} value\n * @returns {number}\n */\nfunction toAlignment(value) {\n const code = typeof value === 'string' ? value.codePointAt(0) : 0\n\n return code === 67 /* `C` */ || code === 99 /* `c` */\n ? 99 /* `c` */\n : code === 76 /* `L` */ || code === 108 /* `l` */\n ? 108 /* `l` */\n : code === 82 /* `R` */ || code === 114 /* `r` */\n ? 114 /* `r` */\n : 0\n}\n","/**\n * @typedef {import('mdast').AlignType} AlignType\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('markdown-table').MarkdownTableOptions} MarkdownTableOptions\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Context} ToMarkdownContext\n * @typedef {import('mdast-util-to-markdown').SafeOptions} SafeOptions\n *\n * @typedef Options\n * @property {boolean} [tableCellPadding=true]\n * @property {boolean} [tablePipeAlign=true]\n * @property {MarkdownTableOptions['stringLength']} [stringLength]\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {inlineCode} from 'mdast-util-to-markdown/lib/handle/inline-code.js'\nimport {markdownTable} from 'markdown-table'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmTableFromMarkdown = {\n enter: {\n table: enterTable,\n tableData: enterCell,\n tableHeader: enterCell,\n tableRow: enterRow\n },\n exit: {\n codeText: exitCodeText,\n table: exitTable,\n tableData: exit,\n tableHeader: exit,\n tableRow: exit\n }\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterTable(token) {\n /** @type {Array<'left'|'right'|'center'|'none'>} */\n // @ts-expect-error: `align` is custom.\n const align = token._align\n this.enter(\n {\n type: 'table',\n align: align.map((d) => (d === 'none' ? null : d)),\n children: []\n },\n token\n )\n this.setData('inTable', true)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitTable(token) {\n this.exit(token)\n this.setData('inTable')\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterRow(token) {\n this.enter({type: 'tableRow', children: []}, token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exit(token) {\n this.exit(token)\n}\n\n/** @type {FromMarkdownHandle} */\nfunction enterCell(token) {\n this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n/** @type {FromMarkdownHandle} */\nfunction exitCodeText(token) {\n let value = this.resume()\n\n if (this.getData('inTable')) {\n value = value.replace(/\\\\([\\\\|])/g, replace)\n }\n\n const node = /** @type {InlineCode} */ (this.stack[this.stack.length - 1])\n node.value = value\n this.exit(token)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @returns {string}\n */\nfunction replace($0, $1) {\n // Pipes work, backslashes don’t (but can’t escape pipes).\n return $1 === '|' ? $1 : $0\n}\n\n/**\n * @param {Options} [options]\n * @returns {ToMarkdownExtension}\n */\nexport function gfmTableToMarkdown(options) {\n const settings = options || {}\n const padding = settings.tableCellPadding\n const alignDelimiters = settings.tablePipeAlign\n const stringLength = settings.stringLength\n const around = padding ? ' ' : '|'\n\n return {\n unsafe: [\n {character: '\\r', inConstruct: 'tableCell'},\n {character: '\\n', inConstruct: 'tableCell'},\n // A pipe, when followed by a tab or space (padding), or a dash or colon\n // (unpadded delimiter row), could result in a table.\n {atBreak: true, character: '|', after: '[\\t :-]'},\n // A pipe in a cell must be encoded.\n {character: '|', inConstruct: 'tableCell'},\n // A colon must be followed by a dash, in which case it could start a\n // delimiter row.\n {atBreak: true, character: ':', after: '-'},\n // A delimiter row can also start with a dash, when followed by more\n // dashes, a colon, or a pipe.\n // This is a stricter version than the built in check for lists, thematic\n // breaks, and setex heading underlines though:\n // \n {atBreak: true, character: '-', after: '[:|-]'}\n ],\n handlers: {\n table: handleTable,\n tableRow: handleTableRow,\n tableCell: handleTableCell,\n inlineCode: inlineCodeWithTable\n }\n }\n\n /**\n * @type {ToMarkdownHandle}\n * @param {Table} node\n */\n function handleTable(node, _, context, safeOptions) {\n return serializeData(\n handleTableAsData(node, context, safeOptions),\n // @ts-expect-error: fixed in `markdown-table@3.0.1`.\n node.align\n )\n }\n\n /**\n * This function isn’t really used normally, because we handle rows at the\n * table level.\n * But, if someone passes in a table row, this ensures we make somewhat sense.\n *\n * @type {ToMarkdownHandle}\n * @param {TableRow} node\n */\n function handleTableRow(node, _, context, safeOptions) {\n const row = handleTableRowAsData(node, context, safeOptions)\n // `markdown-table` will always add an align row\n const value = serializeData([row])\n return value.slice(0, value.indexOf('\\n'))\n }\n\n /**\n * @type {ToMarkdownHandle}\n * @param {TableCell} node\n */\n function handleTableCell(node, _, context, safeOptions) {\n const exit = context.enter('tableCell')\n const subexit = context.enter('phrasing')\n const value = containerPhrasing(node, context, {\n ...safeOptions,\n before: around,\n after: around\n })\n subexit()\n exit()\n return value\n }\n\n /**\n * @param {Array>} matrix\n * @param {Array} [align]\n */\n function serializeData(matrix, align) {\n return markdownTable(matrix, {\n align,\n alignDelimiters,\n padding,\n stringLength\n })\n }\n\n /**\n * @param {Table} node\n * @param {ToMarkdownContext} context\n * @param {SafeOptions} safeOptions\n */\n function handleTableAsData(node, context, safeOptions) {\n const children = node.children\n let index = -1\n /** @type {Array>} */\n const result = []\n const subexit = context.enter('table')\n\n while (++index < children.length) {\n result[index] = handleTableRowAsData(\n children[index],\n context,\n safeOptions\n )\n }\n\n subexit()\n\n return result\n }\n\n /**\n * @param {TableRow} node\n * @param {ToMarkdownContext} context\n * @param {SafeOptions} safeOptions\n */\n function handleTableRowAsData(node, context, safeOptions) {\n const children = node.children\n let index = -1\n /** @type {Array} */\n const result = []\n const subexit = context.enter('tableRow')\n\n while (++index < children.length) {\n // Note: the positional info as used here is incorrect.\n // Making it correct would be impossible due to aligning cells?\n // And it would need copy/pasting `markdown-table` into this project.\n result[index] = handleTableCell(\n children[index],\n node,\n context,\n safeOptions\n )\n }\n\n subexit()\n\n return result\n }\n\n /**\n * @type {ToMarkdownHandle}\n * @param {InlineCode} node\n */\n function inlineCodeWithTable(node, parent, context) {\n let value = inlineCode(node, parent, context)\n\n if (context.stack.includes('tableCell')) {\n value = value.replace(/\\|/g, '\\\\$&')\n }\n\n return value\n }\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('../util/indent-lines.js').Map} Map\n * @typedef {import('../types.js').Options} Options\n * @typedef {import('../types.js').Handle} Handle\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkListItemIndent} from '../util/check-list-item-indent.js'\nimport {containerFlow} from '../util/container-flow.js'\nimport {indentLines} from '../util/indent-lines.js'\nimport {track} from '../util/track.js'\n\n/**\n * @type {Handle}\n * @param {ListItem} node\n */\nexport function listItem(node, parent, context, safeOptions) {\n const listItemIndent = checkListItemIndent(context)\n let bullet = context.bulletCurrent || checkBullet(context)\n\n // Add the marker value for ordered lists.\n if (parent && parent.type === 'list' && parent.ordered) {\n bullet =\n (typeof parent.start === 'number' && parent.start > -1\n ? parent.start\n : 1) +\n (context.options.incrementListMarker === false\n ? 0\n : parent.children.indexOf(node)) +\n bullet\n }\n\n let size = bullet.length + 1\n\n if (\n listItemIndent === 'tab' ||\n (listItemIndent === 'mixed' &&\n ((parent && parent.type === 'list' && parent.spread) || node.spread))\n ) {\n size = Math.ceil(size / 4) * 4\n }\n\n const tracker = track(safeOptions)\n tracker.move(bullet + ' '.repeat(size - bullet.length))\n tracker.shift(size)\n const exit = context.enter('listItem')\n const value = indentLines(\n containerFlow(node, context, tracker.current()),\n map\n )\n exit()\n\n return value\n\n /** @type {Map} */\n function map(line, index, blank) {\n if (index) {\n return (blank ? '' : ' '.repeat(size)) + line\n }\n\n return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line\n }\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {Context} context\n * @returns {Exclude}\n */\nexport function checkListItemIndent(context) {\n const style = context.options.listItemIndent || 'tab'\n\n // To do: remove in a major.\n // @ts-expect-error: deprecated.\n if (style === 1 || style === '1') {\n return 'one'\n }\n\n if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n throw new Error(\n 'Cannot serialize items with `' +\n style +\n '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n )\n }\n\n return style\n}\n","/**\n * @typedef {import('../types.js').Context} Context\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {Context} context\n * @returns {Exclude}\n */\nexport function checkBullet(context) {\n const marker = context.options.bullet || '*'\n\n if (marker !== '*' && marker !== '+' && marker !== '-') {\n throw new Error(\n 'Cannot serialize items with `' +\n marker +\n '` for `options.bullet`, expected `*`, `+`, or `-`'\n )\n }\n\n return marker\n}\n","/**\n * @typedef {Extract} Parent\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').BlockContent} BlockContent\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {listItem} from 'mdast-util-to-markdown/lib/handle/list-item.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n/** @type {FromMarkdownExtension} */\nexport const gfmTaskListItemFromMarkdown = {\n exit: {\n taskListCheckValueChecked: exitCheck,\n taskListCheckValueUnchecked: exitCheck,\n paragraph: exitParagraphWithTaskListItem\n }\n}\n\n/** @type {ToMarkdownExtension} */\nexport const gfmTaskListItemToMarkdown = {\n unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n handlers: {listItem: listItemWithTaskListItem}\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitCheck(token) {\n const node = /** @type {ListItem} */ (this.stack[this.stack.length - 2])\n // We’re always in a paragraph, in a list item.\n node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/** @type {FromMarkdownHandle} */\nfunction exitParagraphWithTaskListItem(token) {\n const parent = /** @type {Parent} */ (this.stack[this.stack.length - 2])\n const node = /** @type {Paragraph} */ (this.stack[this.stack.length - 1])\n const siblings = parent.children\n const head = node.children[0]\n let index = -1\n /** @type {Paragraph|undefined} */\n let firstParaghraph\n\n if (\n parent &&\n parent.type === 'listItem' &&\n typeof parent.checked === 'boolean' &&\n head &&\n head.type === 'text'\n ) {\n while (++index < siblings.length) {\n const sibling = siblings[index]\n if (sibling.type === 'paragraph') {\n firstParaghraph = sibling\n break\n }\n }\n\n if (firstParaghraph === node) {\n // Must start with a space or a tab.\n head.value = head.value.slice(1)\n\n if (head.value.length === 0) {\n node.children.shift()\n } else if (\n node.position &&\n head.position &&\n typeof head.position.start.offset === 'number'\n ) {\n head.position.start.column++\n head.position.start.offset++\n node.position.start = Object.assign({}, head.position.start)\n }\n }\n }\n\n this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, context, safeOptions) {\n const head = node.children[0]\n const checkable =\n typeof node.checked === 'boolean' && head && head.type === 'paragraph'\n const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '\n const tracker = track(safeOptions)\n\n if (checkable) {\n tracker.move(checkbox)\n }\n\n let value = listItem(node, parent, context, {\n ...safeOptions,\n ...tracker.current()\n })\n\n if (checkable) {\n value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n }\n\n return value\n\n /**\n * @param {string} $0\n * @returns {string}\n */\n function check($0) {\n return $0 + checkbox\n }\n}\n","/**\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n *\n * @typedef {import('mdast-util-gfm-table').Options} Options\n */\n\nimport {\n gfmAutolinkLiteralFromMarkdown,\n gfmAutolinkLiteralToMarkdown\n} from 'mdast-util-gfm-autolink-literal'\nimport {\n gfmFootnoteFromMarkdown,\n gfmFootnoteToMarkdown\n} from 'mdast-util-gfm-footnote'\nimport {\n gfmStrikethroughFromMarkdown,\n gfmStrikethroughToMarkdown\n} from 'mdast-util-gfm-strikethrough'\nimport {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'\nimport {\n gfmTaskListItemFromMarkdown,\n gfmTaskListItemToMarkdown\n} from 'mdast-util-gfm-task-list-item'\n\n/**\n * @returns {Array}\n */\nexport function gfmFromMarkdown() {\n return [\n gfmAutolinkLiteralFromMarkdown,\n gfmFootnoteFromMarkdown(),\n gfmStrikethroughFromMarkdown,\n gfmTableFromMarkdown,\n gfmTaskListItemFromMarkdown\n ]\n}\n\n/**\n * @param {Options} [options]\n * @returns {ToMarkdownExtension}\n */\nexport function gfmToMarkdown(options) {\n return {\n extensions: [\n gfmAutolinkLiteralToMarkdown,\n gfmFootnoteToMarkdown(),\n gfmStrikethroughToMarkdown,\n gfmTableToMarkdown(options),\n gfmTaskListItemToMarkdown\n ]\n }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options\n */\n\nimport {gfm} from 'micromark-extension-gfm'\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\n\n/**\n * Plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function remarkGfm(options = {}) {\n const data = this.data()\n\n add('micromarkExtensions', gfm(options))\n add('fromMarkdownExtensions', gfmFromMarkdown())\n add('toMarkdownExtensions', gfmToMarkdown(options))\n\n /**\n * @param {string} field\n * @param {unknown} value\n */\n function add(field, value) {\n const list = /** @type {unknown[]} */ (\n // Other extensions\n /* c8 ignore next 2 */\n data[field] ? data[field] : (data[field] = [])\n )\n\n list.push(value)\n }\n}\n","var own = {}.hasOwnProperty\n\n/**\n * Check if `node` has a set `name` property.\n *\n * @param {unknown} node\n * @param {string} name\n * @returns {boolean}\n */\nexport function hasProperty(node, name) {\n /** @type {unknown} */\n var value =\n name &&\n node &&\n typeof node === 'object' &&\n // @ts-ignore Looks like a node.\n node.type === 'element' &&\n // @ts-ignore Looks like an element.\n node.properties &&\n // @ts-ignore Looks like an element.\n own.call(node.properties, name) &&\n // @ts-ignore Looks like an element.\n node.properties[name]\n\n return value !== null && value !== undefined && value !== false\n}\n","/**\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Root} Root\n * @typedef {Root|Parent['children'][number]} Node\n */\n\n/**\n * Rank of a heading: H1 -> 1, H2 -> 2, etc.\n *\n * @param {Node} node\n * @returns {number|null}\n */\nexport function headingRank(node) {\n var name =\n (node && node.type === 'element' && node.tagName.toLowerCase()) || ''\n var code =\n name.length === 2 && name.charCodeAt(0) === 104 /* `h` */\n ? name.charCodeAt(1)\n : 0\n return code > 48 /* `0` */ && code < 55 /* `7` */ ? code - 48 /* `0` */ : null\n}\n","/**\n * @fileoverview\n * Get the plain-text value of a hast node.\n * @longdescription\n * ## Use\n *\n * ```js\n * import {h} from 'hastscript'\n * import {toString} from 'hast-util-to-string'\n *\n * toString(h('p', 'Alpha'))\n * //=> 'Alpha'\n * toString(h('div', [h('b', 'Bold'), ' and ', h('i', 'italic'), '.']))\n * //=> 'Bold and italic.'\n * ```\n *\n * ## API\n *\n * ### `toString(node)`\n *\n * Transform a node to a string.\n */\n\n/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n * @typedef {Root|Root['children'][number]} Node\n */\n\n/**\n * Get the plain-text value of a hast node.\n *\n * @param {Node} node\n * @returns {string}\n */\nexport function toString(node) {\n // “The concatenation of data of all the Text node descendants of the context\n // object, in tree order.”\n if ('children' in node) {\n return all(node)\n }\n\n // “Context object’s data.”\n return 'value' in node ? node.value : ''\n}\n\n/**\n * @param {Node} node\n * @returns {string}\n */\nfunction one(node) {\n if (node.type === 'text') {\n return node.value\n }\n\n return 'children' in node ? all(node) : ''\n}\n\n/**\n * @param {Root|Element} node\n * @returns {string}\n */\nfunction all(node) {\n let index = -1\n /** @type {string[]} */\n const result = []\n\n while (++index < node.children.length) {\n result[index] = one(node.children[index])\n }\n\n return result.join('')\n}\n","/**\n * @typedef {import('hast').Root} Root\n */\n\nimport Slugger from 'github-slugger'\nimport {hasProperty} from 'hast-util-has-property'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {toString} from 'hast-util-to-string'\nimport {visit} from 'unist-util-visit'\n\nconst slugs = new Slugger()\n\n/**\n * Plugin to add `id`s to headings.\n *\n * @type {import('unified').Plugin, Root>}\n */\nexport default function rehypeSlug() {\n return (tree) => {\n slugs.reset()\n\n visit(tree, 'element', (node) => {\n if (headingRank(node) && node.properties && !hasProperty(node, 'id')) {\n node.properties.id = slugs.slug(toString(node))\n }\n })\n }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('hast').Element} Element\n *\n * @typedef {string} TagName\n * @typedef {null|undefined|TagName|TestFunctionAnything|Array.} Test\n */\n\n/**\n * @template {Element} T\n * @typedef {null|undefined|T['tagName']|TestFunctionPredicate|Array.>} PredicateTest\n */\n\n/**\n * Check if an element passes a test\n *\n * @callback TestFunctionAnything\n * @param {Element} element\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if an element passes a certain node test\n *\n * @template {Element} X\n * @callback TestFunctionPredicate\n * @param {Element} element\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {element is X}\n */\n\n/**\n * Check if a node is an element and passes a certain node test\n *\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node is an element and passes a certain node test\n *\n * @template {Element} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\n// Check if `node` is an `element` and whether it passes the given test.\nexport const isElement =\n /**\n * Check if a node is an element and passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @type {(\n * (() => false) &\n * ((node: unknown, test?: PredicateTest, index?: number, parent?: Parent, context?: unknown) => node is T) &\n * ((node: unknown, test: Test, index?: number, parent?: Parent, context?: unknown) => boolean)\n * )}\n */\n (\n /**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @param {unknown} [node] Node to check\n * @param {Test} [test] When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `array`, checks any one of the subtests pass.\n * @param {number} [index] Position of `node` in `parent`\n * @param {Parent} [parent] Parent of `node`\n * @param {unknown} [context] Context object to invoke `test` with\n * @returns {boolean} Whether test passed and `node` is an `Element` (object with `type` set to `element` and `tagName` set to a non-empty string).\n */\n // eslint-disable-next-line max-params\n function (node, test, index, parent, context) {\n const check = convertElement(test)\n\n if (\n index !== undefined &&\n index !== null &&\n (typeof index !== 'number' ||\n index < 0 ||\n index === Number.POSITIVE_INFINITY)\n ) {\n throw new Error('Expected positive finite index for child node')\n }\n\n if (\n parent !== undefined &&\n parent !== null &&\n (!parent.type || !parent.children)\n ) {\n throw new Error('Expected parent node')\n }\n\n // @ts-expect-error Looks like a node.\n if (!node || !node.type || typeof node.type !== 'string') {\n return false\n }\n\n if (\n (parent === undefined || parent === null) !==\n (index === undefined || index === null)\n ) {\n throw new Error('Expected both parent and index')\n }\n\n return check.call(context, node, index, parent)\n }\n )\n\nexport const convertElement =\n /**\n * @type {(\n * ((test: T['tagName']|TestFunctionPredicate) => AssertPredicate) &\n * ((test?: Test) => AssertAnything)\n * )}\n */\n (\n /**\n * Generate an assertion from a check.\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @returns {AssertAnything}\n */\n function (test) {\n if (test === undefined || test === null) {\n return element\n }\n\n if (typeof test === 'string') {\n return tagNameFactory(test)\n }\n\n if (typeof test === 'object') {\n return anyFactory(test)\n }\n\n if (typeof test === 'function') {\n return castFactory(test)\n }\n\n throw new Error('Expected function, string, or array as test')\n }\n )\n\n/**\n * @param {Array.} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n /** @type {Array.} */\n const checks = []\n let index = -1\n\n while (++index < tests.length) {\n checks[index] = convertElement(tests[index])\n }\n\n return castFactory(any)\n\n /**\n * @this {unknown}\n * @param {unknown[]} parameters\n * @returns {boolean}\n */\n function any(...parameters) {\n let index = -1\n\n while (++index < checks.length) {\n if (checks[index].call(this, ...parameters)) {\n return true\n }\n }\n\n return false\n }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s tag\n * name for said string.\n *\n * @param {TagName} check\n * @returns {AssertAnything}\n */\nfunction tagNameFactory(check) {\n return tagName\n\n /**\n * @param {unknown} node\n * @returns {boolean}\n */\n function tagName(node) {\n return element(node) && node.tagName === check\n }\n}\n\n/**\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n return assertion\n\n /**\n * @this {unknown}\n * @param {unknown} node\n * @param {Array.} parameters\n * @returns {boolean}\n */\n function assertion(node, ...parameters) {\n // @ts-expect-error: fine.\n return element(node) && Boolean(check.call(this, node, ...parameters))\n }\n}\n\n/**\n * Utility to return true if this is an element.\n * @param {unknown} node\n * @returns {node is Element}\n */\nfunction element(node) {\n return Boolean(\n node &&\n typeof node === 'object' &&\n // @ts-expect-error Looks like a node.\n node.type === 'element' &&\n // @ts-expect-error Looks like an element.\n typeof node.tagName === 'string'\n )\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Element} Element\n * @typedef {Element['children'][number]} ElementChild\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast-util-is-element').Test} Test\n *\n * @typedef {'prepend'|'append'|'wrap'|'before'|'after'} Behavior\n *\n * @callback Build\n * @param {Element} node\n * @returns {ElementChild|ElementChild[]}\n *\n * @typedef Options\n * Configuration.\n * @property {Behavior} [behavior='prepend']\n * How to create links.\n * @property {Behavior} [behaviour]\n * Please use `behavior` instead\n * @property {Properties} [properties]\n * Extra properties to set on the link when injecting.\n * Defaults to `{ariaHidden: true, tabIndex: -1}` when `'prepend'` or\n * `'append'`.\n * @property {ElementChild|ElementChild[]|Build} [content={type: 'element', tagName: 'span', properties: {className: ['icon', 'icon-link']}, children: []}]\n * hast nodes to insert in the link.\n * @property {ElementChild|ElementChild[]|Build} [group]\n * hast node to wrap the heading and link with, if `behavior` is `'before'` or\n * `'after'`.\n * There is no default.\n * @property {Test} [test]\n * Test to define which heading elements are linked.\n * Any test that can be given to `hast-util-is-element` is supported.\n * The default (no test) is to link all headings.\n * Can be used to link only h1-h3, or for example all except h1.\n */\n\nimport extend from 'extend'\nimport {hasProperty} from 'hast-util-has-property'\nimport {headingRank} from 'hast-util-heading-rank'\nimport {convertElement} from 'hast-util-is-element'\nimport {visit, SKIP} from 'unist-util-visit'\n\n/** @type {Element} */\nconst contentDefaults = {\n type: 'element',\n tagName: 'span',\n properties: {className: ['icon', 'icon-link']},\n children: []\n}\n\n/**\n * Plugin to automatically add links to headings (h1-h6).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function rehypeAutolinkHeadings(options = {}) {\n let props = options.properties\n const behavior = options.behaviour || options.behavior || 'prepend'\n const content = options.content || contentDefaults\n const group = options.group\n const is = convertElement(options.test)\n\n /** @type {import('unist-util-visit/complex-types').Visitor} */\n let method\n\n if (behavior === 'wrap') {\n method = wrap\n } else if (behavior === 'before' || behavior === 'after') {\n method = around\n } else {\n if (!props) {\n props = {ariaHidden: 'true', tabIndex: -1}\n }\n\n method = inject\n }\n\n return (tree) => {\n visit(tree, 'element', (node, index, parent) => {\n if (\n headingRank(node) &&\n hasProperty(node, 'id') &&\n is(node, index, parent)\n ) {\n return method(node, index, parent)\n }\n })\n }\n\n /** @type {import('unist-util-visit/complex-types').Visitor} */\n function inject(node) {\n node.children[behavior === 'prepend' ? 'unshift' : 'push'](\n create(node, extend(true, {}, props), toChildren(content, node))\n )\n\n return [SKIP]\n }\n\n /** @type {import('unist-util-visit/complex-types').Visitor} */\n function around(node, index, parent) {\n // Uncommon.\n /* c8 ignore next */\n if (typeof index !== 'number' || !parent) return\n\n const link = create(\n node,\n extend(true, {}, props),\n toChildren(content, node)\n )\n let nodes = behavior === 'before' ? [link, node] : [node, link]\n\n if (group) {\n const grouping = toNode(group, node)\n\n if (grouping && !Array.isArray(grouping) && grouping.type === 'element') {\n grouping.children = nodes\n nodes = [grouping]\n }\n }\n\n parent.children.splice(index, 1, ...nodes)\n\n return [SKIP, index + nodes.length]\n }\n\n /** @type {import('unist-util-visit/complex-types').Visitor} */\n function wrap(node) {\n node.children = [create(node, extend(true, {}, props), node.children)]\n return [SKIP]\n }\n\n /**\n * @param {ElementChild|ElementChild[]|Build} value\n * @param {Element} node\n * @returns {ElementChild[]}\n */\n function toChildren(value, node) {\n const result = toNode(value, node)\n return Array.isArray(result) ? result : [result]\n }\n\n /**\n * @param {ElementChild|ElementChild[]|Build} value\n * @param {Element} node\n * @returns {ElementChild|ElementChild[]}\n */\n function toNode(value, node) {\n if (typeof value === 'function') return value(node)\n return extend(true, Array.isArray(value) ? [] : {}, value)\n }\n\n /**\n * @param {Element} node\n * @param {Properties} props\n * @param {ElementChild[]} children\n * @returns {Element}\n */\n function create(node, props, children) {\n return {\n type: 'element',\n tagName: 'a',\n properties: Object.assign({}, props, {\n // Fix hast types and make them required.\n /* c8 ignore next */\n href: '#' + (node.properties || {}).id\n }),\n children\n }\n }\n}\n","/**\n * @typedef {import('./core.js').HChild} Child Acceptable child value\n * @typedef {import('./core.js').HProperties} Properties Acceptable properties value.\n *\n * @typedef {import('./jsx-classic').Element} s.JSX.Element\n * @typedef {import('./jsx-classic').IntrinsicAttributes} s.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic').IntrinsicElements} s.JSX.IntrinsicElements\n * @typedef {import('./jsx-classic').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute\n */\n\nimport {svg} from 'property-information'\nimport {core} from './core.js'\nimport {svgCaseSensitiveTagNames} from './svg-case-sensitive-tag-names.js'\n\nexport const s = core(svg, 'g', svgCaseSensitiveTagNames)\n","export const svgCaseSensitiveTagNames = [\n 'altGlyph',\n 'altGlyphDef',\n 'altGlyphItem',\n 'animateColor',\n 'animateMotion',\n 'animateTransform',\n 'clipPath',\n 'feBlend',\n 'feColorMatrix',\n 'feComponentTransfer',\n 'feComposite',\n 'feConvolveMatrix',\n 'feDiffuseLighting',\n 'feDisplacementMap',\n 'feDistantLight',\n 'feDropShadow',\n 'feFlood',\n 'feFuncA',\n 'feFuncB',\n 'feFuncG',\n 'feFuncR',\n 'feGaussianBlur',\n 'feImage',\n 'feMerge',\n 'feMergeNode',\n 'feMorphology',\n 'feOffset',\n 'fePointLight',\n 'feSpecularLighting',\n 'feSpotLight',\n 'feTile',\n 'feTurbulence',\n 'foreignObject',\n 'glyphRef',\n 'linearGradient',\n 'radialGradient',\n 'solidColor',\n 'textArea',\n 'textPath'\n]\n","/**\n * Map of web namespaces.\n *\n * @type {Record}\n */\nexport const webNamespaces = {\n html: 'http://www.w3.org/1999/xhtml',\n mathml: 'http://www.w3.org/1998/Math/MathML',\n svg: 'http://www.w3.org/2000/svg',\n xlink: 'http://www.w3.org/1999/xlink',\n xml: 'http://www.w3.org/XML/1998/namespace',\n xmlns: 'http://www.w3.org/2000/xmlns/'\n}\n","/**\n * @typedef {import('vfile').VFile} VFile\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {Parent['children'][number]} Child\n * @typedef {Element['children'][number]} ElementChild\n * @typedef {Child|Root} Node\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentType} P5Doctype\n * @typedef {import('parse5').CommentNode} P5Comment\n * @typedef {import('parse5').TextNode} P5Text\n * @typedef {import('parse5').Element} P5Element\n * @typedef {import('parse5').ElementLocation} P5ElementLocation\n * @typedef {import('parse5').Location} P5Location\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {import('parse5').Node} P5Node\n *\n * @typedef {'html'|'svg'} Space\n *\n * @callback Handler\n * @param {Context} ctx\n * @param {P5Node} node\n * @param {Array.} [children]\n * @returns {Node}\n *\n * @typedef Options\n * @property {Space} [space='html'] Whether the root of the tree is in the `'html'` or `'svg'` space. If an element in with the SVG namespace is found in `ast`, `fromParse5` automatically switches to the SVG space when entering the element, and switches back when leaving\n * @property {VFile} [file] `VFile`, used to add positional information to nodes. If given, the file should have the original HTML source as its contents\n * @property {boolean} [verbose=false] Whether to add extra positional information about starting tags, closing tags, and attributes to elements. Note: not used without `file`\n *\n * @typedef Context\n * @property {Schema} schema\n * @property {VFile|undefined} file\n * @property {boolean|undefined} verbose\n * @property {boolean} location\n */\n\nimport {h, s} from 'hastscript'\nimport {html, svg, find} from 'property-information'\nimport {location} from 'vfile-location'\nimport {webNamespaces} from 'web-namespaces'\n\nconst own = {}.hasOwnProperty\n\n// Handlers.\nconst map = {\n '#document': root,\n '#document-fragment': root,\n '#text': text,\n '#comment': comment,\n '#documentType': doctype\n}\n\n/**\n * Transform Parse5’s AST to a hast tree.\n *\n * @param {P5Node} ast\n * @param {Options|VFile} [options]\n */\nexport function fromParse5(ast, options = {}) {\n /** @type {Options} */\n let settings\n /** @type {VFile|undefined} */\n let file\n\n if (isFile(options)) {\n file = options\n settings = {}\n } else {\n file = options.file\n settings = options\n }\n\n return transform(\n {\n schema: settings.space === 'svg' ? svg : html,\n file,\n verbose: settings.verbose,\n location: false\n },\n ast\n )\n}\n\n/**\n * Transform children.\n *\n * @param {Context} ctx\n * @param {P5Node} ast\n * @returns {Node}\n */\nfunction transform(ctx, ast) {\n const schema = ctx.schema\n /** @type {Handler} */\n // @ts-expect-error: index is fine.\n const fn = own.call(map, ast.nodeName) ? map[ast.nodeName] : element\n /** @type {Array.|undefined} */\n let children\n\n // Element.\n if ('tagName' in ast) {\n ctx.schema = ast.namespaceURI === webNamespaces.svg ? svg : html\n }\n\n if ('childNodes' in ast) {\n children = nodes(ctx, ast.childNodes)\n }\n\n const result = fn(ctx, ast, children)\n\n if ('sourceCodeLocation' in ast && ast.sourceCodeLocation && ctx.file) {\n // @ts-expect-error It’s fine.\n const position = createLocation(ctx, result, ast.sourceCodeLocation)\n\n if (position) {\n ctx.location = true\n result.position = position\n }\n }\n\n ctx.schema = schema\n\n return result\n}\n\n/**\n * Transform children.\n *\n * @param {Context} ctx\n * @param {Array.} children\n * @returns {Array.}\n */\nfunction nodes(ctx, children) {\n let index = -1\n /** @type {Array.} */\n const result = []\n\n while (++index < children.length) {\n // @ts-expect-error Assume no roots in children.\n result[index] = transform(ctx, children[index])\n }\n\n return result\n}\n\n/**\n * Transform a document.\n * Stores `ast.quirksMode` in `node.data.quirksMode`.\n *\n * @type {Handler}\n * @param {P5Document} ast\n * @param {Array.} children\n * @returns {Root}\n */\nfunction root(ctx, ast, children) {\n /** @type {Root} */\n const result = {\n type: 'root',\n children,\n data: {quirksMode: ast.mode === 'quirks' || ast.mode === 'limited-quirks'}\n }\n\n if (ctx.file && ctx.location) {\n const doc = String(ctx.file)\n const loc = location(doc)\n result.position = {\n start: loc.toPoint(0),\n end: loc.toPoint(doc.length)\n }\n }\n\n return result\n}\n\n/**\n * Transform a doctype.\n *\n * @type {Handler}\n * @returns {Doctype}\n */\nfunction doctype() {\n // @ts-expect-error Types are out of date.\n return {type: 'doctype'}\n}\n\n/**\n * Transform a text.\n *\n * @type {Handler}\n * @param {P5Text} ast\n * @returns {Text}\n */\nfunction text(_, ast) {\n return {type: 'text', value: ast.value}\n}\n\n/**\n * Transform a comment.\n *\n * @type {Handler}\n * @param {P5Comment} ast\n * @returns {Comment}\n */\nfunction comment(_, ast) {\n return {type: 'comment', value: ast.data}\n}\n\n/**\n * Transform an element.\n *\n * @type {Handler}\n * @param {P5Element} ast\n * @param {Array.} children\n * @returns {Element}\n */\nfunction element(ctx, ast, children) {\n const fn = ctx.schema.space === 'svg' ? s : h\n let index = -1\n /** @type {Object.} */\n const props = {}\n\n while (++index < ast.attrs.length) {\n const attribute = ast.attrs[index]\n props[(attribute.prefix ? attribute.prefix + ':' : '') + attribute.name] =\n attribute.value\n }\n\n const result = fn(ast.tagName, props, children)\n\n if (result.tagName === 'template' && 'content' in ast) {\n const pos = ast.sourceCodeLocation\n const startTag = pos && pos.startTag && position(pos.startTag)\n const endTag = pos && pos.endTag && position(pos.endTag)\n\n /** @type {Root} */\n // @ts-expect-error Types are wrong.\n const content = transform(ctx, ast.content)\n\n if (startTag && endTag && ctx.file) {\n content.position = {start: startTag.end, end: endTag.start}\n }\n\n result.content = content\n }\n\n return result\n}\n\n/**\n * Create clean positional information.\n *\n * @param {Context} ctx\n * @param {Node} node\n * @param {P5ElementLocation} location\n * @returns {Position|null}\n */\nfunction createLocation(ctx, node, location) {\n const result = position(location)\n\n if (node.type === 'element') {\n const tail = node.children[node.children.length - 1]\n\n // Bug for unclosed with children.\n // See: .\n if (\n result &&\n !location.endTag &&\n tail &&\n tail.position &&\n tail.position.end\n ) {\n result.end = Object.assign({}, tail.position.end)\n }\n\n if (ctx.verbose) {\n /** @type {Object.} */\n const props = {}\n /** @type {string} */\n let key\n\n for (key in location.attrs) {\n if (own.call(location.attrs, key)) {\n props[find(ctx.schema, key).property] = position(location.attrs[key])\n }\n }\n\n node.data = {\n position: {\n opening: position(location.startTag),\n closing: location.endTag ? position(location.endTag) : null,\n properties: props\n }\n }\n }\n }\n\n return result\n}\n\n/**\n * @param {P5Location} loc\n * @returns {Position|null}\n */\nfunction position(loc) {\n const start = point({\n line: loc.startLine,\n column: loc.startCol,\n offset: loc.startOffset\n })\n const end = point({\n line: loc.endLine,\n column: loc.endCol,\n offset: loc.endOffset\n })\n // @ts-expect-error `null` is fine.\n return start || end ? {start, end} : null\n}\n\n/**\n * @param {Point} point\n * @returns {Point|null}\n */\nfunction point(point) {\n return point.line && point.column ? point : null\n}\n\n/**\n * @param {VFile|Options} value\n * @returns {value is VFile}\n */\nfunction isFile(value) {\n return 'messages' in value\n}\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {Pick} PositionalPoint\n * @typedef {Required} FullPoint\n * @typedef {NonNullable} Offset\n */\n\n/**\n * Get transform functions for the given `document`.\n *\n * @param {string|Uint8Array|VFile} file\n */\nexport function location(file) {\n var value = String(file)\n /** @type {Array.} */\n var indices = []\n var search = /\\r?\\n|\\r/g\n\n while (search.test(value)) {\n indices.push(search.lastIndex)\n }\n\n indices.push(value.length + 1)\n\n return {toPoint, toOffset}\n\n /**\n * Get the line and column-based `point` for `offset` in the bound indices.\n * Returns a point with `undefined` values when given invalid or out of bounds\n * input.\n *\n * @param {Offset} offset\n * @returns {FullPoint}\n */\n function toPoint(offset) {\n var index = -1\n\n if (offset > -1 && offset < indices[indices.length - 1]) {\n while (++index < indices.length) {\n if (indices[index] > offset) {\n return {\n line: index + 1,\n column: offset - (indices[index - 1] || 0) + 1,\n offset\n }\n }\n }\n }\n\n return {line: undefined, column: undefined, offset: undefined}\n }\n\n /**\n * Get the `offset` for a line and column-based `point` in the bound indices.\n * Returns `-1` when given invalid or out of bounds input.\n *\n * @param {PositionalPoint} point\n * @returns {Offset}\n */\n function toOffset(point) {\n var line = point && point.line\n var column = point && point.column\n /** @type {number} */\n var offset\n\n if (\n typeof line === 'number' &&\n typeof column === 'number' &&\n !Number.isNaN(line) &&\n !Number.isNaN(column) &&\n line - 1 in indices\n ) {\n offset = (indices[line - 2] || 0) + column - 1 || 0\n }\n\n return offset > -1 && offset < indices[indices.length - 1] ? offset : -1\n }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('unist-util-is').AssertPredicate} AssertElement\n * @typedef {import('unist-util-is').AssertPredicate} AssertText\n * @typedef {import('unist-util-is').AssertPredicate} AssertRoot\n *\n * @callback CreateElementLike\n * @param {string} name\n * @param {any} attributes\n * @param {Array.} [children]\n * @returns {any}\n *\n * @typedef Context\n * @property {html|svg} schema\n * @property {string|null} prefix\n * @property {number} key\n * @property {boolean} react\n * @property {boolean} vue\n * @property {boolean} vdom\n * @property {boolean} hyperscript\n *\n * @typedef Options\n * @property {string|null} [prefix]\n * @property {'html'|'svg'} [space]\n */\n\nimport {html, svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\nimport {webNamespaces} from 'web-namespaces'\nimport {convert} from 'unist-util-is'\n\nconst ns = /** @type {Record} */ (webNamespaces)\nconst toReact = /** @type {Record} */ (hastToReact)\n\nconst own = {}.hasOwnProperty\n\n/** @type {AssertRoot} */\n// @ts-expect-error it’s correct.\nconst root = convert('root')\n/** @type {AssertElement} */\n// @ts-expect-error it’s correct.\nconst element = convert('element')\n/** @type {AssertText} */\n// @ts-expect-error it’s correct.\nconst text = convert('text')\n\n/**\n * @template {CreateElementLike} H\n * @param {H} h\n * @param {Element|Root} tree\n * @param {string|boolean|Options} [options]\n * @returns {ReturnType}\n */\nexport function toH(h, tree, options) {\n if (typeof h !== 'function') {\n throw new TypeError('h is not a function')\n }\n\n const r = react(h)\n const v = vue(h)\n const vd = vdom(h)\n /** @type {string|boolean|null|undefined} */\n let prefix\n /** @type {Element} */\n let node\n\n if (typeof options === 'string' || typeof options === 'boolean') {\n prefix = options\n options = {}\n } else {\n if (!options) options = {}\n prefix = options.prefix\n }\n\n if (root(tree)) {\n // @ts-expect-error Allow `doctypes` in there, we’ll filter them out later.\n node =\n tree.children.length === 1 && element(tree.children[0])\n ? tree.children[0]\n : {\n type: 'element',\n tagName: 'div',\n properties: {},\n children: tree.children\n }\n } else if (element(tree)) {\n node = tree\n } else {\n throw new Error(\n // @ts-expect-error runtime.\n 'Expected root or element, not `' + ((tree && tree.type) || tree) + '`'\n )\n }\n\n return transform(h, node, {\n schema: options.space === 'svg' ? svg : html,\n prefix:\n prefix === undefined || prefix === null\n ? r || v || vd\n ? 'h-'\n : null\n : typeof prefix === 'string'\n ? prefix\n : prefix\n ? 'h-'\n : null,\n key: 0,\n react: r,\n vue: v,\n vdom: vd,\n hyperscript: hyperscript(h)\n })\n}\n\n/**\n * Transform a hast node through a hyperscript interface to *anything*!\n *\n * @template {CreateElementLike} H\n * @param {H} h\n * @param {Element} node\n * @param {Context} ctx\n */\nfunction transform(h, node, ctx) {\n const parentSchema = ctx.schema\n let schema = parentSchema\n let name = node.tagName\n /** @type {Record} */\n const attributes = {}\n /** @type {Array.|string>} */\n const nodes = []\n let index = -1\n /** @type {string} */\n let key\n\n if (parentSchema.space === 'html' && name.toLowerCase() === 'svg') {\n schema = svg\n ctx.schema = schema\n }\n\n for (key in node.properties) {\n if (node.properties && own.call(node.properties, key)) {\n addAttribute(attributes, key, node.properties[key], ctx, name)\n }\n }\n\n if (ctx.vdom) {\n if (schema.space === 'html') {\n name = name.toUpperCase()\n } else if (schema.space) {\n attributes.namespace = ns[schema.space]\n }\n }\n\n if (ctx.prefix) {\n ctx.key++\n attributes.key = ctx.prefix + ctx.key\n }\n\n if (node.children) {\n while (++index < node.children.length) {\n const value = node.children[index]\n\n if (element(value)) {\n nodes.push(transform(h, value, ctx))\n } else if (text(value)) {\n nodes.push(value.value)\n }\n }\n }\n\n // Restore parent schema.\n ctx.schema = parentSchema\n\n // Ensure no React warnings are triggered for void elements having children\n // passed in.\n return nodes.length > 0\n ? h.call(node, name, attributes, nodes)\n : h.call(node, name, attributes)\n}\n\n/**\n * @param {Record} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n * @param {string} name\n */\n// eslint-disable-next-line complexity, max-params\nfunction addAttribute(props, prop, value, ctx, name) {\n const info = find(ctx.schema, prop)\n /** @type {string|undefined} */\n let subprop\n\n // Ignore nullish and `NaN` values.\n // Ignore `false` and falsey known booleans for hyperlike DSLs.\n if (\n value === undefined ||\n value === null ||\n (typeof value === 'number' && Number.isNaN(value)) ||\n (value === false && (ctx.vue || ctx.vdom || ctx.hyperscript)) ||\n (!value && info.boolean && (ctx.vue || ctx.vdom || ctx.hyperscript))\n ) {\n return\n }\n\n if (Array.isArray(value)) {\n // Accept `array`.\n // Most props are space-separated.\n value = info.commaSeparated ? commas(value) : spaces(value)\n }\n\n // Treat `true` and truthy known booleans.\n if (info.boolean && ctx.hyperscript) {\n value = ''\n }\n\n // VDOM, Vue, and React accept `style` as object.\n if (\n info.property === 'style' &&\n typeof value === 'string' &&\n (ctx.react || ctx.vue || ctx.vdom)\n ) {\n value = parseStyle(value, name)\n }\n\n if (ctx.vue) {\n if (info.property !== 'style') subprop = 'attrs'\n } else if (!info.mustUseProperty) {\n if (ctx.vdom) {\n if (info.property !== 'style') subprop = 'attributes'\n } else if (ctx.hyperscript) {\n subprop = 'attrs'\n }\n }\n\n if (subprop) {\n props[subprop] = Object.assign(props[subprop] || {}, {\n [info.attribute]: value\n })\n } else if (info.space && ctx.react) {\n props[toReact[info.property] || info.property] = value\n } else {\n props[info.attribute] = value\n }\n}\n\n/**\n * Check if `h` is `react.createElement`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction react(h) {\n /** @type {unknown} */\n const node = h('div', {})\n return Boolean(\n node &&\n // @ts-expect-error Looks like a React node.\n ('_owner' in node || '_store' in node) &&\n // @ts-expect-error Looks like a React node.\n (node.key === undefined || node.key === null)\n )\n}\n\n/**\n * Check if `h` is `hyperscript`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction hyperscript(h) {\n return 'context' in h && 'cleanup' in h\n}\n\n/**\n * Check if `h` is `virtual-dom/h`.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction vdom(h) {\n /** @type {unknown} */\n const node = h('div', {})\n // @ts-expect-error Looks like a vnode.\n return node.type === 'VirtualNode'\n}\n\n/**\n * Check if `h` is Vue.\n *\n * @param {CreateElementLike} h\n * @returns {boolean}\n */\nfunction vue(h) {\n /** @type {unknown} */\n const node = h('div', {})\n // @ts-expect-error Looks like a Vue node.\n return Boolean(node && node.context && node.context._isVue)\n}\n\n/**\n * @param {string} value\n * @param {string} tagName\n * @returns {Record}\n */\nfunction parseStyle(value, tagName) {\n /** @type {Record} */\n const result = {}\n\n try {\n style(value, (name, value) => {\n if (name.slice(0, 4) === '-ms-') name = 'ms-' + name.slice(4)\n\n result[\n name.replace(\n /-([a-z])/g,\n /**\n * @param {string} _\n * @param {string} $1\n * @returns {string}\n */ (_, $1) => $1.toUpperCase()\n )\n ] = value\n })\n } catch (error) {\n error.message =\n tagName + '[style]' + error.message.slice('undefined'.length)\n throw error\n }\n\n return result\n}\n","var own = {}.hasOwnProperty\n\n/**\n * @callback Handler\n * @param {...unknown} value\n * @return {unknown}\n *\n * @typedef {Record} Handlers\n *\n * @typedef {Object} Options\n * @property {Handler} [unknown]\n * @property {Handler} [invalid]\n * @property {Handlers} [handlers]\n */\n\n/**\n * Handle values based on a property.\n *\n * @param {string} key\n * @param {Options} [options]\n */\nexport function zwitch(key, options) {\n var settings = options || {}\n\n /**\n * Handle one value.\n * Based on the bound `key`, a respective handler will be called.\n * If `value` is not an object, or doesn’t have a `key` property, the special\n * “invalid” handler will be called.\n * If `value` has an unknown `key`, the special “unknown” handler will be\n * called.\n *\n * All arguments, and the context object, are passed through to the handler,\n * and it’s result is returned.\n *\n * @param {...unknown} [value]\n * @this {unknown}\n * @returns {unknown}\n * @property {Handler} invalid\n * @property {Handler} unknown\n * @property {Handlers} handlers\n */\n function one(value) {\n var fn = one.invalid\n var handlers = one.handlers\n\n if (value && own.call(value, key)) {\n fn = own.call(handlers, value[key]) ? handlers[value[key]] : one.unknown\n }\n\n if (fn) {\n return fn.apply(this, arguments)\n }\n }\n\n one.handlers = settings.handlers || {}\n one.invalid = settings.invalid\n one.unknown = settings.unknown\n\n return one\n}\n","/**\n * @typedef {import('parse5').Node} P5Node\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentFragment} P5Fragment\n * @typedef {import('parse5').DocumentType} P5Doctype\n * @typedef {import('parse5').CommentNode} P5Comment\n * @typedef {import('parse5').TextNode} P5Text\n * @typedef {import('parse5').Element} P5Element\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {import('parse5').ParentNode} P5Parent\n * @typedef {Exclude} P5Child\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('property-information').Info} Info\n * @typedef {'html'|'svg'} Space\n * @typedef {import('hast').Parent} Parent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {Parent['children'][number]} Child\n * @typedef {Child|Root} Node\n *\n * @callback Handle\n * @param {Node} node\n * @param {Schema} schema\n * @returns {P5Node}\n */\n\nimport {html, svg, find} from 'property-information'\nimport {toH} from 'hast-to-hyperscript'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\nvar own = {}.hasOwnProperty\n\nvar one = zwitch('type', {handlers: {root, element, text, comment, doctype}})\n\n/**\n * Transform a tree from hast to Parse5’s AST.\n *\n * @param {Node} tree\n * @param {Space} [space='html']\n * @returns {P5Node}\n */\nexport function toParse5(tree, space) {\n // @ts-ignore Types are wrong.\n return one(tree, space === 'svg' ? svg : html)\n}\n\n/**\n * @type {Handle}\n * @param {Root} node\n * @returns {P5Document}\n */\nfunction root(node, schema) {\n /** @type {P5Document} */\n var p5 = {\n nodeName: '#document',\n mode: (node.data || {}).quirksMode ? 'quirks' : 'no-quirks',\n childNodes: []\n }\n // @ts-ignore Assume correct children.\n p5.childNodes = all(node.children, p5, schema)\n return patch(node, p5)\n}\n\n/**\n * @type {Handle}\n * @param {Root} node\n * @returns {P5Fragment}\n */\nfunction fragment(node, schema) {\n /** @type {P5Fragment} */\n var p5 = {nodeName: '#document-fragment', childNodes: []}\n // @ts-ignore Assume correct children.\n p5.childNodes = all(node.children, p5, schema)\n return patch(node, p5)\n}\n\n/**\n * @type {Handle}\n * @param {Doctype} node\n * @returns {P5Doctype}\n */\nfunction doctype(node) {\n return patch(node, {\n nodeName: '#documentType',\n name: 'html',\n publicId: '',\n systemId: '',\n parentNode: undefined\n })\n}\n\n/**\n * @type {Handle}\n * @param {Text} node\n * @returns {P5Text}\n */\nfunction text(node) {\n return patch(node, {\n nodeName: '#text',\n value: node.value,\n parentNode: undefined\n })\n}\n\n/**\n * @type {Handle}\n * @param {Comment} node\n * @returns {P5Comment}\n */\nfunction comment(node) {\n return patch(node, {\n nodeName: '#comment',\n data: node.value,\n parentNode: undefined\n })\n}\n\n/**\n * @type {Handle}\n * @param {Element} node\n * @returns {P5Element}\n */\nfunction element(node, schema) {\n /** @type {Space} */\n // @ts-ignore Assume space.\n var space = schema.space\n return toH(h, Object.assign({}, node, {children: []}), {space})\n\n /**\n * @param {string} name\n * @param {Object.} attrs\n */\n function h(name, attrs) {\n /** @type {Array.} */\n var values = []\n /** @type {Info} */\n var info\n /** @type {P5Attribute} */\n var value\n /** @type {string} */\n var key\n /** @type {number} */\n var index\n /** @type {P5Element} */\n var p5\n\n for (key in attrs) {\n if (!own.call(attrs, key) || attrs[key] === false) {\n continue\n }\n\n info = find(schema, key)\n\n if (info.boolean && !attrs[key]) {\n continue\n }\n\n value = {name: key, value: attrs[key] === true ? '' : String(attrs[key])}\n\n if (info.space && info.space !== 'html' && info.space !== 'svg') {\n index = key.indexOf(':')\n\n if (index < 0) {\n value.prefix = ''\n } else {\n value.name = key.slice(index + 1)\n value.prefix = key.slice(0, index)\n }\n\n value.namespace = webNamespaces[info.space]\n }\n\n values.push(value)\n }\n\n if (schema.space === 'html' && node.tagName === 'svg') schema = svg\n\n p5 = patch(node, {\n nodeName: name,\n tagName: name,\n attrs: values,\n namespaceURI: webNamespaces[schema.space],\n childNodes: [],\n parentNode: undefined\n })\n\n // @ts-ignore Assume correct children.\n p5.childNodes = all(node.children, p5, schema)\n\n // @ts-ignore Types are wrong.\n if (name === 'template') p5.content = fragment(node.content, schema)\n\n return p5\n }\n}\n\n/**\n * @param {Array.} children\n * @param {P5Parent} p5\n * @param {Schema} schema\n * @returns {Array.}\n */\nfunction all(children, p5, schema) {\n var index = -1\n /** @type {Array.} */\n var result = []\n /** @type {P5Child} */\n var child\n\n if (children) {\n while (++index < children.length) {\n // @ts-ignore Assume child.\n child = one(children[index], schema)\n\n // @ts-ignore types are wrong.\n child.parentNode = p5\n\n result.push(child)\n }\n }\n\n return result\n}\n\n/**\n * Patch specific properties.\n *\n * @template {P5Node} T\n * @param {Node} node\n * @param {T} p5\n * @returns {T}\n */\nfunction patch(node, p5) {\n var position = node.position\n\n if (position && position.start && position.end) {\n // @ts-ignore Types are wrong.\n p5.sourceCodeLocation = {\n startLine: position.start.line,\n startCol: position.start.column,\n startOffset: position.start.offset,\n endLine: position.end.line,\n endCol: position.end.column,\n endOffset: position.end.offset\n }\n }\n\n return p5\n}\n","/**\n * List of HTML void tag names.\n *\n * @type {Array}\n */\nexport const htmlVoidElements = [\n 'area',\n 'base',\n 'basefont',\n 'bgsound',\n 'br',\n 'col',\n 'command',\n 'embed',\n 'frame',\n 'hr',\n 'image',\n 'img',\n 'input',\n 'isindex',\n 'keygen',\n 'link',\n 'menuitem',\n 'meta',\n 'nextid',\n 'param',\n 'source',\n 'track',\n 'wbr'\n]\n","/**\n * @typedef {import('vfile').VFile} VFile\n * @typedef {import('parse5').Document} P5Document\n * @typedef {import('parse5').DocumentFragment} P5Fragment\n * @typedef {Omit} P5Element\n * @typedef {import('parse5').Attribute} P5Attribute\n * @typedef {Omit & {startOffset: number|undefined, endOffset: number|undefined}} P5Location\n * @typedef {import('parse5').ParserOptions} P5ParserOptions\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {import('../complex-types').Raw} Raw\n *\n * @typedef {Omit & {value: {stitch: Node}}} Stitch\n *\n * @typedef Options\n * @property {Array} [passThrough]\n * List of custom hast node types to pass through (keep) in hast.\n * If the passed through nodes have children, those children are expected to\n * be hast and will be handled.\n *\n * @typedef HiddenTokenizer\n * @property {Array} __mixins\n * Way too simple, but works for us.\n * @property {HiddenPreprocessor} preprocessor\n * @property {(value: string) => void} write\n * @property {() => number} _consume\n * @property {Array} tokenQueue\n * @property {string} state\n * @property {string} returnState\n * @property {number} charRefCode\n * @property {Array} tempBuff\n * @property {Function} _flushCodePointsConsumedAsCharacterReference\n * @property {string} lastStartTagName\n * @property {number} consumedAfterSnapshot\n * @property {boolean} active\n * @property {HiddenToken|undefined} currentCharacterToken\n * @property {HiddenToken|undefined} currentToken\n * @property {unknown} currentAttr\n * @property {Function} NAMED_CHARACTER_REFERENCE_STATE\n * @property {Function} NUMERIC_CHARACTER_REFERENCE_END_STATE\n *\n * @typedef {Record & {location: P5Location}} HiddenToken\n *\n * @typedef HiddenPreprocessor\n * @property {string|undefined} html\n * @property {number} pos\n * @property {number} lastGapPos\n * @property {number} lastCharPos\n * @property {Array} gapStack\n * @property {boolean} skipNextNewLine\n * @property {boolean} lastChunkWritten\n * @property {boolean} endOfChunkHit\n *\n * @typedef HiddenLocationTracker\n * @property {P5Location|undefined} currentAttrLocation\n * @property {P5Location} ctLoc\n * @property {HiddenPosTracker} posTracker\n *\n * @typedef HiddenPosTracker\n * @property {boolean} isEol\n * @property {number} lineStartPos\n * @property {number} droppedBufferSize\n * @property {number} offset\n * @property {number} col\n * @property {number} line\n */\n\n// @ts-expect-error: untyped.\nimport Parser from 'parse5/lib/parser/index.js'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {visit} from 'unist-util-visit'\nimport {fromParse5} from 'hast-util-from-parse5'\nimport {toParse5} from 'hast-util-to-parse5'\nimport {htmlVoidElements} from 'html-void-elements'\nimport {webNamespaces} from 'web-namespaces'\nimport {zwitch} from 'zwitch'\n\nconst inTemplateMode = 'IN_TEMPLATE_MODE'\nconst dataState = 'DATA_STATE'\nconst characterToken = 'CHARACTER_TOKEN'\nconst startTagToken = 'START_TAG_TOKEN'\nconst endTagToken = 'END_TAG_TOKEN'\nconst commentToken = 'COMMENT_TOKEN'\nconst doctypeToken = 'DOCTYPE_TOKEN'\n\n/** @type {P5ParserOptions} */\nconst parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false}\n\n/**\n * Given a hast tree and an optional vfile (for positional info), return a new\n * parsed-again hast tree.\n *\n * @param tree\n * Original hast tree.\n * @param file\n * Virtual file for positional info, optional.\n * @param options\n * Configuration.\n */\nexport const raw =\n /**\n * @type {(\n * ((tree: Node, file: VFile|undefined, options?: Options) => Node) &\n * ((tree: Node, options?: Options) => Node)\n * )}\n */\n (\n /**\n * @param {Node} tree\n * @param {VFile} [file]\n * @param {Options} [options]\n */\n function (tree, file, options) {\n let index = -1\n const parser = new Parser(parseOptions)\n const one = zwitch('type', {\n // @ts-expect-error: hush.\n handlers: {root, element, text, comment, doctype, raw: handleRaw},\n // @ts-expect-error: hush.\n unknown\n })\n /** @type {boolean|undefined} */\n let stitches\n /** @type {HiddenTokenizer|undefined} */\n let tokenizer\n /** @type {HiddenPreprocessor|undefined} */\n let preprocessor\n /** @type {HiddenPosTracker|undefined} */\n let posTracker\n /** @type {HiddenLocationTracker|undefined} */\n let locationTracker\n\n if (isOptions(file)) {\n options = file\n file = undefined\n }\n\n if (options && options.passThrough) {\n while (++index < options.passThrough.length) {\n // @ts-expect-error: hush.\n one.handlers[options.passThrough[index]] = stitch\n }\n }\n\n const result = fromParse5(\n documentMode(tree) ? document() : fragment(),\n file\n )\n\n if (stitches) {\n visit(result, 'comment', (node, index, parent) => {\n const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node))\n if (stitch.value.stitch && parent !== null && index !== null) {\n // @ts-expect-error: assume the stitch is allowed.\n parent.children[index] = stitch.value.stitch\n return index\n }\n })\n }\n\n // Unpack if possible and when not given a `root`.\n if (\n tree.type !== 'root' &&\n result.type === 'root' &&\n result.children.length === 1\n ) {\n return result.children[0]\n }\n\n return result\n\n /**\n * @returns {P5Fragment}\n */\n function fragment() {\n /** @type {P5Element} */\n const context = {\n nodeName: 'template',\n tagName: 'template',\n attrs: [],\n namespaceURI: webNamespaces.html,\n childNodes: []\n }\n /** @type {P5Element} */\n const mock = {\n nodeName: 'documentmock',\n tagName: 'documentmock',\n attrs: [],\n namespaceURI: webNamespaces.html,\n childNodes: []\n }\n /** @type {P5Fragment} */\n const doc = {nodeName: '#document-fragment', childNodes: []}\n\n parser._bootstrap(mock, context)\n parser._pushTmplInsertionMode(inTemplateMode)\n parser._initTokenizerForFragmentParsing()\n parser._insertFakeRootElement()\n parser._resetInsertionMode()\n parser._findFormInFragmentContext()\n\n tokenizer = parser.tokenizer\n /* c8 ignore next */\n if (!tokenizer) throw new Error('Expected `tokenizer`')\n preprocessor = tokenizer.preprocessor\n locationTracker = tokenizer.__mixins[0]\n posTracker = locationTracker.posTracker\n\n one(tree)\n\n resetTokenizer()\n\n parser._adoptNodes(mock.childNodes[0], doc)\n\n return doc\n }\n\n /**\n * @returns {P5Document}\n */\n function document() {\n /** @type {P5Document} */\n const doc = parser.treeAdapter.createDocument()\n\n parser._bootstrap(doc, undefined)\n tokenizer = parser.tokenizer\n /* c8 ignore next */\n if (!tokenizer) throw new Error('Expected `tokenizer`')\n preprocessor = tokenizer.preprocessor\n locationTracker = tokenizer.__mixins[0]\n posTracker = locationTracker.posTracker\n\n one(tree)\n\n resetTokenizer()\n\n return doc\n }\n\n /**\n * @param {Array} nodes\n * @returns {void}\n */\n function all(nodes) {\n let index = -1\n\n /* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */\n if (nodes) {\n while (++index < nodes.length) {\n one(nodes[index])\n }\n }\n }\n\n /**\n * @param {Root} node\n * @returns {void}\n */\n function root(node) {\n all(node.children)\n }\n\n /**\n * @param {Element} node\n * @returns {void}\n */\n function element(node) {\n resetTokenizer()\n parser._processToken(startTag(node), webNamespaces.html)\n\n all(node.children)\n\n if (!htmlVoidElements.includes(node.tagName)) {\n resetTokenizer()\n parser._processToken(endTag(node))\n }\n }\n\n /**\n * @param {Text} node\n * @returns {void}\n */\n function text(node) {\n resetTokenizer()\n parser._processToken({\n type: characterToken,\n chars: node.value,\n location: createParse5Location(node)\n })\n }\n\n /**\n * @param {Doctype} node\n * @returns {void}\n */\n function doctype(node) {\n resetTokenizer()\n parser._processToken({\n type: doctypeToken,\n name: 'html',\n forceQuirks: false,\n publicId: '',\n systemId: '',\n location: createParse5Location(node)\n })\n }\n\n /**\n * @param {Comment|Stitch} node\n * @returns {void}\n */\n function comment(node) {\n resetTokenizer()\n parser._processToken({\n type: commentToken,\n data: node.value,\n location: createParse5Location(node)\n })\n }\n\n /**\n * @param {Raw} node\n * @returns {void}\n */\n function handleRaw(node) {\n const start = pointStart(node)\n const line = start.line || 1\n const column = start.column || 1\n const offset = start.offset || 0\n\n /* c8 ignore next 4 */\n if (!preprocessor) throw new Error('Expected `preprocessor`')\n if (!tokenizer) throw new Error('Expected `tokenizer`')\n if (!posTracker) throw new Error('Expected `posTracker`')\n if (!locationTracker) throw new Error('Expected `locationTracker`')\n\n // Reset preprocessor:\n // See: .\n preprocessor.html = undefined\n preprocessor.pos = -1\n preprocessor.lastGapPos = -1\n preprocessor.lastCharPos = -1\n preprocessor.gapStack = []\n preprocessor.skipNextNewLine = false\n preprocessor.lastChunkWritten = false\n preprocessor.endOfChunkHit = false\n\n // Reset preprocessor mixin:\n // See: .\n posTracker.isEol = false\n posTracker.lineStartPos = -column + 1 // Looks weird, but ensures we get correct positional info.\n posTracker.droppedBufferSize = offset\n posTracker.offset = 0\n posTracker.col = 1\n posTracker.line = line\n\n // Reset location tracker:\n // See: .\n locationTracker.currentAttrLocation = undefined\n locationTracker.ctLoc = createParse5Location(node)\n\n // See the code for `parse` and `parseFragment`:\n // See: .\n tokenizer.write(node.value)\n parser._runParsingLoop(null)\n\n // Character references hang, so if we ended there, we need to flush\n // those too.\n // We reset the preprocessor as if the document ends here.\n // Then one single call to the relevant state does the trick, parse5\n // consumes the whole token.\n if (\n tokenizer.state === 'NAMED_CHARACTER_REFERENCE_STATE' ||\n tokenizer.state === 'NUMERIC_CHARACTER_REFERENCE_END_STATE'\n ) {\n preprocessor.lastChunkWritten = true\n tokenizer[tokenizer.state](tokenizer._consume())\n }\n }\n\n /**\n * @param {Node} node\n */\n function stitch(node) {\n stitches = true\n\n /** @type {Node} */\n let clone\n\n // Recurse, because to somewhat handle `[]` (where `[]` denotes the\n // passed through node).\n if ('children' in node) {\n clone = {\n ...node,\n children: raw(\n {type: 'root', children: node.children},\n file,\n options\n // @ts-expect-error Assume a given parent yields a parent.\n ).children\n }\n } else {\n clone = {...node}\n }\n\n // Hack: `value` is supposed to be a string, but as none of the tools\n // (`parse5` or `hast-util-from-parse5`) looks at it, we can pass nodes\n // through.\n comment({type: 'comment', value: {stitch: clone}})\n }\n\n function resetTokenizer() {\n /* c8 ignore next 2 */\n if (!tokenizer) throw new Error('Expected `tokenizer`')\n if (!posTracker) throw new Error('Expected `posTracker`')\n\n // Process final characters if they’re still there after hibernating.\n // Similar to:\n // See: .\n const token = tokenizer.currentCharacterToken\n\n if (token) {\n token.location.endLine = posTracker.line\n token.location.endCol = posTracker.col + 1\n token.location.endOffset = posTracker.offset + 1\n parser._processToken(token)\n }\n\n // Reset tokenizer:\n // See: .\n // Especially putting it back in the `data` state is useful: some elements,\n // like textareas and iframes, change the state.\n // See GH-7.\n // But also if broken HTML is in `raw`, and then a correct element is given.\n // See GH-11.\n tokenizer.tokenQueue = []\n tokenizer.state = dataState\n tokenizer.returnState = ''\n tokenizer.charRefCode = -1\n tokenizer.tempBuff = []\n tokenizer.lastStartTagName = ''\n tokenizer.consumedAfterSnapshot = -1\n tokenizer.active = false\n tokenizer.currentCharacterToken = undefined\n tokenizer.currentToken = undefined\n tokenizer.currentAttr = undefined\n }\n }\n )\n/**\n * @param {Element} node\n * @returns {HiddenToken}\n */\nfunction startTag(node) {\n /** @type {P5Location} */\n const location = Object.assign(createParse5Location(node))\n // @ts-expect-error extra positional info.\n location.startTag = Object.assign({}, location)\n\n // Untyped token.\n return {\n type: startTagToken,\n tagName: node.tagName,\n selfClosing: false,\n attrs: attributes(node),\n location\n }\n}\n\n/**\n * @param {Element} node\n * @returns {Array}\n */\nfunction attributes(node) {\n return toParse5({\n tagName: node.tagName,\n type: 'element',\n properties: node.properties,\n children: []\n // @ts-expect-error Assume element.\n }).attrs\n}\n\n/**\n * @param {Element} node\n * @returns {HiddenToken}\n */\nfunction endTag(node) {\n /** @type {P5Location} */\n const location = Object.assign(createParse5Location(node))\n // @ts-expect-error extra positional info.\n location.startTag = Object.assign({}, location)\n\n // Untyped token.\n return {\n type: endTagToken,\n tagName: node.tagName,\n attrs: [],\n location\n }\n}\n\n/**\n * @param {Node} node\n */\nfunction unknown(node) {\n throw new Error('Cannot compile `' + node.type + '` node')\n}\n\n/**\n * @param {Node} node\n * @returns {boolean}\n */\nfunction documentMode(node) {\n const head = node.type === 'root' ? node.children[0] : node\n return Boolean(\n head &&\n (head.type === 'doctype' ||\n (head.type === 'element' && head.tagName === 'html'))\n )\n}\n\n/**\n * @param {Node|Stitch} node\n * @returns {P5Location}\n */\nfunction createParse5Location(node) {\n const start = pointStart(node)\n const end = pointEnd(node)\n\n return {\n startLine: start.line,\n startCol: start.column,\n startOffset: start.offset,\n endLine: end.line,\n endCol: end.column,\n endOffset: end.offset\n }\n}\n\n/**\n * @param {VFile|Options|undefined} value\n * @return {value is Options}\n */\nfunction isOptions(value) {\n return Boolean(value && !('message' in value && 'messages' in value))\n}\n","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-raw').Options} Options\n * @typedef {import('hast-util-raw')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {raw} from 'hast-util-raw'\n\n/**\n * Plugin to parse the tree again (and raw nodes).\n * Keeping positional info OK. 🙌\n *\n * @type {import('unified').Plugin<[Options?] | Array, Root>}\n */\nexport default function rehypeRaw(options = {}) {\n return (tree, file) => {\n // Assume that when a root was given, it’s also returned.\n const result = /** @type {Root} */ (raw(tree, file, options))\n return result\n }\n}\n","import { Element, Comment, Literal, ElementContent, RootContent, Properties } from 'hast';\nimport { RehypeAttrsOptions } from './';\n\nexport const getURLParameters = (url: string): Record =>\n(url.match(/([^?=&]+)(=([^&]*))/g) || []).reduce(\n (a: Record, v: string) => (\n (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1)), a\n ),\n {},\n);\n\nexport const prevChild = (data: Literal[] = [], index: number): Comment | undefined => {\n let i = index;\n while (i > -1) {\n i--;\n if (!data[i]) return\n if ((data[i] && data[i].value && (data[i].value as string).replace(/(\\n|\\s)/g, '') !== '') || data[i].type !== 'text') {\n if (!/^rehype:/.test(data[i].value as string) || (data[i].type as string) !== 'comment') return;\n return data[i] as unknown as Comment;\n }\n }\n return;\n}\n\nexport const nextChild = (data: RootContent[] | ElementContent[] = [], index: number, tagName?: string): ElementContent | undefined => {\n let i = index;\n while (i < data.length) {\n i++;\n if (tagName) {\n const element = data[i] as Literal & Element;\n if (element && element.value && (element.value as string).replace(/(\\n|\\s)/g, '') !== '' || data[i] && (data[i].type as string) === 'element') {\n return element.tagName === tagName ? element : undefined\n }\n } else {\n const element = data[i] as ElementContent & Literal;\n if (!element || (element.type !== 'text' && (element.type as string) !== 'comment') || (element.type === 'text' && (element.value as string).replace(/(\\n|\\s)/g, '') !== '')) return;\n if ((element.type as string) === 'comment') {\n if (!/^rehype:/.test(element.value as string)) return;\n const nextNode = nextChild(data, i, 'pre')\n if (nextNode) return;\n return element;\n }\n }\n }\n return\n}\n\n/**\n * 获取代码注视的位置\n * @param data 数据\n * @param index 当前数据所在的位置\n * @returns 返回 当前参数数据 Object,`{}`\n */\nexport const getCommentObject = ({ value = '' }: Comment): Properties => {\n const param = getURLParameters(value.replace(/^rehype:/, ''));\n Object.keys(param).forEach((keyName: string) => {\n if (param[keyName] === 'true') {\n param[keyName] = true;\n }\n if (param[keyName] === 'false') {\n param[keyName] = false;\n }\n if (typeof param[keyName] === 'string' && !/^0/.test(param[keyName] as string) && !isNaN(+param[keyName])) {\n param[keyName] = +param[keyName];\n }\n })\n return param;\n}\n\nexport type DataConfig = {\n 'data-config': Properties\n}\n\nexport const propertiesHandle = (defaultAttrs?: Properties | null, attrs?: Properties, type?: RehypeAttrsOptions['properties']): Properties | DataConfig => {\n if (type === 'string') {\n return { ...defaultAttrs, 'data-config': JSON.stringify({ ...attrs, rehyp: true })}\n } else if (type === 'attr') {\n return { ...defaultAttrs, ...attrs}\n }\n return { ...defaultAttrs, 'data-config': { ...attrs, rehyp: true }}\n}","import { Plugin } from 'unified';\nimport { Root, Element, Comment, Properties, Literal } from 'hast';\nimport { visit } from 'unist-util-visit';\nimport { propertiesHandle, nextChild, prevChild, getCommentObject } from './utils';\n\nexport type RehypeAttrsOptions = {\n /**\n * ## `data`\n * \n * ```markdown\n * text\n * \n * ```\n * \n * ⇣⇣⇣⇣⇣⇣\n * \n * ```html\n *

text

\n * ```\n * \n * ## `string`\n * \n * ```markdown\n * text\n * \n * ```\n * \n * ⇣⇣⇣⇣⇣⇣\n * \n * ```html\n *

text

\n * ```\n * \n * ## attr\n * \n * ```markdown\n * text\n * \n * ```\n * ⇣⇣⇣⇣⇣⇣\n * ```html\n *

text

\n * ```\n */\n properties: 'data' | 'string' | 'attr';\n}\n\nconst defaultOptions: RehypeAttrsOptions = {\n properties: 'data',\n}\n\nconst rehypeAttrs: Plugin<[RehypeAttrsOptions?], Root> = (options) => {\n const opts = { ...defaultOptions, ...options }\n return (tree) => {\n visit(tree, 'element', (node, index, parent) => {\n if (node.tagName === 'pre' && node && Array.isArray(node.children) && parent && Array.isArray(parent.children) && parent.children.length > 1) {\n const firstChild = node.children[0] as Element;\n if (firstChild && firstChild.tagName === 'code' && typeof index === 'number') {\n const child = prevChild(parent.children as Literal[], index);\n if (child) {\n const attr = getCommentObject(child);\n if (Object.keys(attr).length > 0) {\n node.properties = { ...node.properties, ...{ 'data-type': 'rehyp' } }\n firstChild.properties = propertiesHandle(firstChild.properties, attr, opts.properties) as Properties\n }\n }\n }\n }\n\n if (/^(em|strong|b|a|i|p|pre|kbd|blockquote|h(1|2|3|4|5|6)|code|table|img|del|ul|ol)$/.test(node.tagName) && parent && Array.isArray(parent.children) && typeof index === 'number') {\n const child = nextChild(parent.children, index)\n if (child) {\n const attr = getCommentObject(child as Comment)\n if (Object.keys(attr).length > 0) {\n node.properties = propertiesHandle(node.properties, attr, opts.properties) as Properties\n }\n }\n }\n });\n }\n}\n\n\nexport default rehypeAttrs\n","import { Plugin } from 'unified';\nimport { Root, RootContent } from 'hast';\nimport { visit } from 'unist-util-visit';\n\nexport type RehypeIgnoreOptions = {\n /**\n * Character to use for opening delimiter, by default `rehype:ignore:start`\n */\n openDelimiter?: string;\n /**\n * Character to use for closing delimiter, by default `rehype:ignore:end`\n */\n closeDelimiter?: string;\n}\n\nconst rehypeIgnore: Plugin<[RehypeIgnoreOptions?], Root> = (options = {}) => {\n const { openDelimiter = 'rehype:ignore:start', closeDelimiter = 'rehype:ignore:end' } = options;\n return (tree) => {\n visit(tree, (node: Root | RootContent, index, parent) => {\n if (node.type === 'element' || node.type === 'root') {\n // const start = node.children.findIndex((item) => item.type === 'comment' && item.value === openDelimiter);\n // const end = node.children.findIndex((item) => item.type === 'comment' && item.value === closeDelimiter);\n // if (start > -1 && end > -1) {\n // node.children = node.children.filter((_, idx) => idx < start || idx > end);\n // }\n let start = false;\n node.children = node.children.filter((item) => {\n if (item.type === 'comment' && item.value.trim() === openDelimiter) {\n start = true;\n return false\n }\n if (item.type === 'comment' && item.value.trim() === closeDelimiter) {\n start = false;\n return false\n }\n \n return !start;\n })\n }\n });\n }\n}\n\nexport default rehypeIgnore;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n */\n\n/**\n * Options for unist util filter\n *\n * @typedef {Object} FilterOptions\n * @property {boolean} [cascade=true] Whether to drop parent nodes if they had children, but all their children were filtered out.\n */\n\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Create a new tree consisting of copies of all nodes that pass test.\n * The tree is walked in preorder (NLR), visiting the node itself, then its head, etc.\n *\n * @param tree Tree to filter.\n * @param options Configuration (optional).\n * @param test is-compatible test (such as a type).\n * @returns Given `tree` or `null` if it didn’t pass `test`.\n */\nexport const filter =\n /**\n * @type {(\n * ((node: Tree, options: FilterOptions, test: Check) => import('./complex-types').Matches) &\n * ((node: Tree, test: Check) => import('./complex-types').Matches) &\n * ((node: Tree, options?: FilterOptions) => Tree)\n * )}\n */\n (\n /**\n * @param {Node} tree\n * @param {FilterOptions} options\n * @param {Test} test\n * @returns {Node|null}\n */\n function (tree, options, test) {\n const is = convert(test || options)\n const cascade =\n options.cascade === undefined || options.cascade === null\n ? true\n : options.cascade\n\n return preorder(tree)\n\n /**\n * @param {Node} node\n * @param {number|undefined} [index]\n * @param {Parent|undefined} [parent]\n * @returns {Node|null}\n */\n function preorder(node, index, parent) {\n /** @type {Array.} */\n const children = []\n /** @type {number} */\n let childIndex\n /** @type {Node} */\n let result\n /** @type {string} */\n let key\n\n if (!is(node, index, parent)) return null\n\n // @ts-expect-error: Looks like a parent.\n if (node.children) {\n childIndex = -1\n\n // @ts-expect-error Looks like a parent.\n while (++childIndex < node.children.length) {\n // @ts-expect-error Looks like a parent.\n result = preorder(node.children[childIndex], childIndex, node)\n\n if (result) {\n children.push(result)\n }\n }\n\n // @ts-expect-error Looks like a parent.\n if (cascade && node.children.length > 0 && children.length === 0)\n return null\n }\n\n // Create a shallow clone, using the new children.\n /** @type {typeof node} */\n // @ts-expect-error all the fields will be copied over.\n const next = {}\n\n for (key in node) {\n if (own.call(node, key)) {\n // @ts-expect-error: Looks like a record.\n next[key] = key === 'children' ? children : node[key]\n }\n }\n\n return next\n }\n }\n )\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef Options options\n * Configuration.\n * @property {boolean} [showLineNumbers]\n * Set `showLineNumbers` to `true` to always display line number\n * @property {boolean} [ignoreMissing]\n * Set `ignoreMissing` to `true` to ignore unsupported languages and line highlighting when no language is specified\n */\n\nimport { visit } from 'unist-util-visit'\nimport { toString } from 'hast-util-to-string'\nimport { filter } from 'unist-util-filter'\nimport rangeParser from 'parse-numeric-range'\n\n/**\n * @param {Element} node\n * @return {string|null}\n */\nconst getLanguage = (node) => {\n const className = node.properties.className\n //@ts-ignore\n for (const classListItem of className) {\n if (classListItem.slice(0, 9) === 'language-') {\n return classListItem.slice(9).toLowerCase()\n }\n }\n return null\n}\n\n/**\n * Create a closure that determines if we have to highlight the given index\n *\n * @param {string} meta\n * @return { (index:number) => boolean }\n */\nconst calculateLinesToHighlight = (meta) => {\n const RE = /{([\\d,-]+)}/\n // Remove space between {} e.g. {1, 3}\n const parsedMeta = meta\n .split(',')\n .map((str) => str.trim())\n .join()\n if (RE.test(parsedMeta)) {\n const strlineNumbers = RE.exec(parsedMeta)[1]\n const lineNumbers = rangeParser(strlineNumbers)\n return (index) => lineNumbers.includes(index + 1)\n } else {\n return () => false\n }\n}\n\n/**\n * Check if we want to start the line numbering from a given number or 1\n * showLineNumbers=5, will start the numbering from 5\n * @param {string} meta\n * @returns {number}\n */\nconst calculateStartingLine = (meta) => {\n const RE = /showLineNumbers=(?\\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: 0 is to make the ts compiler happy but we do not use this field\n start: { line: startLineNum, column: 0 },\n end: { line: startLineNum, column: 0 },\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 },\n end: { line: startLineNum + i },\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: 0 },\n end: { line: startLineNum, column: 0 },\n }\n return result\n }\n\n result.push(node)\n return result\n }, [])\n }\n return addNodePosition\n}\n\n/**\n * Rehype prism plugin generator that highlights code blocks with refractor (prismjs)\n *\n * Pass in your own refractor object with the required languages registered:\n * https://github.com/wooorm/refractor#refractorregistersyntax\n *\n * @param {import('refractor/lib/core').Refractor} refractor\n * @return {import('unified').Plugin<[Options?], Root>}\n */\nconst rehypePrismGenerator = (refractor) => {\n return (options = {}) => {\n return (tree) => {\n visit(tree, 'element', visitor)\n }\n\n /**\n * @param {Element} node\n * @param {number} index\n * @param {Element} parent\n */\n function visitor(node, index, parent) {\n if (!parent || parent.tagName !== 'pre' || node.tagName !== 'code') {\n return\n }\n\n let meta = node.data && node.data.meta ? /** @type {string} */ (node.data.meta) : ''\n // Coerce className to array\n if (node.properties.className) {\n if (typeof node.properties.className === 'boolean') {\n node.properties.className = []\n } else if (!Array.isArray(node.properties.className)) {\n node.properties.className = [node.properties.className]\n }\n } else {\n node.properties.className = []\n }\n node.properties.className.push('code-highlight')\n const lang = getLanguage(node)\n\n /** @type {Element} */\n let refractorRoot\n\n // Syntax highlight\n if (lang) {\n try {\n // @ts-ignore\n refractorRoot = refractor.highlight(toString(node), lang)\n // @ts-ignore className is already an array\n parent.properties.className = (parent.properties.className || []).concat(\n 'language-' + lang\n )\n } catch (err) {\n if (options.ignoreMissing && /Unknown language/.test(err.message)) {\n refractorRoot = node\n } else {\n throw err\n }\n }\n } else {\n refractorRoot = node\n }\n\n refractorRoot.children = addNodePositionClosure()(refractorRoot.children)\n\n // Add position info to root\n if (refractorRoot.children.length > 0) {\n refractorRoot.position = {\n start: { line: refractorRoot.children[0].position.start.line, column: 0 },\n end: {\n line: refractorRoot.children[refractorRoot.children.length - 1].position.end.line,\n column: 0,\n },\n }\n } else {\n refractorRoot.position = {\n start: { line: 0, column: 0 },\n end: { line: 0, column: 0 },\n }\n }\n\n const shouldHighlightLine = calculateLinesToHighlight(meta)\n const startingLineNumber = calculateStartingLine(meta)\n const codeLineArray = createLineNodes(refractorRoot.position.end.line)\n\n const falseShowLineNumbersStr = [\n 'showlinenumbers=false',\n 'showlinenumbers=\"false\"',\n 'showlinenumbers={false}',\n ]\n for (const [i, line] of codeLineArray.entries()) {\n // Default class name for each line\n line.properties.className = ['code-line']\n\n // Syntax highlight\n const treeExtract = filter(\n refractorRoot,\n (node) => node.position.start.line <= i + 1 && node.position.end.line >= i + 1\n )\n line.children = treeExtract.children\n\n // Line number\n if (\n (meta.toLowerCase().includes('showLineNumbers'.toLowerCase()) ||\n options.showLineNumbers) &&\n !falseShowLineNumbersStr.some((str) => meta.toLowerCase().includes(str))\n ) {\n line.properties.line = [(i + startingLineNumber).toString()]\n line.properties.className.push('line-number')\n }\n\n // Line highlight\n if (shouldHighlightLine(i)) {\n line.properties.className.push('highlight-line')\n }\n\n // Diff classes\n if (lang === 'diff' && toString(line).substring(0, 1) === '-') {\n line.properties.className.push('deleted')\n } else if (lang === 'diff' && toString(line).substring(0, 1) === '+') {\n line.properties.className.push('inserted')\n }\n }\n\n // Remove possible trailing line when splitting by \\n which results in empty array\n if (\n codeLineArray.length > 0 &&\n toString(codeLineArray[codeLineArray.length - 1]).trim() === ''\n ) {\n codeLineArray.pop()\n }\n\n node.children = codeLineArray\n }\n }\n}\n\nexport default rehypePrismGenerator\n","import { refractor as refractorAll } from 'refractor/lib/all.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * This supports all the languages and should be used on the server side.\n *\n * Consider using rehypePrismCommon or rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismAll = rehypePrismGenerator(refractorAll)\n\nexport default rehypePrismAll\n","import { refractor as refractorCommon } from 'refractor/lib/common.js'\nimport rehypePrismGenerator from './generator.js'\n\n/**\n * Rehype prism plugin that highlights code blocks with refractor (prismjs)\n * Supported languages: https://github.com/wooorm/refractor#data\n *\n * Consider using rehypePrismGenerator to generate a plugin\n * that supports your required languages.\n */\nconst rehypePrismCommon = rehypePrismGenerator(refractorCommon)\n\nexport default rehypePrismCommon\n","const rtlRange = '\\u0591-\\u07FF\\uFB1D-\\uFDFD\\uFE70-\\uFEFC'\nconst ltrRange =\n 'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6' +\n '\\u00F8-\\u02B8\\u0300-\\u0590\\u0800-\\u1FFF\\u200E\\u2C00-\\uFB1C' +\n '\\uFE00-\\uFE6F\\uFEFD-\\uFFFF'\n\n/* eslint-disable no-misleading-character-class */\nconst rtl = new RegExp('^[^' + ltrRange + ']*[' + rtlRange + ']')\nconst ltr = new RegExp('^[^' + rtlRange + ']*[' + ltrRange + ']')\n/* eslint-enable no-misleading-character-class */\n\n/**\n * Detect the direction of text: left-to-right, right-to-left, or neutral\n *\n * @param {string} value\n * @returns {'rtl'|'ltr'|'neutral'}\n */\nexport function direction(value) {\n const source = String(value || '')\n return rtl.test(source) ? 'rtl' : ltr.test(source) ? 'ltr' : 'neutral'\n}\n","/**\n * @typedef {import('./types.js').Node} Node\n * @typedef {import('./types.js').Element} Element\n * @typedef {import('./types.js').Parent} Parent\n * @typedef {import('hast-util-is-element').AssertPredicate} IsElement\n */\n\nimport {convertElement} from 'hast-util-is-element'\n\n/**\n * @param {Node} node\n * @returns {node is Parent}\n */\nexport function parent(node) {\n // @ts-expect-error: hush.\n return Array.isArray(node.children)\n}\n\n/** @type {IsElement} */\n// @ts-expect-error it works.\nexport const element = convertElement()\n","/**\n * @typedef {import('./types.js').SelectState} SelectState\n * @typedef {import('./types.js').HastNode} HastNode\n * @typedef {import('./types.js').ElementChild} ElementChild\n * @typedef {import('./types.js').Direction} Direction\n * @typedef {import('unist-util-visit/complex-types').Visitor} Visitor\n */\n\nimport {direction} from 'direction'\nimport {isElement} from 'hast-util-is-element'\nimport {toString} from 'hast-util-to-string'\nimport {svg} from 'property-information'\nimport {visit, EXIT, SKIP} from 'unist-util-visit'\nimport {element} from './util.js'\n\n/**\n * @param {SelectState} state\n * @param {HastNode} node\n * @returns {() => void}\n */\n// eslint-disable-next-line complexity\nexport function enterState(state, node) {\n const schema = state.schema\n const language = state.language\n const currentDirection = state.direction\n const editableOrEditingHost = state.editableOrEditingHost\n /** @type {Direction|undefined} */\n let dirInferred\n /** @type {boolean|undefined} */\n let found\n\n if (element(node) && node.properties) {\n const lang = node.properties.xmlLang || node.properties.lang\n const type = node.properties.type || 'text'\n const dir = dirProperty(node)\n\n if (lang !== undefined && lang !== null) {\n state.language = String(lang)\n found = true\n }\n\n if (schema && schema.space === 'html') {\n if (node.properties.contentEditable === 'true') {\n state.editableOrEditingHost = true\n found = true\n }\n\n if (isElement(node, 'svg')) {\n state.schema = svg\n found = true\n }\n\n // See: .\n // Explicit `[dir=rtl]`.\n if (dir === 'rtl') {\n dirInferred = dir\n } else if (\n // Explicit `[dir=ltr]`.\n dir === 'ltr' ||\n // HTML with an invalid or no `[dir]`.\n (dir !== 'auto' && isElement(node, 'html')) ||\n // `input[type=tel]` with an invalid or no `[dir]`.\n (dir !== 'auto' && isElement(node, 'input') && type === 'tel')\n ) {\n dirInferred = 'ltr'\n // `[dir=auto]` or `bdi` with an invalid or no `[dir]`.\n } else if (dir === 'auto' || isElement(node, 'bdi')) {\n if (isElement(node, 'textarea')) {\n // Check contents of `