cngpac 0.0.1

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

@@ -0,0 +1,177 @@
+import { asciiDigit, 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";
+import { blankLine } from "./blank-line.mjs";
+import { thematicBreak } from "./thematic-break.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Exiter,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const list = {
+	continuation: { tokenize: tokenizeListContinuation },
+	exit: tokenizeListEnd,
+	name: "list",
+	tokenize: tokenizeListStart
+};
+/** @type {Construct} */
+const listItemPrefixWhitespaceConstruct = {
+	partial: true,
+	tokenize: tokenizeListItemPrefixWhitespace
+};
+/** @type {Construct} */
+const indentConstruct = {
+	partial: true,
+	tokenize: tokenizeIndent
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeListStart(effects, ok, nok) {
+	const self = this;
+	const tail = self.events[self.events.length - 1];
+	let initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
+	let size = 0;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? "listUnordered" : "listOrdered");
+		if (kind === "listUnordered" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {
+			if (!self.containerState.type) {
+				self.containerState.type = kind;
+				effects.enter(kind, { _container: true });
+			}
+			if (kind === "listUnordered") {
+				effects.enter("listItemPrefix");
+				return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);
+			}
+			if (!self.interrupt || code === 49) {
+				effects.enter("listItemPrefix");
+				effects.enter("listItemValue");
+				return inside(code);
+			}
+		}
+		return nok(code);
+	}
+	/** @type {State} */
+	function inside(code) {
+		if (asciiDigit(code) && ++size < 10) {
+			effects.consume(code);
+			return inside;
+		}
+		if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {
+			effects.exit("listItemValue");
+			return atMarker(code);
+		}
+		return nok(code);
+	}
+	/**
+	* @type {State}
+	**/
+	function atMarker(code) {
+		effects.enter("listItemMarker");
+		effects.consume(code);
+		effects.exit("listItemMarker");
+		self.containerState.marker = self.containerState.marker || code;
+		return effects.check(blankLine, self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));
+	}
+	/** @type {State} */
+	function onBlank(code) {
+		self.containerState.initialBlankLine = true;
+		initialSize++;
+		return endOfPrefix(code);
+	}
+	/** @type {State} */
+	function otherPrefix(code) {
+		if (markdownSpace(code)) {
+			effects.enter("listItemPrefixWhitespace");
+			effects.consume(code);
+			effects.exit("listItemPrefixWhitespace");
+			return endOfPrefix;
+		}
+		return nok(code);
+	}
+	/** @type {State} */
+	function endOfPrefix(code) {
+		self.containerState.size = initialSize + self.sliceSerialize(effects.exit("listItemPrefix"), true).length;
+		return ok(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeListContinuation(effects, ok, nok) {
+	const self = this;
+	self.containerState._closeFlow = void 0;
+	return effects.check(blankLine, onBlank, notBlank);
+	/** @type {State} */
+	function onBlank(code) {
+		self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;
+		return factorySpace(effects, ok, "listItemIndent", self.containerState.size + 1)(code);
+	}
+	/** @type {State} */
+	function notBlank(code) {
+		if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
+			self.containerState.furtherBlankLines = void 0;
+			self.containerState.initialBlankLine = void 0;
+			return notInCurrentItem(code);
+		}
+		self.containerState.furtherBlankLines = void 0;
+		self.containerState.initialBlankLine = void 0;
+		return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);
+	}
+	/** @type {State} */
+	function notInCurrentItem(code) {
+		self.containerState._closeFlow = true;
+		self.interrupt = void 0;
+		return factorySpace(effects, effects.attempt(list, ok, nok), "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeIndent(effects, ok, nok) {
+	const self = this;
+	return factorySpace(effects, afterPrefix, "listItemIndent", self.containerState.size + 1);
+	/** @type {State} */
+	function afterPrefix(code) {
+		const tail = self.events[self.events.length - 1];
+		return tail && tail[1].type === "listItemIndent" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Exiter}
+*/
+function tokenizeListEnd(effects) {
+	effects.exit(this.containerState.type);
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
+	const self = this;
+	return factorySpace(effects, afterPrefix, "listItemPrefixWhitespace", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 5);
+	/** @type {State} */
+	function afterPrefix(code) {
+		const tail = self.events[self.events.length - 1];
+		return !markdownSpace(code) && tail && tail[1].type === "listItemPrefixWhitespace" ? ok(code) : nok(code);
+	}
+}
+//#endregion
+export { list };

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

@@ -0,0 +1,155 @@
+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/setext-underline.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const setextUnderline = {
+	name: "setextUnderline",
+	resolveTo: resolveToSetextUnderline,
+	tokenize: tokenizeSetextUnderline
+};
+/** @type {Resolver} */
+function resolveToSetextUnderline(events, context) {
+	let index = events.length;
+	/** @type {number | undefined} */
+	let content;
+	/** @type {number | undefined} */
+	let text;
+	/** @type {number | undefined} */
+	let definition;
+	while (index--) if (events[index][0] === "enter") {
+		if (events[index][1].type === "content") {
+			content = index;
+			break;
+		}
+		if (events[index][1].type === "paragraph") text = index;
+	} else {
+		if (events[index][1].type === "content") events.splice(index, 1);
+		if (!definition && events[index][1].type === "definition") definition = index;
+	}
+	const heading = {
+		type: "setextHeading",
+		start: { ...events[content][1].start },
+		end: { ...events[events.length - 1][1].end }
+	};
+	events[text][1].type = "setextHeadingText";
+	if (definition) {
+		events.splice(text, 0, [
+			"enter",
+			heading,
+			context
+		]);
+		events.splice(definition + 1, 0, [
+			"exit",
+			events[content][1],
+			context
+		]);
+		events[content][1].end = { ...events[definition][1].end };
+	} else events[content][1] = heading;
+	events.push([
+		"exit",
+		heading,
+		context
+	]);
+	return events;
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeSetextUnderline(effects, ok, nok) {
+	const self = this;
+	/** @type {NonNullable<Code>} */
+	let marker;
+	return start;
+	/**
+	* At start of heading (setext) underline.
+	*
+	* ```markdown
+	*   | aa
+	* > | ==
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		let index = self.events.length;
+		/** @type {boolean | undefined} */
+		let paragraph;
+		while (index--) if (self.events[index][1].type !== "lineEnding" && self.events[index][1].type !== "linePrefix" && self.events[index][1].type !== "content") {
+			paragraph = self.events[index][1].type === "paragraph";
+			break;
+		}
+		if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {
+			effects.enter("setextHeadingLine");
+			marker = code;
+			return before(code);
+		}
+		return nok(code);
+	}
+	/**
+	* After optional whitespace, at `-` or `=`.
+	*
+	* ```markdown
+	*   | aa
+	* > | ==
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function before(code) {
+		effects.enter("setextHeadingLineSequence");
+		return inside(code);
+	}
+	/**
+	* In sequence.
+	*
+	* ```markdown
+	*   | aa
+	* > | ==
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function inside(code) {
+		if (code === marker) {
+			effects.consume(code);
+			return inside;
+		}
+		effects.exit("setextHeadingLineSequence");
+		return markdownSpace(code) ? factorySpace(effects, after, "lineSuffix")(code) : after(code);
+	}
+	/**
+	* After sequence, after optional whitespace.
+	*
+	* ```markdown
+	*   | aa
+	* > | ==
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		if (code === null || markdownLineEnding(code)) {
+			effects.exit("setextHeadingLine");
+			return ok(code);
+		}
+		return nok(code);
+	}
+}
+//#endregion
+export { setextUnderline };

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

@@ -0,0 +1,98 @@
+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/thematic-break.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const thematicBreak = {
+	name: "thematicBreak",
+	tokenize: tokenizeThematicBreak
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeThematicBreak(effects, ok, nok) {
+	let size = 0;
+	/** @type {NonNullable<Code>} */
+	let marker;
+	return start;
+	/**
+	* Start of thematic break.
+	*
+	* ```markdown
+	* > | ***
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("thematicBreak");
+		return before(code);
+	}
+	/**
+	* After optional whitespace, at marker.
+	*
+	* ```markdown
+	* > | ***
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function before(code) {
+		marker = code;
+		return atBreak(code);
+	}
+	/**
+	* After something, before something else.
+	*
+	* ```markdown
+	* > | ***
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function atBreak(code) {
+		if (code === marker) {
+			effects.enter("thematicBreakSequence");
+			return sequence(code);
+		}
+		if (size >= 3 && (code === null || markdownLineEnding(code))) {
+			effects.exit("thematicBreak");
+			return ok(code);
+		}
+		return nok(code);
+	}
+	/**
+	* In sequence.
+	*
+	* ```markdown
+	* > | ***
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function sequence(code) {
+		if (code === marker) {
+			effects.consume(code);
+			size++;
+			return sequence;
+		}
+		effects.exit("thematicBreakSequence");
+		return markdownSpace(code) ? factorySpace(effects, atBreak, "whitespace")(code) : atBreak(code);
+	}
+}
+//#endregion
+export { thematicBreak };