npm - markdown-flow-ui - Versions diffs - 0.1.70 → 0.1.71-beta.0 - Mend

markdown-flow-ui 0.1.70 → 0.1.71-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (378) hide show

package/dist/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js"],"sourcesContent":["/**\n * @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiControl, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\nconst wwwPrefix = {\n tokenize: tokenizeWwwPrefix,\n partial: true\n};\nconst domain = {\n tokenize: tokenizeDomain,\n partial: true\n};\nconst path = {\n tokenize: tokenizePath,\n partial: true\n};\nconst trail = {\n tokenize: tokenizeTrail,\n partial: true\n};\nconst emailDomainDotTrail = {\n tokenize: tokenizeEmailDomainDotTrail,\n partial: true\n};\nconst wwwAutolink = {\n name: 'wwwAutolink',\n tokenize: tokenizeWwwAutolink,\n previous: previousWww\n};\nconst protocolAutolink = {\n name: 'protocolAutolink',\n tokenize: tokenizeProtocolAutolink,\n previous: previousProtocol\n};\nconst emailAutolink = {\n name: 'emailAutolink',\n tokenize: tokenizeEmailAutolink,\n previous: previousEmail\n};\n\n/** @type {ConstructRecord} */\nconst text = {};\n\n/**\n * Create an extension for `micromark` to support GitHub autolink literal\n * syntax.\n *\n * @returns {Extension}\n * Extension for `micromark` that can be passed in `extensions` to enable GFM\n * autolink literal syntax.\n */\nexport function gfmAutolinkLiteral() {\n return {\n text\n };\n}\n\n/** @type {Code} */\nlet code = 48;\n\n// Add alphanumerics.\nwhile (code < 123) {\n text[code] = emailAutolink;\n code++;\n if (code === 58) code = 65;else if (code === 91) code = 97;\n}\ntext[43] = emailAutolink;\ntext[45] = emailAutolink;\ntext[46] = emailAutolink;\ntext[95] = emailAutolink;\ntext[72] = [emailAutolink, protocolAutolink];\ntext[104] = [emailAutolink, protocolAutolink];\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n * ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n const self = this;\n /** @type {boolean | undefined} */\n let dot;\n /** @type {boolean} */\n let data;\n return start;\n\n /**\n * Start of email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n * ^\n * ```\n *\n * @type {State}\n */\n function start(code) {\n if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {\n return nok(code);\n }\n effects.enter('literalAutolink');\n effects.enter('literalAutolinkEmail');\n return atext(code);\n }\n\n /**\n * In email atext.\n *\n * ```markdown\n * > | a contact@example.org b\n * ^\n * ```\n *\n * @type {State}\n */\n function atext(code) {\n if (gfmAtext(code)) {\n effects.consume(code);\n return atext;\n }\n if (code === 64) {\n effects.consume(code);\n return emailDomain;\n }\n return nok(code);\n }\n\n /**\n * In email domain.\n *\n * The reference code is a bit overly complex as it handles the `@`, of which\n * there may be just one.\n * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n *\n * ```markdown\n * > | a contact@example.org b\n * ^\n * ```\n *\n * @type {State}\n */\n function emailDomain(code) {\n // Dot followed by alphanumerical (not `-` or `_`).\n if (code === 46) {\n return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);\n }\n\n // Alphanumerical, `-`, and `_`.\n if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n data = true;\n effects.consume(code);\n return emailDomain;\n }\n\n // To do: `/` if xmpp.\n\n // Note: normally we’d truncate trailing punctuation from the link.\n // However, email autolink literals cannot contain any of those markers,\n // except for `.`, but that can only occur if it isn’t trailing.\n // So we can ignore truncating!\n return emailDomainAfter(code);\n }\n\n /**\n * In email domain, on dot that is not a trail.\n *\n * ```markdown\n * > | a contact@example.org b\n * ^\n * ```\n *\n * @type {State}\n */\n function emailDomainDot(code) {\n effects.consume(code);\n dot = true;\n return emailDomain;\n }\n\n /**\n * After email domain.\n *\n * ```markdown\n * > | a contact@example.org b\n * ^\n * ```\n *\n * @type {State}\n */\n function emailDomainAfter(code) {\n // Domain must not be empty, must include a dot, and must end in alphabetical.\n // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n if (data && dot && asciiAlpha(self.previous)) {\n effects.exit('literalAutolinkEmail');\n effects.exit('literalAutolink');\n return ok(code);\n }\n return nok(code);\n }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n * ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n const self = this;\n return wwwStart;\n\n /**\n * Start of www autolink literal.\n *\n * ```markdown\n * > | www.example.com/a?b#c\n * ^\n * ```\n *\n * @type {State}\n */\n function wwwStart(code) {\n if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {\n return nok(code);\n }\n effects.enter('literalAutolink');\n effects.enter('literalAutolinkWww');\n // Note: we *check*, so we can discard the `www.` we parsed.\n // If it worked, we consider it as a part of the domain.\n return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);\n }\n\n /**\n * After a www autolink literal.\n *\n * ```markdown\n * > | www.example.com/a?b#c\n * ^\n * ```\n *\n * @type {State}\n */\n function wwwAfter(code) {\n effects.exit('literalAutolinkWww');\n effects.exit('literalAutolink');\n return ok(code);\n }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n * ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n const self = this;\n let buffer = '';\n let seen = false;\n return protocolStart;\n\n /**\n * Start of protocol autolink literal.\n *\n * ```markdown\n * > | https://example.com/a?b#c\n * ^\n * ```\n *\n * @type {State}\n */\n function protocolStart(code) {\n if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {\n effects.enter('literalAutolink');\n effects.enter('literalAutolinkHttp');\n buffer += String.fromCodePoint(code);\n effects.consume(code);\n return protocolPrefixInside;\n }\n return nok(code);\n }\n\n /**\n * In protocol.\n *\n * ```markdown\n * > | https://example.com/a?b#c\n * ^^^^^\n * ```\n *\n * @type {State}\n */\n function protocolPrefixInside(code) {\n // `5` is size of `https`\n if (asciiAlpha(code) && buffer.length < 5) {\n // @ts-expect-error: definitely number.\n buffer += String.fromCodePoint(code);\n effects.consume(code);\n return protocolPrefixInside;\n }\n if (code === 58) {\n const protocol = buffer.toLowerCase();\n if (protocol === 'http' || protocol === 'https') {\n effects.consume(code);\n return protocolSlashesInside;\n }\n }\n return nok(code);\n }\n\n /**\n * In slashes.\n *\n * ```markdown\n * > | https://example.com/a?b#c\n * ^^\n * ```\n *\n * @type {State}\n */\n function protocolSlashesInside(code) {\n if (code === 47) {\n effects.consume(code);\n if (seen) {\n return afterProtocol;\n }\n seen = true;\n return protocolSlashesInside;\n }\n return nok(code);\n }\n\n /**\n * After protocol, before domain.\n *\n * ```markdown\n * > | https://example.com/a?b#c\n * ^\n * ```\n *\n * @type {State}\n */\n function afterProtocol(code) {\n // To do: this is different from `markdown-rs`:\n // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);\n }\n\n /**\n * After a protocol autolink literal.\n *\n * ```markdown\n * > | https://example.com/a?b#c\n * ^\n * ```\n *\n * @type {State}\n */\n function protocolAfter(code) {\n effects.exit('literalAutolinkHttp');\n effects.exit('literalAutolink');\n return ok(code);\n }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n * ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n let size = 0;\n return wwwPrefixInside;\n\n /**\n * In www prefix.\n *\n * ```markdown\n * > | www.example.com\n * ^^^^\n * ```\n *\n * @type {State}\n */\n function wwwPrefixInside(code) {\n if ((code === 87 || code === 119) && size < 3) {\n size++;\n effects.consume(code);\n return wwwPrefixInside;\n }\n if (code === 46 && size === 3) {\n effects.consume(code);\n return wwwPrefixAfter;\n }\n return nok(code);\n }\n\n /**\n * After www prefix.\n *\n * ```markdown\n * > | www.example.com\n * ^\n * ```\n *\n * @type {State}\n */\n function wwwPrefixAfter(code) {\n // If there is *anything*, we can link.\n return code === null ? nok(code) : ok(code);\n }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n * ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n /** @type {boolean | undefined} */\n let underscoreInLastSegment;\n /** @type {boolean | undefined} */\n let underscoreInLastLastSegment;\n /** @type {boolean | undefined} */\n let seen;\n return domainInside;\n\n /**\n * In domain.\n *\n * ```markdown\n * > | https://example.com/a\n * ^^^^^^^^^^^\n * ```\n *\n * @type {State}\n */\n function domainInside(code) {\n // Check whether this marker, which is a trailing punctuation\n // marker, optionally followed by more trailing markers, and then\n // followed by an end.\n if (code === 46 || code === 95) {\n return effects.check(trail, domainAfter, domainAtPunctuation)(code);\n }\n\n // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n // so that’s Unicode.\n // Instead of some new production for Unicode alphanumerics, markdown\n // already has that for Unicode punctuation and whitespace, so use those.\n // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) {\n return domainAfter(code);\n }\n seen = true;\n effects.consume(code);\n return domainInside;\n }\n\n /**\n * In domain, at potential trailing punctuation, that was not trailing.\n *\n * ```markdown\n * > | https://example.com\n * ^\n * ```\n *\n * @type {State}\n */\n function domainAtPunctuation(code) {\n // There is an underscore in the last segment of the domain\n if (code === 95) {\n underscoreInLastSegment = true;\n }\n // Otherwise, it’s a `.`: save the last segment underscore in the\n // penultimate segment slot.\n else {\n underscoreInLastLastSegment = underscoreInLastSegment;\n underscoreInLastSegment = undefined;\n }\n effects.consume(code);\n return domainInside;\n }\n\n /**\n * After domain.\n *\n * ```markdown\n * > | https://example.com/a\n * ^\n * ```\n *\n * @type {State} */\n function domainAfter(code) {\n // Note: that’s GH says a dot is needed, but it’s not true:\n // <https://github.com/github/cmark-gfm/issues/279>\n if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n return nok(code);\n }\n return ok(code);\n }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n * ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n let sizeOpen = 0;\n let sizeClose = 0;\n return pathInside;\n\n /**\n * In path.\n *\n * ```markdown\n * > | https://example.com/a\n * ^^\n * ```\n *\n * @type {State}\n */\n function pathInside(code) {\n if (code === 40) {\n sizeOpen++;\n effects.consume(code);\n return pathInside;\n }\n\n // To do: `markdown-rs` also needs this.\n // If this is a paren, and there are less closings than openings,\n // we don’t check for a trail.\n if (code === 41 && sizeClose < sizeOpen) {\n return pathAtPunctuation(code);\n }\n\n // Check whether this trailing punctuation marker is optionally\n // followed by more trailing markers, and then followed\n // by an end.\n if (code === 33 || code === 34 || code === 38 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 60 || code === 63 || code === 93 || code === 95 || code === 126) {\n return effects.check(trail, ok, pathAtPunctuation)(code);\n }\n if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n return ok(code);\n }\n effects.consume(code);\n return pathInside;\n }\n\n /**\n * In path, at potential trailing punctuation, that was not trailing.\n *\n * ```markdown\n * > | https://example.com/a\"b\n * ^\n * ```\n *\n * @type {State}\n */\n function pathAtPunctuation(code) {\n // Count closing parens.\n if (code === 41) {\n sizeClose++;\n }\n effects.consume(code);\n return pathInside;\n }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n * ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n return trail;\n\n /**\n * In trail of domain or path.\n *\n * ```markdown\n * > | https://example.com\").\n * ^\n * ```\n *\n * @type {State}\n */\n function trail(code) {\n // Regular trailing punctuation.\n if (code === 33 || code === 34 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 63 || code === 95 || code === 126) {\n effects.consume(code);\n return trail;\n }\n\n // `&` followed by one or more alphabeticals and then a `;`, is\n // as a whole considered as trailing punctuation.\n // In all other cases, it is considered as continuation of the URL.\n if (code === 38) {\n effects.consume(code);\n return trailCharacterReferenceStart;\n }\n\n // Needed because we allow literals after `[`, as we fix:\n // <https://github.com/github/cmark-gfm/issues/278>.\n // Check that it is not followed by `(` or `[`.\n if (code === 93) {\n effects.consume(code);\n return trailBracketAfter;\n }\n if (\n // `<` is an end.\n code === 60 ||\n // So is whitespace.\n code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n return ok(code);\n }\n return nok(code);\n }\n\n /**\n * In trail, after `]`.\n *\n * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n *\n * ```markdown\n * > | https://example.com](\n * ^\n * ```\n *\n * @type {State}\n */\n function trailBracketAfter(code) {\n // Whitespace or something that could start a resource or reference is the end.\n // Switch back to trail otherwise.\n if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n return ok(code);\n }\n return trail(code);\n }\n\n /**\n * In character-reference like trail, after `&`.\n *\n * ```markdown\n * > | https://example.com&).\n * ^\n * ```\n *\n * @type {State}\n */\n function trailCharacterReferenceStart(code) {\n // When non-alpha, it’s not a trail.\n return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);\n }\n\n /**\n * In character-reference like trail.\n *\n * ```markdown\n * > | https://example.com&).\n * ^\n * ```\n *\n * @type {State}\n */\n function trailCharacterReferenceInside(code) {\n // Switch back to trail if this is well-formed.\n if (code === 59) {\n effects.consume(code);\n return trail;\n }\n if (asciiAlpha(code)) {\n effects.consume(code);\n return trailCharacterReferenceInside;\n }\n\n // It’s not a trail.\n return nok(code);\n }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n * ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n return start;\n\n /**\n * Dot.\n *\n * ```markdown\n * > | contact@example.org.\n * ^ ^\n * ```\n *\n * @type {State}\n */\n function start(code) {\n // Must be dot.\n effects.consume(code);\n return after;\n }\n\n /**\n * After dot.\n *\n * ```markdown\n * > | contact@example.org.\n * ^ ^\n * ```\n *\n * @type {State}\n */\n function after(code) {\n // Not a trail if alphanumeric.\n return asciiAlphanumeric(code) ? nok(code) : ok(code);\n }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n return !asciiAlpha(code);\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n // Do not allow a slash “inside” atext.\n // The reference code is a bit weird, but that’s what it results in.\n // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n // Other than slash, every preceding character is allowed.\n return !(code === 47 || gfmAtext(code));\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n let index = events.length;\n let result = false;\n while (index--) {\n const token = events[index][1];\n if ((token.type === 'labelLink' || token.type === 'labelImage') && !token._balanced) {\n result = true;\n break;\n }\n\n // If we’ve seen this token, and it was marked as not having any unbalanced\n // bracket before it, we can exit.\n if (token._gfmAutolinkLiteralWalkedInto) {\n result = false;\n break;\n }\n }\n if (events.length > 0 && !result) {\n // Mark the last token as “walked into” w/o finding\n // anything.\n events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;\n }\n return result;\n}"],"names":["wwwPrefix","tokenizeWwwPrefix","domain","tokenizeDomain","path","tokenizePath","trail","tokenizeTrail","emailDomainDotTrail","tokenizeEmailDomainDotTrail","wwwAutolink","tokenizeWwwAutolink","previousWww","protocolAutolink","tokenizeProtocolAutolink","previousProtocol","emailAutolink","tokenizeEmailAutolink","previousEmail","text","gfmAutolinkLiteral","code","effects","ok","nok","self","dot","data","start","gfmAtext","previousUnbalanced","atext","emailDomain","emailDomainAfter","emailDomainDot","asciiAlphanumeric","asciiAlpha","wwwStart","wwwAfter","buffer","seen","protocolStart","protocolPrefixInside","protocol","protocolSlashesInside","afterProtocol","asciiControl","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation","protocolAfter","size","wwwPrefixInside","wwwPrefixAfter","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","domainAfter","domainAtPunctuation","sizeOpen","sizeClose","pathInside","pathAtPunctuation","trailCharacterReferenceStart","trailBracketAfter","trailCharacterReferenceInside","after","events","index","result","token"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-footnote/lib/syntax.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n tokenize: tokenizeIndent,\n partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n * Extension for `micromark` that can be passed in `extensions` to\n * enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n /** @type {Extension} */\n return {\n document: {\n [91]: {\n name: 'gfmFootnoteDefinition',\n tokenize: tokenizeDefinitionStart,\n continuation: {\n tokenize: tokenizeDefinitionContinuation\n },\n exit: gfmFootnoteDefinitionEnd\n }\n },\n text: {\n [91]: {\n name: 'gfmFootnoteCall',\n tokenize: tokenizeGfmFootnoteCall\n },\n [93]: {\n name: 'gfmPotentialFootnoteCall',\n add: 'after',\n tokenize: tokenizePotentialGfmFootnoteCall,\n resolveTo: resolveToPotentialGfmFootnoteCall\n }\n }\n };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n const self = this;\n let index = self.events.length;\n const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n /** @type {Token} */\n let labelStart;\n\n // Find an opening.\n while (index--) {\n const token = self.events[index][1];\n if (token.type === \"labelImage\") {\n labelStart = token;\n break;\n }\n\n // Exit if we’ve walked far enough.\n if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n break;\n }\n }\n return start;\n\n /**\n * @type {State}\n */\n function start(code) {\n if (!labelStart || !labelStart._balanced) {\n return nok(code);\n }\n const id = normalizeIdentifier(self.sliceSerialize({\n start: labelStart.end,\n end: self.now()\n }));\n if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n return nok(code);\n }\n effects.enter('gfmFootnoteCallLabelMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteCallLabelMarker');\n return ok(code);\n }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n let index = events.length;\n /** @type {Token | undefined} */\n let labelStart;\n\n // Find an opening.\n while (index--) {\n if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n labelStart = events[index][1];\n break;\n }\n }\n // Change the `labelImageMarker` to a `data`.\n events[index + 1][1].type = \"data\";\n events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n // The whole (without `!`):\n /** @type {Token} */\n const call = {\n type: 'gfmFootnoteCall',\n start: Object.assign({}, events[index + 3][1].start),\n end: Object.assign({}, events[events.length - 1][1].end)\n };\n // The `^` marker\n /** @type {Token} */\n const marker = {\n type: 'gfmFootnoteCallMarker',\n start: Object.assign({}, events[index + 3][1].end),\n end: Object.assign({}, events[index + 3][1].end)\n };\n // Increment the end 1 character.\n marker.end.column++;\n marker.end.offset++;\n marker.end._bufferIndex++;\n /** @type {Token} */\n const string = {\n type: 'gfmFootnoteCallString',\n start: Object.assign({}, marker.end),\n end: Object.assign({}, events[events.length - 1][1].start)\n };\n /** @type {Token} */\n const chunk = {\n type: \"chunkString\",\n contentType: 'string',\n start: Object.assign({}, string.start),\n end: Object.assign({}, string.end)\n };\n\n /** @type {Array<Event>} */\n const replacement = [\n // Take the `labelImageMarker` (now `data`, the `!`)\n events[index + 1], events[index + 2], ['enter', call, context],\n // The `[`\n events[index + 3], events[index + 4],\n // The `^`.\n ['enter', marker, context], ['exit', marker, context],\n // Everything in between.\n ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n // The ending (`]`, properly parsed and labelled).\n events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n events.splice(index, events.length - index + 1, ...replacement);\n return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n const self = this;\n const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n let size = 0;\n /** @type {boolean} */\n let data;\n\n // Note: the implementation of `markdown-rs` is different, because it houses\n // core *and* extensions in one project.\n // Therefore, it can include footnote logic inside `label-end`.\n // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n // needed for labels.\n return start;\n\n /**\n * Start of footnote label.\n *\n * ```markdown\n * > | a [^b] c\n * ^\n * ```\n *\n * @type {State}\n */\n function start(code) {\n effects.enter('gfmFootnoteCall');\n effects.enter('gfmFootnoteCallLabelMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteCallLabelMarker');\n return callStart;\n }\n\n /**\n * After `[`, at `^`.\n *\n * ```markdown\n * > | a [^b] c\n * ^\n * ```\n *\n * @type {State}\n */\n function callStart(code) {\n if (code !== 94) return nok(code);\n effects.enter('gfmFootnoteCallMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteCallMarker');\n effects.enter('gfmFootnoteCallString');\n effects.enter('chunkString').contentType = 'string';\n return callData;\n }\n\n /**\n * In label.\n *\n * ```markdown\n * > | a [^b] c\n * ^\n * ```\n *\n * @type {State}\n */\n function callData(code) {\n if (\n // Too long.\n size > 999 ||\n // Closing brace with nothing.\n code === 93 && !data ||\n // Space or tab is not supported by GFM for some reason.\n // `\\n` and `[` not being supported makes sense.\n code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n return nok(code);\n }\n if (code === 93) {\n effects.exit('chunkString');\n const token = effects.exit('gfmFootnoteCallString');\n if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n return nok(code);\n }\n effects.enter('gfmFootnoteCallLabelMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteCallLabelMarker');\n effects.exit('gfmFootnoteCall');\n return ok;\n }\n if (!markdownLineEndingOrSpace(code)) {\n data = true;\n }\n size++;\n effects.consume(code);\n return code === 92 ? callEscape : callData;\n }\n\n /**\n * On character after escape.\n *\n * ```markdown\n * > | a [^b\\c] d\n * ^\n * ```\n *\n * @type {State}\n */\n function callEscape(code) {\n if (code === 91 || code === 92 || code === 93) {\n effects.consume(code);\n size++;\n return callData;\n }\n return callData(code);\n }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n const self = this;\n const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n /** @type {string} */\n let identifier;\n let size = 0;\n /** @type {boolean | undefined} */\n let data;\n return start;\n\n /**\n * Start of GFM footnote definition.\n *\n * ```markdown\n * > | [^a]: b\n * ^\n * ```\n *\n * @type {State}\n */\n function start(code) {\n effects.enter('gfmFootnoteDefinition')._container = true;\n effects.enter('gfmFootnoteDefinitionLabel');\n effects.enter('gfmFootnoteDefinitionLabelMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteDefinitionLabelMarker');\n return labelAtMarker;\n }\n\n /**\n * In label, at caret.\n *\n * ```markdown\n * > | [^a]: b\n * ^\n * ```\n *\n * @type {State}\n */\n function labelAtMarker(code) {\n if (code === 94) {\n effects.enter('gfmFootnoteDefinitionMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteDefinitionMarker');\n effects.enter('gfmFootnoteDefinitionLabelString');\n effects.enter('chunkString').contentType = 'string';\n return labelInside;\n }\n return nok(code);\n }\n\n /**\n * In label.\n *\n * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n * > definition labels.\n *\n * ```markdown\n * > | [^a]: b\n * ^\n * ```\n *\n * @type {State}\n */\n function labelInside(code) {\n if (\n // Too long.\n size > 999 ||\n // Closing brace with nothing.\n code === 93 && !data ||\n // Space or tab is not supported by GFM for some reason.\n // `\\n` and `[` not being supported makes sense.\n code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n return nok(code);\n }\n if (code === 93) {\n effects.exit('chunkString');\n const token = effects.exit('gfmFootnoteDefinitionLabelString');\n identifier = normalizeIdentifier(self.sliceSerialize(token));\n effects.enter('gfmFootnoteDefinitionLabelMarker');\n effects.consume(code);\n effects.exit('gfmFootnoteDefinitionLabelMarker');\n effects.exit('gfmFootnoteDefinitionLabel');\n return labelAfter;\n }\n if (!markdownLineEndingOrSpace(code)) {\n data = true;\n }\n size++;\n effects.consume(code);\n return code === 92 ? labelEscape : labelInside;\n }\n\n /**\n * After `\\`, at a special character.\n *\n * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n * > <https://github.com/github/cmark-gfm/issues/240>\n *\n * ```markdown\n * > | [^a\\*b]: c\n * ^\n * ```\n *\n * @type {State}\n */\n function labelEscape(code) {\n if (code === 91 || code === 92 || code === 93) {\n effects.consume(code);\n size++;\n return labelInside;\n }\n return labelInside(code);\n }\n\n /**\n * After definition label.\n *\n * ```markdown\n * > | [^a]: b\n * ^\n * ```\n *\n * @type {State}\n */\n function labelAfter(code) {\n if (code === 58) {\n effects.enter('definitionMarker');\n effects.consume(code);\n effects.exit('definitionMarker');\n if (!defined.includes(identifier)) {\n defined.push(identifier);\n }\n\n // Any whitespace after the marker is eaten, forming indented code\n // is not possible.\n // No space is also fine, just like a block quote marker.\n return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n }\n return nok(code);\n }\n\n /**\n * After definition prefix.\n *\n * ```markdown\n * > | [^a]: b\n * ^\n * ```\n *\n * @type {State}\n */\n function whitespaceAfter(code) {\n // `markdown-rs` has a wrapping token for the prefix that is closed here.\n return ok(code);\n }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n /// Start of footnote definition continuation.\n ///\n /// ```markdown\n /// | [^a]: b\n /// > | c\n /// ^\n /// ```\n //\n // Either a blank line, which is okay, or an indented thing.\n return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n const self = this;\n return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n /**\n * @type {State}\n */\n function afterPrefix(code) {\n const tail = self.events[self.events.length - 1];\n return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n }\n}"],"names":["indent","tokenizeIndent","gfmFootnote","tokenizeDefinitionStart","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","tokenizeGfmFootnoteCall","tokenizePotentialGfmFootnoteCall","resolveToPotentialGfmFootnoteCall","effects","ok","nok","self","index","defined","labelStart","token","start","code","id","normalizeIdentifier","events","context","call","marker","string","chunk","replacement","size","data","callStart","callData","markdownLineEndingOrSpace","callEscape","identifier","labelAtMarker","labelInside","labelAfter","labelEscape","factorySpace","whitespaceAfter","blankLine","afterPrefix","tail"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js"],"sourcesContent":["/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n * Configuration.\n * @returns {Extension}\n * Extension for `micromark` that can be passed in `extensions`, to\n * enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n const options_ = options || {};\n let single = options_.singleTilde;\n const tokenizer = {\n name: 'strikethrough',\n tokenize: tokenizeStrikethrough,\n resolveAll: resolveAllStrikethrough\n };\n if (single === null || single === undefined) {\n single = true;\n }\n return {\n text: {\n [126]: tokenizer\n },\n insideSpan: {\n null: [tokenizer]\n },\n attentionMarkers: {\n null: [126]\n }\n };\n\n /**\n * Take events and resolve strikethrough.\n *\n * @type {Resolver}\n */\n function resolveAllStrikethrough(events, context) {\n let index = -1;\n\n // Walk through all events.\n while (++index < events.length) {\n // Find a token that can close.\n if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n let open = index;\n\n // Now walk back to find an opener.\n while (open--) {\n // Find a token that can open the closer.\n if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n // If the sizes are the same:\n events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n events[index][1].type = 'strikethroughSequence';\n events[open][1].type = 'strikethroughSequence';\n\n /** @type {Token} */\n const strikethrough = {\n type: 'strikethrough',\n start: Object.assign({}, events[open][1].start),\n end: Object.assign({}, events[index][1].end)\n };\n\n /** @type {Token} */\n const text = {\n type: 'strikethroughText',\n start: Object.assign({}, events[open][1].end),\n end: Object.assign({}, events[index][1].start)\n };\n\n // Opening.\n /** @type {Array<Event>} */\n const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n const insideSpan = context.parser.constructs.insideSpan.null;\n if (insideSpan) {\n // Between.\n splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n }\n\n // Closing.\n splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n splice(events, open - 1, index - open + 3, nextEvents);\n index = open + nextEvents.length - 2;\n break;\n }\n }\n }\n }\n index = -1;\n while (++index < events.length) {\n if (events[index][1].type === 'strikethroughSequenceTemporary') {\n events[index][1].type = \"data\";\n }\n }\n return events;\n }\n\n /**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\n function tokenizeStrikethrough(effects, ok, nok) {\n const previous = this.previous;\n const events = this.events;\n let size = 0;\n return start;\n\n /** @type {State} */\n function start(code) {\n if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n return nok(code);\n }\n effects.enter('strikethroughSequenceTemporary');\n return more(code);\n }\n\n /** @type {State} */\n function more(code) {\n const before = classifyCharacter(previous);\n if (code === 126) {\n // If this is the third marker, exit.\n if (size > 1) return nok(code);\n effects.consume(code);\n size++;\n return more;\n }\n if (size < 2 && !single) return nok(code);\n const token = effects.exit('strikethroughSequenceTemporary');\n const after = classifyCharacter(code);\n token._open = !after || after === 2 && Boolean(before);\n token._close = !before || before === 2 && Boolean(after);\n return ok(code);\n }\n }\n}"],"names":["gfmStrikethrough","options","single","tokenizer","tokenizeStrikethrough","resolveAllStrikethrough","events","context","index","open","strikethrough","text","nextEvents","insideSpan","splice","resolveAll","effects","ok","nok","previous","size","start","code","more","before","classifyCharacter","token","after"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js"],"sourcesContent":["/**\n * @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nconst tasklistCheck = {\n name: 'tasklistCheck',\n tokenize: tokenizeTasklistCheck\n};\n\n/**\n * Create an HTML extension for `micromark` to support GFM task list items\n * syntax.\n *\n * @returns {Extension}\n * Extension for `micromark` that can be passed in `htmlExtensions` to\n * support GFM task list items when serializing to HTML.\n */\nexport function gfmTaskListItem() {\n return {\n text: {\n [91]: tasklistCheck\n }\n };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n const self = this;\n return open;\n\n /**\n * At start of task list item check.\n *\n * ```markdown\n * > | * [x] y.\n * ^\n * ```\n *\n * @type {State}\n */\n function open(code) {\n if (\n // Exit if there’s stuff before.\n self.previous !== null ||\n // Exit if not in the first content that is the first child of a list\n // item.\n !self._gfmTasklistFirstContentOfListItem) {\n return nok(code);\n }\n effects.enter('taskListCheck');\n effects.enter('taskListCheckMarker');\n effects.consume(code);\n effects.exit('taskListCheckMarker');\n return inside;\n }\n\n /**\n * In task list item check.\n *\n * ```markdown\n * > | * [x] y.\n * ^\n * ```\n *\n * @type {State}\n */\n function inside(code) {\n // Currently we match how GH works in files.\n // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n if (markdownLineEndingOrSpace(code)) {\n effects.enter('taskListCheckValueUnchecked');\n effects.consume(code);\n effects.exit('taskListCheckValueUnchecked');\n return close;\n }\n if (code === 88 || code === 120) {\n effects.enter('taskListCheckValueChecked');\n effects.consume(code);\n effects.exit('taskListCheckValueChecked');\n return close;\n }\n return nok(code);\n }\n\n /**\n * At close of task list item check.\n *\n * ```markdown\n * > | * [x] y.\n * ^\n * ```\n *\n * @type {State}\n */\n function close(code) {\n if (code === 93) {\n effects.enter('taskListCheckMarker');\n effects.consume(code);\n effects.exit('taskListCheckMarker');\n effects.exit('taskListCheck');\n return after;\n }\n return nok(code);\n }\n\n /**\n * @type {State}\n */\n function after(code) {\n // EOL in paragraph means there must be something else after it.\n if (markdownLineEnding(code)) {\n return ok(code);\n }\n\n // Space or tab?\n // Check what comes after.\n if (markdownSpace(code)) {\n return effects.check({\n tokenize: spaceThenNonSpace\n }, ok, nok)(code);\n }\n\n // EOF, or non-whitespace, both wrong.\n return nok(code);\n }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n return factorySpace(effects, after, \"whitespace\");\n\n /**\n * After whitespace, after task list item check.\n *\n * ```markdown\n * > | * [x] y.\n * ^\n * ```\n *\n * @type {State}\n */\n function after(code) {\n // EOF means there was nothing, so bad.\n // EOL means there’s content after it, so good.\n // Impossible to have more spaces.\n // Anything else is good.\n return code === null ? nok(code) : ok(code);\n }\n}"],"names":["tasklistCheck","tokenizeTasklistCheck","gfmTaskListItem","effects","ok","nok","self","open","code","inside","markdownLineEndingOrSpace","close","after","markdownLineEnding","markdownSpace","spaceThenNonSpace","factorySpace"],"mappings":";;AAMA,MAAMA,IAAgB;AAAA,EACpB,MAAM;AAAA,EACN,UAAUC;AACZ;AAUO,SAASC,IAAkB;AAChC,SAAO;AAAA,IACL,MAAM;AAAA,MACH,IAAKF;AAAA,IACZ;AAAA,EACA;AACA;AAMA,SAASC,EAAsBE,GAASC,GAAIC,GAAK;AAC/C,QAAMC,IAAO;AACb,SAAOC;AAYP,WAASA,EAAKC,GAAM;AAClB;AAAA;AAAA,MAEAF,EAAK,aAAa;AAAA;AAAA,MAGlB,CAACA,EAAK,qCACGD,EAAIG,CAAI,KAEjBL,EAAQ,MAAM,eAAe,GAC7BA,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,qBAAqB,GAC3BM;AAAA;AAAA,EACT;AAYA,WAASA,EAAOD,GAAM;AAIpB,WAAIE,EAA0BF,CAAI,KAChCL,EAAQ,MAAM,6BAA6B,GAC3CA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,6BAA6B,GACnCQ,KAELH,MAAS,MAAMA,MAAS,OAC1BL,EAAQ,MAAM,2BAA2B,GACzCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,2BAA2B,GACjCQ,KAEFN,EAAIG,CAAI;AAAA,EACjB;AAYA,WAASG,EAAMH,GAAM;AACnB,WAAIA,MAAS,MACXL,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,qBAAqB,GAClCA,EAAQ,KAAK,eAAe,GACrBS,KAEFP,EAAIG,CAAI;AAAA,EACjB;AAKA,WAASI,EAAMJ,GAAM;AAEnB,WAAIK,EAAmBL,CAAI,IAClBJ,EAAGI,CAAI,IAKZM,EAAcN,CAAI,IACbL,EAAQ,MAAM;AAAA,MACnB,UAAUY;AAAA,IAClB,GAASX,GAAIC,CAAG,EAAEG,CAAI,IAIXH,EAAIG,CAAI;AAAA,EACjB;AACF;AAMA,SAASO,EAAkBZ,GAASC,GAAIC,GAAK;AAC3C,SAAOW,EAAab,GAASS,GAAO,YAAY;AAYhD,WAASA,EAAMJ,GAAM;AAKnB,WAAOA,MAAS,OAAOH,EAAIG,CAAI,IAAIJ,EAAGI,CAAI;AAAA,EAC5C;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-factory-space/index.js DELETED Viewed

