cngpac 0.0.1

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

@@ -0,0 +1,187 @@
+import { markdownLineEnding } 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/code-text.js
+/**
+* @import {
+*   Construct,
+*   Previous,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const codeText = {
+	name: "codeText",
+	previous,
+	resolve: resolveCodeText,
+	tokenize: tokenizeCodeText
+};
+/** @type {Resolver} */
+function resolveCodeText(events) {
+	let tailExitIndex = events.length - 4;
+	let headEnterIndex = 3;
+	/** @type {number} */
+	let index;
+	/** @type {number | undefined} */
+	let enter;
+	if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
+		index = headEnterIndex;
+		while (++index < tailExitIndex) if (events[index][1].type === "codeTextData") {
+			events[headEnterIndex][1].type = "codeTextPadding";
+			events[tailExitIndex][1].type = "codeTextPadding";
+			headEnterIndex += 2;
+			tailExitIndex -= 2;
+			break;
+		}
+	}
+	index = headEnterIndex - 1;
+	tailExitIndex++;
+	while (++index <= tailExitIndex) if (enter === void 0) {
+		if (index !== tailExitIndex && events[index][1].type !== "lineEnding") enter = index;
+	} else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
+		events[enter][1].type = "codeTextData";
+		if (index !== enter + 2) {
+			events[enter][1].end = events[index - 1][1].end;
+			events.splice(enter + 2, index - enter - 2);
+			tailExitIndex -= index - enter - 2;
+			index = enter + 2;
+		}
+		enter = void 0;
+	}
+	return events;
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Previous}
+*/
+function previous(code) {
+	return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeCodeText(effects, ok, nok) {
+	let sizeOpen = 0;
+	/** @type {number} */
+	let size;
+	/** @type {Token} */
+	let token;
+	return start;
+	/**
+	* Start of code (text).
+	*
+	* ```markdown
+	* > | `a`
+	*     ^
+	* > | \`a`
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("codeText");
+		effects.enter("codeTextSequence");
+		return sequenceOpen(code);
+	}
+	/**
+	* In opening sequence.
+	*
+	* ```markdown
+	* > | `a`
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function sequenceOpen(code) {
+		if (code === 96) {
+			effects.consume(code);
+			sizeOpen++;
+			return sequenceOpen;
+		}
+		effects.exit("codeTextSequence");
+		return between(code);
+	}
+	/**
+	* Between something and something else.
+	*
+	* ```markdown
+	* > | `a`
+	*      ^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function between(code) {
+		if (code === null) return nok(code);
+		if (code === 32) {
+			effects.enter("space");
+			effects.consume(code);
+			effects.exit("space");
+			return between;
+		}
+		if (code === 96) {
+			token = effects.enter("codeTextSequence");
+			size = 0;
+			return sequenceClose(code);
+		}
+		if (markdownLineEnding(code)) {
+			effects.enter("lineEnding");
+			effects.consume(code);
+			effects.exit("lineEnding");
+			return between;
+		}
+		effects.enter("codeTextData");
+		return data(code);
+	}
+	/**
+	* In data.
+	*
+	* ```markdown
+	* > | `a`
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function data(code) {
+		if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {
+			effects.exit("codeTextData");
+			return between(code);
+		}
+		effects.consume(code);
+		return data;
+	}
+	/**
+	* In closing sequence.
+	*
+	* ```markdown
+	* > | `a`
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function sequenceClose(code) {
+		if (code === 96) {
+			effects.consume(code);
+			size++;
+			return sequenceClose;
+		}
+		if (size === sizeOpen) {
+			effects.exit("codeTextSequence");
+			effects.exit("codeText");
+			return ok(code);
+		}
+		token.type = "codeTextData";
+		return data(code);
+	}
+}
+//#endregion
+export { codeText };

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

@@ -0,0 +1,137 @@
+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";
+import { subtokenize } from "../../../../micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.js
+/**
+* @import {
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
+* No name because it must not be turned off.
+* @type {Construct}
+*/
+const content = {
+	resolve: resolveContent,
+	tokenize: tokenizeContent
+};
+/** @type {Construct} */
+const continuationConstruct = {
+	partial: true,
+	tokenize: tokenizeContinuation
+};
+/**
+* Content is transparent: it’s parsed right now. That way, definitions are also
+* parsed right now: before text in paragraphs (specifically, media) are parsed.
+*
+* @type {Resolver}
+*/
+function resolveContent(events) {
+	subtokenize(events);
+	return events;
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeContent(effects, ok) {
+	/** @type {Token | undefined} */
+	let previous;
+	return chunkStart;
+	/**
+	* Before a content chunk.
+	*
+	* ```markdown
+	* > | abc
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function chunkStart(code) {
+		effects.enter("content");
+		previous = effects.enter("chunkContent", { contentType: "content" });
+		return chunkInside(code);
+	}
+	/**
+	* In a content chunk.
+	*
+	* ```markdown
+	* > | abc
+	*     ^^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function chunkInside(code) {
+		if (code === null) return contentEnd(code);
+		if (markdownLineEnding(code)) return effects.check(continuationConstruct, contentContinue, contentEnd)(code);
+		effects.consume(code);
+		return chunkInside;
+	}
+	/**
+	*
+	*
+	* @type {State}
+	*/
+	function contentEnd(code) {
+		effects.exit("chunkContent");
+		effects.exit("content");
+		return ok(code);
+	}
+	/**
+	*
+	*
+	* @type {State}
+	*/
+	function contentContinue(code) {
+		effects.consume(code);
+		effects.exit("chunkContent");
+		previous.next = effects.enter("chunkContent", {
+			contentType: "content",
+			previous
+		});
+		previous = previous.next;
+		return chunkInside;
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeContinuation(effects, ok, nok) {
+	const self = this;
+	return startLookahead;
+	/**
+	*
+	*
+	* @type {State}
+	*/
+	function startLookahead(code) {
+		effects.exit("chunkContent");
+		effects.enter("lineEnding");
+		effects.consume(code);
+		effects.exit("lineEnding");
+		return factorySpace(effects, prefixed, "linePrefix");
+	}
+	/**
+	*
+	*
+	* @type {State}
+	*/
+	function prefixed(code) {
+		if (code === null || markdownLineEnding(code)) return nok(code);
+		const tail = self.events[self.events.length - 1];
+		if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) return ok(code);
+		return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);
+	}
+}
+//#endregion
+export { content };

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

@@ -0,0 +1,223 @@
+import { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { normalizeIdentifier } from "../../../../micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.mjs";
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.mjs";
+import { factoryDestination } from "../../../../micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.mjs";
+import { factoryLabel } from "../../../../micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.mjs";
+import { factoryTitle } from "../../../../micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.mjs";
+import { factoryWhitespace } from "../../../../micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const definition = {
+	name: "definition",
+	tokenize: tokenizeDefinition
+};
+/** @type {Construct} */
+const titleBefore = {
+	partial: true,
+	tokenize: tokenizeTitleBefore
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeDefinition(effects, ok, nok) {
+	const self = this;
+	/** @type {string} */
+	let identifier;
+	return start;
+	/**
+	* At start of a definition.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("definition");
+		return before(code);
+	}
+	/**
+	* After optional whitespace, at `[`.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function before(code) {
+		return factoryLabel.call(self, effects, labelAfter, nok, "definitionLabel", "definitionLabelMarker", "definitionLabelString")(code);
+	}
+	/**
+	* After label.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelAfter(code) {
+		identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));
+		if (code === 58) {
+			effects.enter("definitionMarker");
+			effects.consume(code);
+			effects.exit("definitionMarker");
+			return markerAfter;
+		}
+		return nok(code);
+	}
+	/**
+	* After marker.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function markerAfter(code) {
+		return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);
+	}
+	/**
+	* Before destination.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*          ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function destinationBefore(code) {
+		return factoryDestination(effects, destinationAfter, nok, "definitionDestination", "definitionDestinationLiteral", "definitionDestinationLiteralMarker", "definitionDestinationRaw", "definitionDestinationString")(code);
+	}
+	/**
+	* After destination.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*           ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function destinationAfter(code) {
+		return effects.attempt(titleBefore, after, after)(code);
+	}
+	/**
+	* After definition.
+	*
+	* ```markdown
+	* > | [a]: b
+	*           ^
+	* > | [a]: b "c"
+	*               ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		return markdownSpace(code) ? factorySpace(effects, afterWhitespace, "whitespace")(code) : afterWhitespace(code);
+	}
+	/**
+	* After definition, after optional whitespace.
+	*
+	* ```markdown
+	* > | [a]: b
+	*           ^
+	* > | [a]: b "c"
+	*               ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function afterWhitespace(code) {
+		if (code === null || markdownLineEnding(code)) {
+			effects.exit("definition");
+			self.parser.defined.push(identifier);
+			return ok(code);
+		}
+		return nok(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeTitleBefore(effects, ok, nok) {
+	return titleBefore;
+	/**
+	* After destination, at whitespace.
+	*
+	* ```markdown
+	* > | [a]: b
+	*           ^
+	* > | [a]: b "c"
+	*           ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function titleBefore(code) {
+		return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);
+	}
+	/**
+	* At title.
+	*
+	* ```markdown
+	*   | [a]: b
+	* > | "c"
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function beforeMarker(code) {
+		return factoryTitle(effects, titleAfter, nok, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(code);
+	}
+	/**
+	* After title.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*               ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function titleAfter(code) {
+		return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, "whitespace")(code) : titleAfterOptionalWhitespace(code);
+	}
+	/**
+	* After title, after optional whitespace.
+	*
+	* ```markdown
+	* > | [a]: b "c"
+	*               ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function titleAfterOptionalWhitespace(code) {
+		return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
+	}
+}
+//#endregion
+export { definition };

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

@@ -0,0 +1,59 @@
+import { markdownLineEnding } 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/hard-break-escape.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const hardBreakEscape = {
+	name: "hardBreakEscape",
+	tokenize: tokenizeHardBreakEscape
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeHardBreakEscape(effects, ok, nok) {
+	return start;
+	/**
+	* Start of a hard break (escape).
+	*
+	* ```markdown
+	* > | a\
+	*      ^
+	*   | b
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("hardBreakEscape");
+		effects.consume(code);
+		return after;
+	}
+	/**
+	* After `\`, at eol.
+	*
+	* ```markdown
+	* > | a\
+	*       ^
+	*   | b
+	* ```
+	*
+	*  @type {State}
+	*/
+	function after(code) {
+		if (markdownLineEnding(code)) {
+			effects.exit("hardBreakEscape");
+			return ok(code);
+		}
+		return nok(code);
+	}
+}
+//#endregion
+export { hardBreakEscape };