cngpac 0.0.1

package/dist/src/node_modules/.pnpm/micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.mjs

@@ -0,0 +1,134 @@
+import { markdownLineEnding, markdownSpace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.js
+/**
+* @import {
+*   Effects,
+*   State,
+*   TokenizeContext,
+*   TokenType
+* } from 'micromark-util-types'
+*/
+/**
+* Parse labels.
+*
+* > 👉 **Note**: labels in markdown are capped at 999 characters in the string.
+*
+* ###### Examples
+*
+* ```markdown
+* [a]
+* [a
+* b]
+* [a\]b]
+* ```
+*
+* @this {TokenizeContext}
+*   Tokenize context.
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {State} nok
+*   State switched to when unsuccessful.
+* @param {TokenType} type
+*   Type of the whole label (`[a]`).
+* @param {TokenType} markerType
+*   Type for the markers (`[` and `]`).
+* @param {TokenType} stringType
+*   Type for the identifier (`a`).
+* @returns {State}
+*   Start state.
+*/
+function factoryLabel(effects, ok, nok, type, markerType, stringType) {
+	const self = this;
+	let size = 0;
+	/** @type {boolean} */
+	let seen;
+	return start;
+	/**
+	* Start of label.
+	*
+	* ```markdown
+	* > | [a]
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter(type);
+		effects.enter(markerType);
+		effects.consume(code);
+		effects.exit(markerType);
+		effects.enter(stringType);
+		return atBreak;
+	}
+	/**
+	* In label, at something, before something else.
+	*
+	* ```markdown
+	* > | [a]
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function atBreak(code) {
+		if (size > 999 || code === null || code === 91 || code === 93 && !seen || code === 94 && !size && "_hiddenFootnoteSupport" in self.parser.constructs) return nok(code);
+		if (code === 93) {
+			effects.exit(stringType);
+			effects.enter(markerType);
+			effects.consume(code);
+			effects.exit(markerType);
+			effects.exit(type);
+			return ok;
+		}
+		if (markdownLineEnding(code)) {
+			effects.enter("lineEnding");
+			effects.consume(code);
+			effects.exit("lineEnding");
+			return atBreak;
+		}
+		effects.enter("chunkString", { contentType: "string" });
+		return labelInside(code);
+	}
+	/**
+	* In label, in text.
+	*
+	* ```markdown
+	* > | [a]
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelInside(code) {
+		if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {
+			effects.exit("chunkString");
+			return atBreak(code);
+		}
+		effects.consume(code);
+		if (!seen) seen = !markdownSpace(code);
+		return code === 92 ? labelEscape : labelInside;
+	}
+	/**
+	* After `\`, at a special character.
+	*
+	* ```markdown
+	* > | [a\*a]
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelEscape(code) {
+		if (code === 91 || code === 92 || code === 93) {
+			effects.consume(code);
+			size++;
+			return labelInside;
+		}
+		return labelInside(code);
+	}
+}
+//#endregion
+export { factoryLabel };

package/dist/src/node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.mjs

@@ -0,0 +1,61 @@
+import { markdownSpace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js
+/**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
+* Parse spaces and tabs.
+*
+* There is no `nok` parameter:
+*
+* *   spaces in markdown are often optional, in which case this factory can be
+*     used and `ok` will be switched to whether spaces were found or not
+* *   one line ending or space can be detected with `markdownSpace(code)` right
+*     before using `factorySpace`
+*
+* ###### Examples
+*
+* Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+* single space.
+*
+* ```markdown
+* ␉
+* ␠␠␠␠
+* ␉␠
+* ```
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {TokenType} type
+*   Type (`' \t'`).
+* @param {number | undefined} [max=Infinity]
+*   Max (exclusive).
+* @returns {State}
+*   Start state.
+*/
+function factorySpace(effects, ok, type, max) {
+	const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+	let size = 0;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (markdownSpace(code)) {
+			effects.enter(type);
+			return prefix(code);
+		}
+		return ok(code);
+	}
+	/** @type {State} */
+	function prefix(code) {
+		if (markdownSpace(code) && size++ < limit) {
+			effects.consume(code);
+			return prefix;
+		}
+		effects.exit(type);
+		return ok(code);
+	}
+}
+//#endregion
+export { factorySpace };

package/dist/src/node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.mjs

@@ -0,0 +1,148 @@
+import { markdownLineEnding } 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-factory-title@2.0.1/node_modules/micromark-factory-title/index.js
+/**
+* @import {
+*   Code,
+*   Effects,
+*   State,
+*   TokenType
+* } from 'micromark-util-types'
+*/
+/**
+* Parse titles.
+*
+* ###### Examples
+*
+* ```markdown
+* "a"
+* 'b'
+* (c)
+* "a
+* b"
+* 'a
+*     b'
+* (a\)b)
+* ```
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {State} nok
+*   State switched to when unsuccessful.
+* @param {TokenType} type
+*   Type of the whole title (`"a"`, `'b'`, `(c)`).
+* @param {TokenType} markerType
+*   Type for the markers (`"`, `'`, `(`, and `)`).
+* @param {TokenType} stringType
+*   Type for the value (`a`).
+* @returns {State}
+*   Start state.
+*/
+function factoryTitle(effects, ok, nok, type, markerType, stringType) {
+	/** @type {NonNullable<Code>} */
+	let marker;
+	return start;
+	/**
+	* Start of title.
+	*
+	* ```markdown
+	* > | "a"
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		if (code === 34 || code === 39 || code === 40) {
+			effects.enter(type);
+			effects.enter(markerType);
+			effects.consume(code);
+			effects.exit(markerType);
+			marker = code === 40 ? 41 : code;
+			return begin;
+		}
+		return nok(code);
+	}
+	/**
+	* After opening marker.
+	*
+	* This is also used at the closing marker.
+	*
+	* ```markdown
+	* > | "a"
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function begin(code) {
+		if (code === marker) {
+			effects.enter(markerType);
+			effects.consume(code);
+			effects.exit(markerType);
+			effects.exit(type);
+			return ok;
+		}
+		effects.enter(stringType);
+		return atBreak(code);
+	}
+	/**
+	* At something, before something else.
+	*
+	* ```markdown
+	* > | "a"
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function atBreak(code) {
+		if (code === marker) {
+			effects.exit(stringType);
+			return begin(marker);
+		}
+		if (code === null) return nok(code);
+		if (markdownLineEnding(code)) {
+			effects.enter("lineEnding");
+			effects.consume(code);
+			effects.exit("lineEnding");
+			return factorySpace(effects, atBreak, "linePrefix");
+		}
+		effects.enter("chunkString", { contentType: "string" });
+		return inside(code);
+	}
+	/**
+	*
+	*
+	* @type {State}
+	*/
+	function inside(code) {
+		if (code === marker || code === null || markdownLineEnding(code)) {
+			effects.exit("chunkString");
+			return atBreak(code);
+		}
+		effects.consume(code);
+		return code === 92 ? escape : inside;
+	}
+	/**
+	* After `\`, at a special character.
+	*
+	* ```markdown
+	* > | "a\*b"
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function escape(code) {
+		if (code === marker || code === 92) {
+			effects.consume(code);
+			return inside;
+		}
+		return inside(code);
+	}
+}
+//#endregion
+export { factoryTitle };

package/dist/src/node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.mjs

@@ -0,0 +1,43 @@
+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-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.js
+/**
+* @import {Effects, State} from 'micromark-util-types'
+*/
+/**
+* Parse spaces and tabs.
+*
+* There is no `nok` parameter:
+*
+* *   line endings or spaces in markdown are often optional, in which case this
+*     factory can be used and `ok` will be switched to whether spaces were found
+*     or not
+* *   one line ending or space can be detected with
+*     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @returns {State}
+*   Start state.
+*/
+function factoryWhitespace(effects, ok) {
+	/** @type {boolean} */
+	let seen;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (markdownLineEnding(code)) {
+			effects.enter("lineEnding");
+			effects.consume(code);
+			effects.exit("lineEnding");
+			seen = true;
+			return start;
+		}
+		if (markdownSpace(code)) return factorySpace(effects, start, seen ? "linePrefix" : "lineSuffix")(code);
+		return ok(code);
+	}
+}
+//#endregion
+export { factoryWhitespace };

package/dist/src/node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs

@@ -0,0 +1,229 @@
+//#region node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.js
+/**
+* @import {Code} from 'micromark-util-types'
+*/
+/**
+* Check whether the character code represents an ASCII alpha (`a` through `z`,
+* case insensitive).
+*
+* An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+*
+* An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+* to U+005A (`Z`).
+*
+* An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+* to U+007A (`z`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiAlpha = regexCheck(/[A-Za-z]/);
+/**
+* Check whether the character code represents an ASCII alphanumeric (`a`
+* through `z`, case insensitive, or `0` through `9`).
+*
+* An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+* (see `asciiAlpha`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+/**
+* Check whether the character code represents an ASCII atext.
+*
+* atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+* the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+* U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+* SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+* CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+* (`{`) to U+007E TILDE (`~`).
+*
+* See:
+* **\[RFC5322]**:
+* [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+* P. Resnick.
+* IETF.
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+/**
+* Check whether a character code is an ASCII control character.
+*
+* An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+* to U+001F (US), or U+007F (DEL).
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function asciiControl(code) {
+	return code !== null && (code < 32 || code === 127);
+}
+/**
+* Check whether the character code represents an ASCII digit (`0` through `9`).
+*
+* An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+* U+0039 (`9`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiDigit = regexCheck(/\d/);
+/**
+* Check whether the character code represents an ASCII hex digit (`a` through
+* `f`, case insensitive, or `0` through `9`).
+*
+* An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+* digit, or an ASCII lower hex digit.
+*
+* An **ASCII upper hex digit** is a character in the inclusive range U+0041
+* (`A`) to U+0046 (`F`).
+*
+* An **ASCII lower hex digit** is a character in the inclusive range U+0061
+* (`a`) to U+0066 (`f`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+/**
+* Check whether the character code represents ASCII punctuation.
+*
+* An **ASCII punctuation** is a character in the inclusive ranges U+0021
+* EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+* SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+* (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+/**
+* Check whether a character code is a markdown line ending.
+*
+* A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+* LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+*
+* In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+* RETURN (CR) are replaced by these virtual characters depending on whether
+* they occurred together.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownLineEnding(code) {
+	return code !== null && code < -2;
+}
+/**
+* Check whether a character code is a markdown line ending (see
+* `markdownLineEnding`) or markdown space (see `markdownSpace`).
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownLineEndingOrSpace(code) {
+	return code !== null && (code < 0 || code === 32);
+}
+/**
+* Check whether a character code is a markdown space.
+*
+* A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+* virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+*
+* In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+* replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+* SPACE (VS) characters, depending on the column at which the tab occurred.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownSpace(code) {
+	return code === -2 || code === -1 || code === 32;
+}
+/**
+* Check whether the character code represents Unicode punctuation.
+*
+* A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+* Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+* (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+* (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+* punctuation (see `asciiPunctuation`).
+*
+* See:
+* **\[UNICODE]**:
+* [The Unicode Standard](https://www.unicode.org/versions/).
+* Unicode Consortium.
+*
+* @param code
+*   Code.
+* @returns
+*   Whether it matches.
+*/
+const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+/**
+* Check whether the character code represents Unicode whitespace.
+*
+* Note that this does handle micromark specific markdown whitespace characters.
+* See `markdownLineEndingOrSpace` to check that.
+*
+* A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+* Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+* U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+*
+* See:
+* **\[UNICODE]**:
+* [The Unicode Standard](https://www.unicode.org/versions/).
+* Unicode Consortium.
+*
+* @param code
+*   Code.
+* @returns
+*   Whether it matches.
+*/
+const unicodeWhitespace = regexCheck(/\s/);
+/**
+* Create a code check from a regex.
+*
+* @param {RegExp} regex
+*   Expression.
+* @returns {(code: Code) => boolean}
+*   Check.
+*/
+function regexCheck(regex) {
+	return check;
+	/**
+	* Check whether a code matches the bound regex.
+	*
+	* @param {Code} code
+	*   Character code.
+	* @returns {boolean}
+	*   Whether the character code matches the bound regex.
+	*/
+	function check(code) {
+		return code !== null && code > -1 && regex.test(String.fromCharCode(code));
+	}
+}
+//#endregion
+export { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl, asciiDigit, asciiHexDigit, asciiPunctuation, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace, unicodePunctuation, unicodeWhitespace };

package/dist/src/node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.mjs

@@ -0,0 +1,71 @@
+//#region node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.js
+/**
+* Like `Array#splice`, but smarter for giant arrays.
+*
+* `Array#splice` takes all items to be inserted as individual argument which
+* causes a stack overflow in V8 when trying to insert 100k items for instance.
+*
+* Otherwise, this does not return the removed items, and takes `items` as an
+* array instead of rest parameters.
+*
+* @template {unknown} T
+*   Item type.
+* @param {Array<T>} list
+*   List to operate on.
+* @param {number} start
+*   Index to remove/insert at (can be negative).
+* @param {number} remove
+*   Number of items to remove.
+* @param {Array<T>} items
+*   Items to inject into `list`.
+* @returns {undefined}
+*   Nothing.
+*/
+function splice(list, start, remove, items) {
+	const end = list.length;
+	let chunkStart = 0;
+	/** @type {Array<unknown>} */
+	let parameters;
+	if (start < 0) start = -start > end ? 0 : end + start;
+	else start = start > end ? end : start;
+	remove = remove > 0 ? remove : 0;
+	if (items.length < 1e4) {
+		parameters = Array.from(items);
+		parameters.unshift(start, remove);
+		list.splice(...parameters);
+	} else {
+		if (remove) list.splice(start, remove);
+		while (chunkStart < items.length) {
+			parameters = items.slice(chunkStart, chunkStart + 1e4);
+			parameters.unshift(start, 0);
+			list.splice(...parameters);
+			chunkStart += 1e4;
+			start += 1e4;
+		}
+	}
+}
+/**
+* Append `items` (an array) at the end of `list` (another array).
+* When `list` was empty, returns `items` instead.
+*
+* This prevents a potentially expensive operation when `list` is empty,
+* and adds items in batches to prevent V8 from hanging.
+*
+* @template {unknown} T
+*   Item type.
+* @param {Array<T>} list
+*   List to operate on.
+* @param {Array<T>} items
+*   Items to add to `list`.
+* @returns {Array<T>}
+*   Either `list` or `items`.
+*/
+function push(list, items) {
+	if (list.length > 0) {
+		splice(list, list.length, 0, items);
+		return list;
+	}
+	return items;
+}
+//#endregion
+export { push, splice };

package/dist/src/node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.mjs

@@ -0,0 +1,25 @@
+import { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.js
+/**
+* @import {Code} from 'micromark-util-types'
+*/
+/**
+* Classify whether a code represents whitespace, punctuation, or something
+* else.
+*
+* Used for attention (emphasis, strong), whose sequences can open or close
+* based on the class of surrounding characters.
+*
+* > 👉 **Note**: eof (`null`) is seen as whitespace.
+*
+* @param {Code} code
+*   Code.
+* @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}
+*   Group.
+*/
+function classifyCharacter(code) {
+	if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) return 1;
+	if (unicodePunctuation(code)) return 2;
+}
+//#endregion
+export { classifyCharacter };