@@ -1,16 +0,0 @@
-import { markdownSpace as m } from "../micromark-util-character/index.js";
-function p(n, t, i, u) {
-  const o = u ? u - 1 : Number.POSITIVE_INFINITY;
-  let I = 0;
-  return a;
-  function a(r) {
-    return m(r) ? (n.enter(i), e(r)) : t(r);
-  }
-  function e(r) {
-    return m(r) && I++ < o ? (n.consume(r), e) : (n.exit(i), t(r));
-  }
-}
-export {
-  p as factorySpace
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-factory-space/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * * spaces in markdown are often optional, in which case this factory can be\n * used and `ok` will be switched to whether spaces were found or not\n * * one line ending or space can be detected with `markdownSpace(code)` right\n * before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n * Context.\n * @param {State} ok\n * State switched to when successful.\n * @param {TokenType} type\n * Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n * Max (exclusive).\n * @returns {State}\n * Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n let size = 0;\n return start;\n\n /** @type {State} */\n function start(code) {\n if (markdownSpace(code)) {\n effects.enter(type);\n return prefix(code);\n }\n return ok(code);\n }\n\n /** @type {State} */\n function prefix(code) {\n if (markdownSpace(code) && size++ < limit) {\n effects.consume(code);\n return prefix;\n }\n effects.exit(type);\n return ok(code);\n }\n}"],"names":["factorySpace","effects","ok","type","max","limit","size","start","code","markdownSpace","prefix"],"mappings":";AAwCO,SAASA,EAAaC,GAASC,GAAIC,GAAMC,GAAK;AACnD,QAAMC,IAAQD,IAAMA,IAAM,IAAI,OAAO;AACrC,MAAIE,IAAO;AACX,SAAOC;AAGP,WAASA,EAAMC,GAAM;AACnB,WAAIC,EAAcD,CAAI,KACpBP,EAAQ,MAAME,CAAI,GACXO,EAAOF,CAAI,KAEbN,EAAGM,CAAI;AAAA,EAChB;AAGA,WAASE,EAAOF,GAAM;AACpB,WAAIC,EAAcD,CAAI,KAAKF,MAASD,KAClCJ,EAAQ,QAAQO,CAAI,GACbE,MAETT,EAAQ,KAAKE,CAAI,GACVD,EAAGM,CAAI;AAAA,EAChB;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-character/index.js DELETED Viewed

