cngpac 0.0.1

package/dist/src/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.mjs

@@ -0,0 +1,213 @@
+import { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const autolink = {
+	name: "autolink",
+	tokenize: tokenizeAutolink
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeAutolink(effects, ok, nok) {
+	let size = 0;
+	return start;
+	/**
+	* Start of an autolink.
+	*
+	* ```markdown
+	* > | a<https://example.com>b
+	*      ^
+	* > | a<user@example.com>b
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("autolink");
+		effects.enter("autolinkMarker");
+		effects.consume(code);
+		effects.exit("autolinkMarker");
+		effects.enter("autolinkProtocol");
+		return open;
+	}
+	/**
+	* After `<`, at protocol or atext.
+	*
+	* ```markdown
+	* > | a<https://example.com>b
+	*       ^
+	* > | a<user@example.com>b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function open(code) {
+		if (asciiAlpha(code)) {
+			effects.consume(code);
+			return schemeOrEmailAtext;
+		}
+		if (code === 64) return nok(code);
+		return emailAtext(code);
+	}
+	/**
+	* At second byte of protocol or atext.
+	*
+	* ```markdown
+	* > | a<https://example.com>b
+	*        ^
+	* > | a<user@example.com>b
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function schemeOrEmailAtext(code) {
+		if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {
+			size = 1;
+			return schemeInsideOrEmailAtext(code);
+		}
+		return emailAtext(code);
+	}
+	/**
+	* In ambiguous protocol or atext.
+	*
+	* ```markdown
+	* > | a<https://example.com>b
+	*        ^
+	* > | a<user@example.com>b
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function schemeInsideOrEmailAtext(code) {
+		if (code === 58) {
+			effects.consume(code);
+			size = 0;
+			return urlInside;
+		}
+		if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {
+			effects.consume(code);
+			return schemeInsideOrEmailAtext;
+		}
+		size = 0;
+		return emailAtext(code);
+	}
+	/**
+	* After protocol, in URL.
+	*
+	* ```markdown
+	* > | a<https://example.com>b
+	*             ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function urlInside(code) {
+		if (code === 62) {
+			effects.exit("autolinkProtocol");
+			effects.enter("autolinkMarker");
+			effects.consume(code);
+			effects.exit("autolinkMarker");
+			effects.exit("autolink");
+			return ok;
+		}
+		if (code === null || code === 32 || code === 60 || asciiControl(code)) return nok(code);
+		effects.consume(code);
+		return urlInside;
+	}
+	/**
+	* In email atext.
+	*
+	* ```markdown
+	* > | a<user.name@example.com>b
+	*              ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailAtext(code) {
+		if (code === 64) {
+			effects.consume(code);
+			return emailAtSignOrDot;
+		}
+		if (asciiAtext(code)) {
+			effects.consume(code);
+			return emailAtext;
+		}
+		return nok(code);
+	}
+	/**
+	* In label, after at-sign or dot.
+	*
+	* ```markdown
+	* > | a<user.name@example.com>b
+	*                 ^       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailAtSignOrDot(code) {
+		return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);
+	}
+	/**
+	* In label, where `.` and `>` are allowed.
+	*
+	* ```markdown
+	* > | a<user.name@example.com>b
+	*                   ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailLabel(code) {
+		if (code === 46) {
+			effects.consume(code);
+			size = 0;
+			return emailAtSignOrDot;
+		}
+		if (code === 62) {
+			effects.exit("autolinkProtocol").type = "autolinkEmail";
+			effects.enter("autolinkMarker");
+			effects.consume(code);
+			effects.exit("autolinkMarker");
+			effects.exit("autolink");
+			return ok;
+		}
+		return emailValue(code);
+	}
+	/**
+	* In label, where `.` and `>` are *not* allowed.
+	*
+	* Though, this is also used in `emailLabel` to parse other values.
+	*
+	* ```markdown
+	* > | a<user.name@ex-ample.com>b
+	*                    ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailValue(code) {
+		if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
+			const next = code === 45 ? emailValue : emailLabel;
+			effects.consume(code);
+			return next;
+		}
+		return nok(code);
+	}
+}
+//#endregion
+export { autolink };

package/dist/src/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.mjs

@@ -0,0 +1,60 @@
+import { markdownLineEnding, markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const blankLine = {
+	partial: true,
+	tokenize: tokenizeBlankLine
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeBlankLine(effects, ok, nok) {
+	return start;
+	/**
+	* Start of blank line.
+	*
+	* > 👉 **Note**: `␠` represents a space character.
+	*
+	* ```markdown
+	* > | ␠␠␊
+	*     ^
+	* > | ␊
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		return markdownSpace(code) ? factorySpace(effects, after, "linePrefix")(code) : after(code);
+	}
+	/**
+	* At eof/eol, after optional whitespace.
+	*
+	* > 👉 **Note**: `␠` represents a space character.
+	*
+	* ```markdown
+	* > | ␠␠␊
+	*       ^
+	* > | ␊
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
+	}
+}
+//#endregion
+export { blankLine };

package/dist/src/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.mjs

@@ -0,0 +1,130 @@
+import { markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.js
+/**
+* @import {
+*   Construct,
+*   Exiter,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const blockQuote = {
+	continuation: { tokenize: tokenizeBlockQuoteContinuation },
+	exit,
+	name: "blockQuote",
+	tokenize: tokenizeBlockQuoteStart
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeBlockQuoteStart(effects, ok, nok) {
+	const self = this;
+	return start;
+	/**
+	* Start of block quote.
+	*
+	* ```markdown
+	* > | > a
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		if (code === 62) {
+			const state = self.containerState;
+			if (!state.open) {
+				effects.enter("blockQuote", { _container: true });
+				state.open = true;
+			}
+			effects.enter("blockQuotePrefix");
+			effects.enter("blockQuoteMarker");
+			effects.consume(code);
+			effects.exit("blockQuoteMarker");
+			return after;
+		}
+		return nok(code);
+	}
+	/**
+	* After `>`, before optional whitespace.
+	*
+	* ```markdown
+	* > | > a
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		if (markdownSpace(code)) {
+			effects.enter("blockQuotePrefixWhitespace");
+			effects.consume(code);
+			effects.exit("blockQuotePrefixWhitespace");
+			effects.exit("blockQuotePrefix");
+			return ok;
+		}
+		effects.exit("blockQuotePrefix");
+		return ok(code);
+	}
+}
+/**
+* Start of block quote continuation.
+*
+* ```markdown
+*   | > a
+* > | > b
+*     ^
+* ```
+*
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeBlockQuoteContinuation(effects, ok, nok) {
+	const self = this;
+	return contStart;
+	/**
+	* Start of block quote continuation.
+	*
+	* Also used to parse the first block quote opening.
+	*
+	* ```markdown
+	*   | > a
+	* > | > b
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function contStart(code) {
+		if (markdownSpace(code)) return factorySpace(effects, contBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
+		return contBefore(code);
+	}
+	/**
+	* At `>`, after optional whitespace.
+	*
+	* Also used to parse the first block quote opening.
+	*
+	* ```markdown
+	*   | > a
+	* > | > b
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function contBefore(code) {
+		return effects.attempt(blockQuote, ok, nok)(code);
+	}
+}
+/** @type {Exiter} */
+function exit(effects) {
+	effects.exit("blockQuote");
+}
+//#endregion
+export { blockQuote };

package/dist/src/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.mjs

@@ -0,0 +1,62 @@
+import { asciiPunctuation } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const characterEscape = {
+	name: "characterEscape",
+	tokenize: tokenizeCharacterEscape
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeCharacterEscape(effects, ok, nok) {
+	return start;
+	/**
+	* Start of character escape.
+	*
+	* ```markdown
+	* > | a\*b
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("characterEscape");
+		effects.enter("escapeMarker");
+		effects.consume(code);
+		effects.exit("escapeMarker");
+		return inside;
+	}
+	/**
+	* After `\`, at punctuation.
+	*
+	* ```markdown
+	* > | a\*b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function inside(code) {
+		if (asciiPunctuation(code)) {
+			effects.enter("characterEscapeValue");
+			effects.consume(code);
+			effects.exit("characterEscapeValue");
+			effects.exit("characterEscape");
+			return ok;
+		}
+		return nok(code);
+	}
+}
+//#endregion
+export { characterEscape };

package/dist/src/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.mjs

@@ -0,0 +1,141 @@
+import { asciiAlphanumeric, asciiDigit, asciiHexDigit } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { decodeNamedCharacterReference } from "../../../../decode-named-character-reference@1.3.0/node_modules/decode-named-character-reference/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const characterReference = {
+	name: "characterReference",
+	tokenize: tokenizeCharacterReference
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeCharacterReference(effects, ok, nok) {
+	const self = this;
+	let size = 0;
+	/** @type {number} */
+	let max;
+	/** @type {(code: Code) => boolean} */
+	let test;
+	return start;
+	/**
+	* Start of character reference.
+	*
+	* ```markdown
+	* > | a&b
+	*      ^
+	* > | a{b
+	*      ^
+	* > | a	b
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("characterReference");
+		effects.enter("characterReferenceMarker");
+		effects.consume(code);
+		effects.exit("characterReferenceMarker");
+		return open;
+	}
+	/**
+	* After `&`, at `#` for numeric references or alphanumeric for named
+	* references.
+	*
+	* ```markdown
+	* > | a&b
+	*       ^
+	* > | a{b
+	*       ^
+	* > | a	b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function open(code) {
+		if (code === 35) {
+			effects.enter("characterReferenceMarkerNumeric");
+			effects.consume(code);
+			effects.exit("characterReferenceMarkerNumeric");
+			return numeric;
+		}
+		effects.enter("characterReferenceValue");
+		max = 31;
+		test = asciiAlphanumeric;
+		return value(code);
+	}
+	/**
+	* After `#`, at `x` for hexadecimals or digit for decimals.
+	*
+	* ```markdown
+	* > | a{b
+	*        ^
+	* > | a	b
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function numeric(code) {
+		if (code === 88 || code === 120) {
+			effects.enter("characterReferenceMarkerHexadecimal");
+			effects.consume(code);
+			effects.exit("characterReferenceMarkerHexadecimal");
+			effects.enter("characterReferenceValue");
+			max = 6;
+			test = asciiHexDigit;
+			return value;
+		}
+		effects.enter("characterReferenceValue");
+		max = 7;
+		test = asciiDigit;
+		return value(code);
+	}
+	/**
+	* After markers (`&#x`, `&#`, or `&`), in value, before `;`.
+	*
+	* The character reference kind defines what and how many characters are
+	* allowed.
+	*
+	* ```markdown
+	* > | a&b
+	*       ^^^
+	* > | a{b
+	*        ^^^
+	* > | a	b
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function value(code) {
+		if (code === 59 && size) {
+			const token = effects.exit("characterReferenceValue");
+			if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) return nok(code);
+			effects.enter("characterReferenceMarker");
+			effects.consume(code);
+			effects.exit("characterReferenceMarker");
+			effects.exit("characterReference");
+			return ok;
+		}
+		if (test(code) && size++ < max) {
+			effects.consume(code);
+			return value;
+		}
+		return nok(code);
+	}
+}
+//#endregion
+export { characterReference };