@@ -1,35 +0,0 @@
-const u = t(/[A-Za-z]/), a = t(/[\dA-Za-z]/);
-function c(n) {
-  return (
-    // Special whitespace codes (which have negative values), C0 and Control
-    // character DEL
-    n !== null && (n < 32 || n === 127)
-  );
-}
-function e(n) {
-  return n !== null && n < -2;
-}
-function o(n) {
-  return n !== null && (n < 0 || n === 32);
-}
-function l(n) {
-  return n === -2 || n === -1 || n === 32;
-}
-const s = t(new RegExp("\\p{P}|\\p{S}", "u")), p = t(/\s/);
-function t(n) {
-  return i;
-  function i(r) {
-    return r !== null && r > -1 && n.test(String.fromCharCode(r));
-  }
-}
-export {
-  u as asciiAlpha,
-  a as asciiAlphanumeric,
-  c as asciiControl,
-  e as markdownLineEnding,
-  o as markdownLineEndingOrSpace,
-  l as markdownSpace,
-  s as unicodePunctuation,
-  p as unicodeWhitespace
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-character/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport function asciiControl(code) {\n return (\n // Special whitespace codes (which have negative values), C0 and Control\n // character DEL\n code !== null && (code < 32 || code === 127)\n );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport function markdownLineEnding(code) {\n return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * Code.\n * @returns {boolean}\n * Whether it matches.\n */\nexport function markdownSpace(code) {\n return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n * Code.\n * @returns\n * Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n * Code.\n * @returns\n * Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * Expression.\n * @returns {(code: Code) => boolean}\n * Check.\n */\nfunction regexCheck(regex) {\n return check;\n\n /**\n * Check whether a code matches the bound regex.\n *\n * @param {Code} code\n * Character code.\n * @returns {boolean}\n * Whether the character code matches the bound regex.\n */\n function check(code) {\n return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiControl","code","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","check"],"mappings":"AAqBY,MAACA,IAAaC,EAAW,UAAU,GAclCC,IAAoBD,EAAW,YAAY;AAoCjD,SAASE,EAAaC,GAAM;AACjC;AAAA;AAAA;AAAA,IAGEA,MAAS,SAASA,IAAO,MAAMA,MAAS;AAAA;AAE5C;AAiEO,SAASC,EAAmBD,GAAM;AACvC,SAAOA,MAAS,QAAQA,IAAO;AACjC;AAWO,SAASE,EAA0BF,GAAM;AAC9C,SAAOA,MAAS,SAASA,IAAO,KAAKA,MAAS;AAChD;AAiBO,SAASG,EAAcH,GAAM;AAClC,SAAOA,MAAS,MAAMA,MAAS,MAAMA,MAAS;AAChD;AAuBY,MAACI,IAAqBP,EAAW,WAAA,iBAAA,GAAc,IAsB9CQ,IAAoBR,EAAW,IAAI;AAUhD,SAASA,EAAWS,GAAO;AACzB,SAAOC;AAUP,WAASA,EAAMP,GAAM;AACnB,WAAOA,MAAS,QAAQA,IAAO,MAAMM,EAAM,KAAK,OAAO,aAAaN,CAAI,CAAC;AAAA,EAC3E;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-chunked/index.js DELETED Viewed

@@ -1,13 +0,0 @@
-function p(f, l, n, h) {
-  const e = f.length;
-  let i = 0, c;
-  if (l < 0 ? l = -l > e ? 0 : e + l : l = l > e ? e : l, n = n > 0 ? n : 0, h.length < 1e4)
-    c = Array.from(h), c.unshift(l, n), f.splice(...c);
-  else
-    for (n && f.splice(l, n); i < h.length; )
-      c = h.slice(i, i + 1e4), c.unshift(l, 0), f.splice(...c), i += 1e4, l += 1e4;
-}
-export {
-  p as splice
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-chunked/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-chunked/index.js"],"sourcesContent":["/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * Item type.\n * @param {Array<T>} list\n * List to operate on.\n * @param {number} start\n * Index to remove/insert at (can be negative).\n * @param {number} remove\n * Number of items to remove.\n * @param {Array<T>} items\n * Items to inject into `list`.\n * @returns {undefined}\n * Nothing.\n */\nexport function splice(list, start, remove, items) {\n const end = list.length;\n let chunkStart = 0;\n /** @type {Array<unknown>} */\n let parameters;\n\n // Make start between zero and `end` (included).\n if (start < 0) {\n start = -start > end ? 0 : end + start;\n } else {\n start = start > end ? end : start;\n }\n remove = remove > 0 ? remove : 0;\n\n // No need to chunk the items if there’s only a couple (10k) items.\n if (items.length < 10000) {\n parameters = Array.from(items);\n parameters.unshift(start, remove);\n // @ts-expect-error Hush, it’s fine.\n list.splice(...parameters);\n } else {\n // Delete `remove` items starting from `start`\n if (remove) list.splice(start, remove);\n\n // Insert the items in chunks to not cause stack overflows.\n while (chunkStart < items.length) {\n parameters = items.slice(chunkStart, chunkStart + 10000);\n parameters.unshift(start, 0);\n // @ts-expect-error Hush, it’s fine.\n list.splice(...parameters);\n chunkStart += 10000;\n start += 10000;\n }\n }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * Item type.\n * @param {Array<T>} list\n * List to operate on.\n * @param {Array<T>} items\n * Items to add to `list`.\n * @returns {Array<T>}\n * Either `list` or `items`.\n */\nexport function push(list, items) {\n if (list.length > 0) {\n splice(list, list.length, 0, items);\n return list;\n }\n return items;\n}"],"names":["splice","list","start","remove","items","end","chunkStart","parameters"],"mappings":"AAsBO,SAASA,EAAOC,GAAMC,GAAOC,GAAQC,GAAO;AACjD,QAAMC,IAAMJ,EAAK;AACjB,MAAIK,IAAa,GAEbC;AAWJ,MARIL,IAAQ,IACVA,IAAQ,CAACA,IAAQG,IAAM,IAAIA,IAAMH,IAEjCA,IAAQA,IAAQG,IAAMA,IAAMH,GAE9BC,IAASA,IAAS,IAAIA,IAAS,GAG3BC,EAAM,SAAS;AACjB,IAAAG,IAAa,MAAM,KAAKH,CAAK,GAC7BG,EAAW,QAAQL,GAAOC,CAAM,GAEhCF,EAAK,OAAO,GAAGM,CAAU;AAAA;AAMzB,SAHIJ,KAAQF,EAAK,OAAOC,GAAOC,CAAM,GAG9BG,IAAaF,EAAM;AACxB,MAAAG,IAAaH,EAAM,MAAME,GAAYA,IAAa,GAAK,GACvDC,EAAW,QAAQL,GAAO,CAAC,GAE3BD,EAAK,OAAO,GAAGM,CAAU,GACzBD,KAAc,KACdJ,KAAS;AAGf;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-classify-character/index.js DELETED Viewed

@@ -1,11 +0,0 @@
-import { markdownLineEndingOrSpace as i, unicodeWhitespace as r, unicodePunctuation as t } from "../micromark-util-character/index.js";
-function a(n) {
-  if (n === null || i(n) || r(n))
-    return 1;
-  if (t(n))
-    return 2;
-}
-export {
-  a as classifyCharacter
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-classify-character/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-classify-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n * Group.\n */\nexport function classifyCharacter(code) {\n if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n return 1;\n }\n if (unicodePunctuation(code)) {\n return 2;\n }\n}"],"names":["classifyCharacter","code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation"],"mappings":";AAmBO,SAASA,EAAkBC,GAAM;AACtC,MAAIA,MAAS,QAAQC,EAA0BD,CAAI,KAAKE,EAAkBF,CAAI;AAC5E,WAAO;AAET,MAAIG,EAAmBH,CAAI;AACzB,WAAO;AAEX;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-combine-extensions/index.js DELETED Viewed

@@ -1,37 +0,0 @@
-import { splice as a } from "../micromark-util-chunked/index.js";
-const s = {}.hasOwnProperty;
-function d(t) {
-  const e = {};
-  let n = -1;
-  for (; ++n < t.length; )
-    l(e, t[n]);
-  return e;
-}
-function l(t, e) {
-  let n;
-  for (n in e) {
-    const i = (s.call(t, n) ? t[n] : void 0) || (t[n] = {}), f = e[n];
-    let o;
-    if (f)
-      for (o in f) {
-        s.call(i, o) || (i[o] = []);
-        const r = f[o];
-        h(
-          // @ts-expect-error Looks like a list.
-          i[o],
-          Array.isArray(r) ? r : r ? [r] : []
-        );
-      }
-  }
-}
-function h(t, e) {
-  let n = -1;
-  const c = [];
-  for (; ++n < e.length; )
-    (e[n].add === "after" ? t : c).push(e[n]);
-  a(t, 0, 0, c);
-}
-export {
-  d as combineExtensions
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-combine-extensions/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-combine-extensions/index.js"],"sourcesContent":["/**\n * @import {\n * Extension,\n * Handles,\n * HtmlExtension,\n * NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n * List of syntax extensions.\n * @returns {NormalizedExtension}\n * A single combined extension.\n */\nexport function combineExtensions(extensions) {\n /** @type {NormalizedExtension} */\n const all = {}\n let index = -1\n\n while (++index < extensions.length) {\n syntaxExtension(all, extensions[index])\n }\n\n return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n * Extension to merge into.\n * @param {Extension} extension\n * Extension to merge.\n * @returns {undefined}\n * Nothing.\n */\nfunction syntaxExtension(all, extension) {\n /** @type {keyof Extension} */\n let hook\n\n for (hook in extension) {\n const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n /** @type {Record<string, unknown>} */\n const left = maybe || (all[hook] = {})\n /** @type {Record<string, unknown> | undefined} */\n const right = extension[hook]\n /** @type {string} */\n let code\n\n if (right) {\n for (code in right) {\n if (!hasOwnProperty.call(left, code)) left[code] = []\n const value = right[code]\n constructs(\n // @ts-expect-error Looks like a list.\n left[code],\n Array.isArray(value) ? value : value ? [value] : []\n )\n }\n }\n }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * List of constructs to merge into.\n * @param {Array<unknown>} list\n * List of constructs to merge.\n * @returns {undefined}\n * Nothing.\n */\nfunction constructs(existing, list) {\n let index = -1\n /** @type {Array<unknown>} */\n const before = []\n\n while (++index < list.length) {\n // @ts-expect-error Looks like an object.\n ;(list[index].add === 'after' ? existing : before).push(list[index])\n }\n\n splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n * List of HTML extensions.\n * @returns {HtmlExtension}\n * Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n /** @type {HtmlExtension} */\n const handlers = {}\n let index = -1\n\n while (++index < htmlExtensions.length) {\n htmlExtension(handlers, htmlExtensions[index])\n }\n\n return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n * Extension to merge into.\n * @param {HtmlExtension} extension\n * Extension to merge.\n * @returns {undefined}\n * Nothing.\n */\nfunction htmlExtension(all, extension) {\n /** @type {keyof HtmlExtension} */\n let hook\n\n for (hook in extension) {\n const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n const left = maybe || (all[hook] = {})\n const right = extension[hook]\n /** @type {keyof Handles} */\n let type\n\n if (right) {\n for (type in right) {\n // @ts-expect-error assume document vs regular handler are managed correctly.\n left[type] = right[type]\n }\n }\n }\n}\n"],"names":["hasOwnProperty","combineExtensions","extensions","all","index","syntaxExtension","extension","hook","left","right","code","value","constructs","existing","list","before","splice"],"mappings":";AAWA,MAAMA,IAAiB,CAAA,EAAG;AAUnB,SAASC,EAAkBC,GAAY;AAE5C,QAAMC,IAAM,CAAA;AACZ,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAW;AAC1B,IAAAG,EAAgBF,GAAKD,EAAWE,CAAK,CAAC;AAGxC,SAAOD;AACT;AAYA,SAASE,EAAgBF,GAAKG,GAAW;AAEvC,MAAIC;AAEJ,OAAKA,KAAQD,GAAW;AAGtB,UAAME,KAFQR,EAAe,KAAKG,GAAKI,CAAI,IAAIJ,EAAII,CAAI,IAAI,YAEpCJ,EAAII,CAAI,IAAI,CAAA,IAE7BE,IAAQH,EAAUC,CAAI;AAE5B,QAAIG;AAEJ,QAAID;AACF,WAAKC,KAAQD,GAAO;AAClB,QAAKT,EAAe,KAAKQ,GAAME,CAAI,MAAGF,EAAKE,CAAI,IAAI,CAAA;AACnD,cAAMC,IAAQF,EAAMC,CAAI;AACxB,QAAAE;AAAA;AAAA,UAEEJ,EAAKE,CAAI;AAAA,UACT,MAAM,QAAQC,CAAK,IAAIA,IAAQA,IAAQ,CAACA,CAAK,IAAI,CAAA;AAAA,QAC3D;AAAA,MACM;AAAA,EAEJ;AACF;AAaA,SAASC,EAAWC,GAAUC,GAAM;AAClC,MAAIV,IAAQ;AAEZ,QAAMW,IAAS,CAAA;AAEf,SAAO,EAAEX,IAAQU,EAAK;AAEnB,KAACA,EAAKV,CAAK,EAAE,QAAQ,UAAUS,IAAWE,GAAQ,KAAKD,EAAKV,CAAK,CAAC;AAGrE,EAAAY,EAAOH,GAAU,GAAG,GAAGE,CAAM;AAC/B;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-normalize-identifier/index.js DELETED Viewed

@@ -1,7 +0,0 @@
-function r(e) {
-  return e.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
-}
-export {
-  r as normalizeIdentifier
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-normalize-identifier/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-normalize-identifier/index.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n * Identifier to normalize.\n * @returns {string}\n * Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n return value\n // Collapse markdown whitespace.\n .replace(/[\\t\\n\\r ]+/g, \" \")\n // Trim.\n .replace(/^ | $/g, '')\n // Some characters are considered “uppercase”, but if their lowercase\n // counterpart is uppercased will result in a different uppercase\n // character.\n // Hence, to get that form, we perform both lower- and uppercase.\n // Upper case makes sure keys will not interact with default prototypal\n // methods: no method is uppercase.\n .toLowerCase().toUpperCase();\n}"],"names":["normalizeIdentifier","value"],"mappings":"AAmBO,SAASA,EAAoBC,GAAO;AACzC,SAAOA,EAEN,QAAQ,eAAe,GAAG,EAE1B,QAAQ,UAAU,EAAE,EAOpB,YAAW,EAAG,YAAW;AAC5B;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-resolve-all/index.js DELETED Viewed

@@ -1,13 +0,0 @@
-function c(o, e, r) {
-  const i = [];
-  let n = -1;
-  for (; ++n < o.length; ) {
-    const l = o[n].resolveAll;
-    l && !i.includes(l) && (e = l(e, r), i.push(l));
-  }
-  return e;
-}
-export {
-  c as resolveAll
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-resolve-all/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-resolve-all/index.js"],"sourcesContent":["/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n * List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n * List of events.\n * @param {TokenizeContext} context\n * Context used by `tokenize`.\n * @returns {Array<Event>}\n * Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n /** @type {Array<Resolver>} */\n const called = []\n let index = -1\n\n while (++index < constructs.length) {\n const resolve = constructs[index].resolveAll\n\n if (resolve && !called.includes(resolve)) {\n events = resolve(events, context)\n called.push(resolve)\n }\n }\n\n return events\n}\n"],"names":["resolveAll","constructs","events","context","called","index","resolve"],"mappings":"AAgBO,SAASA,EAAWC,GAAYC,GAAQC,GAAS;AAEtD,QAAMC,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQJ,EAAW,UAAQ;AAClC,UAAMK,IAAUL,EAAWI,CAAK,EAAE;AAElC,IAAIC,KAAW,CAACF,EAAO,SAASE,CAAO,MACrCJ,IAASI,EAAQJ,GAAQC,CAAO,GAChCC,EAAO,KAAKE,CAAO;AAAA,EAEvB;AAEA,SAAOJ;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/rehype-highlight/lib/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../../node_modules/rehype-highlight/lib/index.js"],"sourcesContent":["/**\n * @import {ElementContent, Element, Root} from 'hast'\n * @import {LanguageFn} from 'lowlight'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef Options\n * Configuration (optional).\n * @property {Readonly<Record<string, ReadonlyArray<string> | string>> | null | undefined} [aliases={}]\n * Register more aliases (optional);\n * passed to `lowlight.registerAlias`.\n * @property {boolean | null | undefined} [detect=false]\n * Highlight code without language classes by guessing its programming\n * language (default: `false`).\n * @property {Readonly<Record<string, LanguageFn>> | null | undefined} [languages]\n * Register languages (default: `common`);\n * passed to `lowlight.register`.\n * @property {ReadonlyArray<string> | null | undefined} [plainText=[]]\n * List of language names to not highlight (optional);\n * note you can also add `no-highlight` classes.\n * @property {string | null | undefined} [prefix='hljs-']\n * Class prefix (default: `'hljs-'`).\n * @property {ReadonlyArray<string> | null | undefined} [subset]\n * Names of languages to check when detecting (default: all registered\n * languages).\n */\n\nimport {toText} from 'hast-util-to-text'\nimport {common, createLowlight} from 'lowlight'\nimport {visit} from 'unist-util-visit'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Apply syntax highlighting.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n * Configuration (optional).\n * @returns\n * Transform.\n */\nexport default function rehypeHighlight(options) {\n const settings = options || emptyOptions\n const aliases = settings.aliases\n const detect = settings.detect || false\n const languages = settings.languages || common\n const plainText = settings.plainText\n const prefix = settings.prefix\n const subset = settings.subset\n let name = 'hljs'\n\n const lowlight = createLowlight(languages)\n\n if (aliases) {\n lowlight.registerAlias(aliases)\n }\n\n if (prefix) {\n const pos = prefix.indexOf('-')\n name = pos === -1 ? prefix : prefix.slice(0, pos)\n }\n\n /**\n * Transform.\n *\n * @param {Root} tree\n * Tree.\n * @param {VFile} file\n * File.\n * @returns {undefined}\n * Nothing.\n */\n return function (tree, file) {\n visit(tree, 'element', function (node, _, parent) {\n if (\n node.tagName !== 'code' ||\n !parent ||\n parent.type !== 'element' ||\n parent.tagName !== 'pre'\n ) {\n return\n }\n\n const lang = language(node)\n\n if (\n lang === false ||\n (!lang && !detect) ||\n (lang && plainText && plainText.includes(lang))\n ) {\n return\n }\n\n if (!Array.isArray(node.properties.className)) {\n node.properties.className = []\n }\n\n if (!node.properties.className.includes(name)) {\n node.properties.className.unshift(name)\n }\n\n const text = toText(node, {whitespace: 'pre'})\n /** @type {Root} */\n let result\n\n try {\n result = lang\n ? lowlight.highlight(lang, text, {prefix})\n : lowlight.highlightAuto(text, {prefix, subset})\n } catch (error) {\n const cause = /** @type {Error} */ (error)\n\n if (lang && /Unknown language/.test(cause.message)) {\n file.message(\n 'Cannot highlight as `' + lang + '`, it’s not registered',\n {\n ancestors: [parent, node],\n cause,\n place: node.position,\n ruleId: 'missing-language',\n source: 'rehype-highlight'\n }\n )\n\n /* c8 ignore next 5 -- throw arbitrary hljs errors */\n return\n }\n\n throw cause\n }\n\n if (!lang && result.data && result.data.language) {\n node.properties.className.push('language-' + result.data.language)\n }\n\n if (result.children.length > 0) {\n node.children = /** @type {Array<ElementContent>} */ (result.children)\n }\n })\n }\n}\n\n/**\n * Get the programming language of `node`.\n *\n * @param {Element} node\n * Node.\n * @returns {false | string | undefined}\n * Language or `undefined`, or `false` when an explikcit `no-highlight` class\n * is used.\n */\nfunction language(node) {\n const list = node.properties.className\n let index = -1\n\n if (!Array.isArray(list)) {\n return\n }\n\n /** @type {string | undefined} */\n let name\n\n while (++index < list.length) {\n const value = String(list[index])\n\n if (value === 'no-highlight' || value === 'nohighlight') {\n return false\n }\n\n if (!name && value.slice(0, 5) === 'lang-') {\n name = value.slice(5)\n }\n\n if (!name && value.slice(0, 9) === 'language-') {\n name = value.slice(9)\n }\n }\n\n return name\n}\n"],"names":["emptyOptions","rehypeHighlight","options","settings","aliases","detect","languages","common","plainText","prefix","subset","name","lowlight","createLowlight","pos","tree","file","visit","node","_","parent","lang","language","text","toText","result","error","cause","list","index","value"],"mappings":";;;;AAiCA,MAAMA,IAAe,CAAA;AAUN,SAASC,EAAgBC,GAAS;AAC/C,QAAMC,IAAWD,KAAWF,GACtBI,IAAUD,EAAS,SACnBE,IAASF,EAAS,UAAU,IAC5BG,IAAYH,EAAS,aAAaI,GAClCC,IAAYL,EAAS,WACrBM,IAASN,EAAS,QAClBO,IAASP,EAAS;AACxB,MAAIQ,IAAO;AAEX,QAAMC,IAAWC,EAAeP,CAAS;AAMzC,MAJIF,KACFQ,EAAS,cAAcR,CAAO,GAG5BK,GAAQ;AACV,UAAMK,IAAML,EAAO,QAAQ,GAAG;AAC9B,IAAAE,IAAOG,MAAQ,KAAKL,IAASA,EAAO,MAAM,GAAGK,CAAG;AAAA,EAClD;AAYA,SAAO,SAAUC,GAAMC,GAAM;AAC3B,IAAAC,EAAMF,GAAM,WAAW,SAAUG,GAAMC,GAAGC,GAAQ;AAChD,UACEF,EAAK,YAAY,UACjB,CAACE,KACDA,EAAO,SAAS,aAChBA,EAAO,YAAY;AAEnB;AAGF,YAAMC,IAAOC,EAASJ,CAAI;AAE1B,UACEG,MAAS,MACR,CAACA,KAAQ,CAAChB,KACVgB,KAAQb,KAAaA,EAAU,SAASa,CAAI;AAE7C;AAGF,MAAK,MAAM,QAAQH,EAAK,WAAW,SAAS,MAC1CA,EAAK,WAAW,YAAY,CAAA,IAGzBA,EAAK,WAAW,UAAU,SAASP,CAAI,KAC1CO,EAAK,WAAW,UAAU,QAAQP,CAAI;AAGxC,YAAMY,IAAOC,EAAON,GAAM,EAAC,YAAY,MAAK,CAAC;AAE7C,UAAIO;AAEJ,UAAI;AACF,QAAAA,IAASJ,IACLT,EAAS,UAAUS,GAAME,GAAM,EAAC,QAAAd,EAAM,CAAC,IACvCG,EAAS,cAAcW,GAAM,EAAC,QAAAd,GAAQ,QAAAC,EAAM,CAAC;AAAA,MACnD,SAASgB,GAAO;AACd,cAAMC;AAAA;AAAA,UAA8BD;AAAA;AAEpC,YAAIL,KAAQ,mBAAmB,KAAKM,EAAM,OAAO,GAAG;AAClD,UAAAX,EAAK;AAAA,YACH,0BAA0BK,IAAO;AAAA,YACjC;AAAA,cACE,WAAW,CAACD,GAAQF,CAAI;AAAA,cACxB,OAAAS;AAAA,cACA,OAAOT,EAAK;AAAA,cACZ,QAAQ;AAAA,cACR,QAAQ;AAAA,YACtB;AAAA,UACA;AAGU;AAAA,QACF;AAEA,cAAMS;AAAA,MACR;AAEA,MAAI,CAACN,KAAQI,EAAO,QAAQA,EAAO,KAAK,YACtCP,EAAK,WAAW,UAAU,KAAK,cAAcO,EAAO,KAAK,QAAQ,GAG/DA,EAAO,SAAS,SAAS,MAC3BP,EAAK;AAAA,MAAiDO,EAAO;AAAA,IAEjE,CAAC;AAAA,EACH;AACF;AAWA,SAASH,EAASJ,GAAM;AACtB,QAAMU,IAAOV,EAAK,WAAW;AAC7B,MAAIW,IAAQ;AAEZ,MAAI,CAAC,MAAM,QAAQD,CAAI;AACrB;AAIF,MAAIjB;AAEJ,SAAO,EAAEkB,IAAQD,EAAK,UAAQ;AAC5B,UAAME,IAAQ,OAAOF,EAAKC,CAAK,CAAC;AAEhC,QAAIC,MAAU,kBAAkBA,MAAU;AACxC,aAAO;AAGT,IAAI,CAACnB,KAAQmB,EAAM,MAAM,GAAG,CAAC,MAAM,YACjCnB,IAAOmB,EAAM,MAAM,CAAC,IAGlB,CAACnB,KAAQmB,EAAM,MAAM,GAAG,CAAC,MAAM,gBACjCnB,IAAOmB,EAAM,MAAM,CAAC;AAAA,EAExB;AAEA,SAAOnB;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/remark-gfm/lib/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../../node_modules/remark-gfm/lib/index.js"],"sourcesContent":["/**\n * @import {Root} from 'mdast'\n * @import {Options} from 'remark-gfm'\n * @import {} from 'remark-parse'\n * @import {} from 'remark-stringify'\n * @import {Processor} from 'unified'\n */\n\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\nimport {gfm} from 'micromark-extension-gfm'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Add support GFM (autolink literals, footnotes, strikethrough, tables,\n * tasklists).\n *\n * @param {Options | null | undefined} [options]\n * Configuration (optional).\n * @returns {undefined}\n * Nothing.\n */\nexport default function remarkGfm(options) {\n // @ts-expect-error: TS is wrong about `this`.\n // eslint-disable-next-line unicorn/no-this-assignment\n const self = /** @type {Processor<Root>} */ (this)\n const settings = options || emptyOptions\n const data = self.data()\n\n const micromarkExtensions =\n data.micromarkExtensions || (data.micromarkExtensions = [])\n const fromMarkdownExtensions =\n data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])\n const toMarkdownExtensions =\n data.toMarkdownExtensions || (data.toMarkdownExtensions = [])\n\n micromarkExtensions.push(gfm(settings))\n fromMarkdownExtensions.push(gfmFromMarkdown())\n toMarkdownExtensions.push(gfmToMarkdown(settings))\n}\n"],"names":["emptyOptions","remarkGfm","options","self","settings","data","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","gfm","gfmFromMarkdown","gfmToMarkdown"],"mappings":";;AAYA,MAAMA,IAAe,CAAA;AAWN,SAASC,EAAUC,GAAS;AAGzC,QAAMC;AAAA;AAAA,IAAuC;AAAA,KACvCC,IAAWF,KAAWF,GACtBK,IAAOF,EAAK,KAAI,GAEhBG,IACJD,EAAK,wBAAwBA,EAAK,sBAAsB,CAAA,IACpDE,IACJF,EAAK,2BAA2BA,EAAK,yBAAyB,CAAA,IAC1DG,IACJH,EAAK,yBAAyBA,EAAK,uBAAuB,CAAA;AAE5D,EAAAC,EAAoB,KAAKG,EAAIL,CAAQ,CAAC,GACtCG,EAAuB,KAAKG,EAAe,CAAE,GAC7CF,EAAqB,KAAKG,EAAcP,CAAQ,CAAC;AACnD;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-find-after/lib/index.js DELETED Viewed

@@ -1,33 +0,0 @@
-import { convert as t } from "../../unist-util-is/lib/index.js";
-const f = (
-  // Note: overloads like this are needed to support optional generics.
-  /**
-   * @type {(
-   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &
-   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)
-   * )}
-   */
-  /**
-   * @param {UnistParent} parent
-   * @param {UnistNode | number} index
-   * @param {Test} [test]
-   * @returns {UnistNode | undefined}
-   */
-  (function(e, r, o) {
-    const i = t(o);
-    if (!e || !e.type || !e.children)
-      throw new Error("Expected parent node");
-    if (typeof r == "number") {
-      if (r < 0 || r === Number.POSITIVE_INFINITY)
-        throw new Error("Expected positive finite number as index");
-    } else if (r = e.children.indexOf(r), r < 0)
-      throw new Error("Expected child node or index");
-    for (; ++r < e.children.length; )
-      if (i(e.children[r], r, e))
-        return e.children[r];
-  })
-);
-export {
-  f as findAfter
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-find-after/lib/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-find-after/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n * Test from `unist-util-is`.\n *\n * Note: we have remove and add `undefined`, because otherwise when generating\n * automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n * which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n * Fn extends (value: any) => value is infer Thing\n * ? Thing\n * : Fallback\n * )} Predicate\n * Get the value of a type guard `Fn`.\n * @template Fn\n * Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n * Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n * Check extends null | undefined // No test.\n * ? Value\n * : Value extends {type: Check} // String (type) test.\n * ? Value\n * : Value extends Check // Partial test.\n * ? Value\n * : Check extends Function // Function test.\n * ? Predicate<Check, Value> extends Value\n * ? Predicate<Check, Value>\n * : never\n * : never // Some other test?\n * )} MatchesOne\n * Check whether a node matches a primitive check in the type system.\n * @template Value\n * Value; typically unist `Node`.\n * @template Check\n * Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n * Check extends Array<any>\n * ? MatchesOne<Value, Check[keyof Check]>\n * : MatchesOne<Value, Check>\n * )} Matches\n * Check whether a node matches a check in the type system.\n * @template Value\n * Value; typically unist `Node`.\n * @template Check\n * Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {(\n * Kind extends {children: Array<infer Child>}\n * ? Child\n * : never\n * )} Child\n * Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Kind\n * All node types.\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Find the first node in `parent` after another `node` or after an index,\n * that passes `test`.\n *\n * @param parent\n * Parent node.\n * @param index\n * Child node or index.\n * @param [test=undefined]\n * Test for child to look for (optional).\n * @returns\n * A child (matching `test`, if given) or `undefined`.\n */\nexport const findAfter =\n // Note: overloads like this are needed to support optional generics.\n /**\n * @type {(\n * (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &\n * (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)\n * )}\n */\n (\n /**\n * @param {UnistParent} parent\n * @param {UnistNode | number} index\n * @param {Test} [test]\n * @returns {UnistNode | undefined}\n */\n function (parent, index, test) {\n const is = convert(test)\n\n if (!parent || !parent.type || !parent.children) {\n throw new Error('Expected parent node')\n }\n\n if (typeof index === 'number') {\n if (index < 0 || index === Number.POSITIVE_INFINITY) {\n throw new Error('Expected positive finite number as index')\n }\n } else {\n index = parent.children.indexOf(index)\n\n if (index < 0) {\n throw new Error('Expected child node or index')\n }\n }\n\n while (++index < parent.children.length) {\n if (is(parent.children[index], index, parent)) {\n return parent.children[index]\n }\n }\n\n return undefined\n }\n )\n"],"names":["findAfter","parent","index","test","is","convert"],"mappings":";AAuFY,MAACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAeT,SAAUC,GAAQC,GAAOC,GAAM;AAC7B,UAAMC,IAAKC,EAAQF,CAAI;AAEvB,QAAI,CAACF,KAAU,CAACA,EAAO,QAAQ,CAACA,EAAO;AACrC,YAAM,IAAI,MAAM,sBAAsB;AAGxC,QAAI,OAAOC,KAAU;AACnB,UAAIA,IAAQ,KAAKA,MAAU,OAAO;AAChC,cAAM,IAAI,MAAM,0CAA0C;AAAA,eAG5DA,IAAQD,EAAO,SAAS,QAAQC,CAAK,GAEjCA,IAAQ;AACV,YAAM,IAAI,MAAM,8BAA8B;AAIlD,WAAO,EAAEA,IAAQD,EAAO,SAAS;AAC/B,UAAIG,EAAGH,EAAO,SAASC,CAAK,GAAGA,GAAOD,CAAM;AAC1C,eAAOA,EAAO,SAASC,CAAK;AAAA,EAKlC;AAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-is/lib/index.js DELETED Viewed

@@ -1,85 +0,0 @@
-const i = (
-  // Note: overloads in JSDoc can’t yet use different `@template`s.
-  /**
-   * @type {(
-   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
-   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
-   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
-   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
-   *   ((test?: Test) => Check)
-   * )}
-   */
-  /**
-   * @param {Test} [test]
-   * @returns {Check}
-   */
-  (function(n) {
-    if (n == null)
-      return p;
-    if (typeof n == "function")
-      return c(n);
-    if (typeof n == "object")
-      return Array.isArray(n) ? f(n) : y(n);
-    if (typeof n == "string")
-      return l(n);
-    throw new Error("Expected function, string, or object as test");
-  })
-);
-function f(n) {
-  const e = [];
-  let r = -1;
-  for (; ++r < n.length; )
-    e[r] = i(n[r]);
-  return c(t);
-  function t(...u) {
-    let o = -1;
-    for (; ++o < e.length; )
-      if (e[o].apply(this, u)) return !0;
-    return !1;
-  }
-}
-function y(n) {
-  const e = (
-    /** @type {Record<string, unknown>} */
-    n
-  );
-  return c(r);
-  function r(t) {
-    const u = (
-      /** @type {Record<string, unknown>} */
-      /** @type {unknown} */
-      t
-    );
-    let o;
-    for (o in n)
-      if (u[o] !== e[o]) return !1;
-    return !0;
-  }
-}
-function l(n) {
-  return c(e);
-  function e(r) {
-    return r && r.type === n;
-  }
-}
-function c(n) {
-  return e;
-  function e(r, t, u) {
-    return !!(a(r) && n.call(
-      this,
-      r,
-      typeof t == "number" ? t : void 0,
-      u || void 0
-    ));
-  }
-}
-function p() {
-  return !0;
-}
-function a(n) {
-  return n !== null && typeof n == "object" && "type" in n;
-}
-export {
-  i as convert
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-is/lib/index.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-is/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n * Check that an arbitrary value is a node.\n * @param {unknown} this\n * The given context.\n * @param {unknown} [node]\n * Anything (typically a node).\n * @param {number | null | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n * The node’s parent.\n * @returns {boolean}\n * Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n * Object to check for equivalence.\n *\n * Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n * Check for an arbitrary node.\n *\n * @callback TestFunction\n * Check if a node passes a test.\n * @param {unknown} this\n * The given context.\n * @param {Node} node\n * A node.\n * @param {number | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n * The node’s parent.\n * @returns {boolean | undefined | void}\n * Whether this node passes the test.\n *\n * Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n * Thing to check, typically `Node`.\n * @param {Test} test\n * A check for a specific node.\n * @param {number | null | undefined} index\n * The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n * The node’s parent.\n * @param {unknown} context\n * Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n * Whether `node` is a node and passes a test.\n */\nexport const is =\n // Note: overloads in JSDoc can’t yet use different `@template`s.\n /**\n * @type {(\n * (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n * (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n * (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n * ((node?: null | undefined) => false) &\n * ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n * ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n * )}\n */\n (\n /**\n * @param {unknown} [node]\n * @param {Test} [test]\n * @param {number | null | undefined} [index]\n * @param {Parent | null | undefined} [parent]\n * @param {unknown} [context]\n * @returns {boolean}\n */\n // eslint-disable-next-line max-params\n function (node, test, index, parent, context) {\n const check = convert(test)\n\n if (\n index !== undefined &&\n index !== null &&\n (typeof index !== 'number' ||\n index < 0 ||\n index === Number.POSITIVE_INFINITY)\n ) {\n throw new Error('Expected positive finite index')\n }\n\n if (\n parent !== undefined &&\n parent !== null &&\n (!is(parent) || !parent.children)\n ) {\n throw new Error('Expected parent node')\n }\n\n if (\n (parent === undefined || parent === null) !==\n (index === undefined || index === null)\n ) {\n throw new Error('Expected both parent and index')\n }\n\n return looksLikeANode(node)\n ? check.call(context, node, index, parent)\n : false\n }\n )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n * * when nullish, checks if `node` is a `Node`.\n * * when `string`, works like passing `(node) => node.type === test`.\n * * when `function` checks if function passed the node is true.\n * * when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * * when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n * An assertion.\n */\nexport const convert =\n // Note: overloads in JSDoc can’t yet use different `@template`s.\n /**\n * @type {(\n * (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n * (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n * (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n * ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n * ((test?: Test) => Check)\n * )}\n */\n (\n /**\n * @param {Test} [test]\n * @returns {Check}\n */\n function (test) {\n if (test === null || test === undefined) {\n return ok\n }\n\n if (typeof test === 'function') {\n return castFactory(test)\n }\n\n if (typeof test === 'object') {\n return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n }\n\n if (typeof test === 'string') {\n return typeFactory(test)\n }\n\n throw new Error('Expected function, string, or object as test')\n }\n )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n /** @type {Array<Check>} */\n const checks = []\n let index = -1\n\n while (++index < tests.length) {\n checks[index] = convert(tests[index])\n }\n\n return castFactory(any)\n\n /**\n * @this {unknown}\n * @type {TestFunction}\n */\n function any(...parameters) {\n let index = -1\n\n while (++index < checks.length) {\n if (checks[index].apply(this, parameters)) return true\n }\n\n return false\n }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n return castFactory(all)\n\n /**\n * @param {Node} node\n * @returns {boolean}\n */\n function all(node) {\n const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n /** @type {unknown} */ (node)\n )\n\n /** @type {string} */\n let key\n\n for (key in check) {\n if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n }\n\n return true\n }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n return castFactory(type)\n\n /**\n * @param {Node} node\n */\n function type(node) {\n return node && node.type === check\n }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n return check\n\n /**\n * @this {unknown}\n * @type {Check}\n */\n function check(value, index, parent) {\n return Boolean(\n looksLikeANode(value) &&\n testFunction.call(\n this,\n value,\n typeof index === 'number' ? index : undefined,\n parent || undefined\n )\n )\n }\n}\n\nfunction ok() {\n return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n return value !== null && typeof value === 'object' && 'type' in value\n}\n"],"names":["convert","test","ok","castFactory","anyFactory","propsFactory","typeFactory","tests","checks","index","any","parameters","check","checkAsRecord","all","node","nodeAsRecord","key","type","testFunction","value","parent","looksLikeANode"],"mappings":"AA2IY,MAACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAgBT,SAAUC,GAAM;AACd,QAAIA,KAAS;AACX,aAAOC;AAGT,QAAI,OAAOD,KAAS;AAClB,aAAOE,EAAYF,CAAI;AAGzB,QAAI,OAAOA,KAAS;AAClB,aAAO,MAAM,QAAQA,CAAI,IAAIG,EAAWH,CAAI,IAAII,EAAaJ,CAAI;AAGnE,QAAI,OAAOA,KAAS;AAClB,aAAOK,EAAYL,CAAI;AAGzB,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAAA;AAOJ,SAASG,EAAWG,GAAO;AAEzB,QAAMC,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAM;AACrB,IAAAC,EAAOC,CAAK,IAAIT,EAAQO,EAAME,CAAK,CAAC;AAGtC,SAAON,EAAYO,CAAG;AAMtB,WAASA,KAAOC,GAAY;AAC1B,QAAIF,IAAQ;AAEZ,WAAO,EAAEA,IAAQD,EAAO;AACtB,UAAIA,EAAOC,CAAK,EAAE,MAAM,MAAME,CAAU,EAAG,QAAO;AAGpD,WAAO;AAAA,EACT;AACF;AAQA,SAASN,EAAaO,GAAO;AAC3B,QAAMC;AAAA;AAAA,IAAwDD;AAAA;AAE9D,SAAOT,EAAYW,CAAG;AAMtB,WAASA,EAAIC,GAAM;AACjB,UAAMC;AAAA;AAAA;AAAA,MACoBD;AAAA;AAI1B,QAAIE;AAEJ,SAAKA,KAAOL;AACV,UAAII,EAAaC,CAAG,MAAMJ,EAAcI,CAAG,EAAG,QAAO;AAGvD,WAAO;AAAA,EACT;AACF;AAQA,SAASX,EAAYM,GAAO;AAC1B,SAAOT,EAAYe,CAAI;AAKvB,WAASA,EAAKH,GAAM;AAClB,WAAOA,KAAQA,EAAK,SAASH;AAAA,EAC/B;AACF;AAQA,SAAST,EAAYgB,GAAc;AACjC,SAAOP;AAMP,WAASA,EAAMQ,GAAOX,GAAOY,GAAQ;AACnC,WAAO,GACLC,EAAeF,CAAK,KAClBD,EAAa;AAAA,MACX;AAAA,MACAC;AAAA,MACA,OAAOX,KAAU,WAAWA,IAAQ;AAAA,MACpCY,KAAU;AAAA,IACpB;AAAA,EAEE;AACF;AAEA,SAASnB,IAAK;AACZ,SAAO;AACT;AAMA,SAASoB,EAAeF,GAAO;AAC7B,SAAOA,MAAU,QAAQ,OAAOA,KAAU,YAAY,UAAUA;AAClE;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-visit/lib/index.js DELETED Viewed

@@ -1,17 +0,0 @@
-import { visitParents as m } from "../../unist-util-visit-parents/lib/index.js";
-import { CONTINUE as y, EXIT as E, SKIP as N } from "../../unist-util-visit-parents/lib/index.js";
-function I(l, n, e, u) {
-  let t, f, o;
-  typeof n == "function" && typeof e != "function" ? (f = void 0, o = n, t = e) : (f = n, o = e, t = u), m(l, f, p, t);
-  function p(c, d) {
-    const i = d[d.length - 1], x = i ? i.children.indexOf(c) : void 0;
-    return o(c, x, i);
-  }
-}
-export {
-  y as CONTINUE,
-  E as EXIT,
-  N as SKIP,
-  I as visit
-};
-//# sourceMappingURL=index.js.map