cngpac 0.0.1

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.mjs

@@ -0,0 +1,24 @@
+import { toString } from "../../../../../mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.mjs";
+import { visit } from "../../../../../unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Heading} from 'mdast'
+*/
+/**
+* @param {Heading} node
+* @param {State} state
+* @returns {boolean}
+*/
+function formatHeadingAsSetext(node, state) {
+	let literalWithBreak = false;
+	visit(node, function(node) {
+		if ("value" in node && /\r?\n|\r/.test(node.value) || node.type === "break") {
+			literalWithBreak = true;
+			return false;
+		}
+	});
+	return Boolean((!node.depth || node.depth < 3) && toString(node) && (state.options.setext || literalWithBreak));
+}
+//#endregion
+export { formatHeadingAsSetext };

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.mjs

@@ -0,0 +1,17 @@
+import { toString } from "../../../../../mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Link} from 'mdast'
+*/
+/**
+* @param {Link} node
+* @param {State} state
+* @returns {boolean}
+*/
+function formatLinkAsAutolink(node, state) {
+	const raw = toString(node);
+	return Boolean(!state.options.resourceLink && node.url && !node.title && node.children && node.children.length === 1 && node.children[0].type === "text" && (raw === node.url || "mailto:" + raw === node.url) && /^[a-z][a-z+.-]+:/i.test(node.url) && !/[\0- <>\u007F]/.test(node.url));
+}
+//#endregion
+export { formatLinkAsAutolink };

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/indent-lines.mjs

@@ -0,0 +1,32 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
+/**
+* @import {IndentLines} from '../types.js'
+*/
+const eol = /\r?\n|\r/g;
+/**
+* @type {IndentLines}
+*/
+function indentLines(value, map) {
+	/** @type {Array<string>} */
+	const result = [];
+	let start = 0;
+	let line = 0;
+	/** @type {RegExpExecArray | null} */
+	let match;
+	while (match = eol.exec(value)) {
+		one(value.slice(start, match.index));
+		result.push(match[0]);
+		start = match.index + match[0].length;
+		line++;
+	}
+	one(value.slice(start));
+	return result.join("");
+	/**
+	* @param {string} value
+	*/
+	function one(value) {
+		result.push(map(value, line, !value));
+	}
+}
+//#endregion
+export { indentLines };

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.mjs

@@ -0,0 +1,27 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+/**
+* @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {Array<ConstructName>} stack
+* @param {Unsafe} pattern
+* @returns {boolean}
+*/
+function patternInScope(stack, pattern) {
+	return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
+}
+/**
+* @param {Array<ConstructName>} stack
+* @param {Unsafe['inConstruct']} list
+* @param {boolean} none
+* @returns {boolean}
+*/
+function listInScope(stack, list, none) {
+	if (typeof list === "string") list = [list];
+	if (!list || list.length === 0) return none;
+	let index = -1;
+	while (++index < list.length) if (stack.includes(list[index])) return true;
+	return false;
+}
+//#endregion
+export { patternInScope };

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/safe.mjs

@@ -0,0 +1,116 @@
+import { patternInScope } from "./pattern-in-scope.mjs";
+import { encodeCharacterReference } from "./encode-character-reference.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/safe.js
+/**
+* @import {SafeConfig, State} from 'mdast-util-to-markdown'
+*/
+/**
+* Make a string safe for embedding in markdown constructs.
+*
+* In markdown, almost all punctuation characters can, in certain cases,
+* result in something.
+* Whether they do is highly subjective to where they happen and in what
+* they happen.
+*
+* To solve this, `mdast-util-to-markdown` tracks:
+*
+* * Characters before and after something;
+* * What “constructs” we are in.
+*
+* This information is then used by this function to escape or encode
+* special characters.
+*
+* @param {State} state
+*   Info passed around about the current state.
+* @param {string | null | undefined} input
+*   Raw value to make safe.
+* @param {SafeConfig} config
+*   Configuration.
+* @returns {string}
+*   Serialized markdown safe for embedding.
+*/
+function safe(state, input, config) {
+	const value = (config.before || "") + (input || "") + (config.after || "");
+	/** @type {Array<number>} */
+	const positions = [];
+	/** @type {Array<string>} */
+	const result = [];
+	/** @type {Record<number, {before: boolean, after: boolean}>} */
+	const infos = {};
+	let index = -1;
+	while (++index < state.unsafe.length) {
+		const pattern = state.unsafe[index];
+		if (!patternInScope(state.stack, pattern)) continue;
+		const expression = state.compilePattern(pattern);
+		/** @type {RegExpExecArray | null} */
+		let match;
+		while (match = expression.exec(value)) {
+			const before = "before" in pattern || Boolean(pattern.atBreak);
+			const after = "after" in pattern;
+			const position = match.index + (before ? match[1].length : 0);
+			if (positions.includes(position)) {
+				if (infos[position].before && !before) infos[position].before = false;
+				if (infos[position].after && !after) infos[position].after = false;
+			} else {
+				positions.push(position);
+				infos[position] = {
+					before,
+					after
+				};
+			}
+		}
+	}
+	positions.sort(numerical);
+	let start = config.before ? config.before.length : 0;
+	const end = value.length - (config.after ? config.after.length : 0);
+	index = -1;
+	while (++index < positions.length) {
+		const position = positions[index];
+		if (position < start || position >= end) continue;
+		if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) continue;
+		if (start !== position) result.push(escapeBackslashes(value.slice(start, position), "\\"));
+		start = position;
+		if (/[!-/:-@[-`{-~]/.test(value.charAt(position)) && (!config.encode || !config.encode.includes(value.charAt(position)))) result.push("\\");
+		else {
+			result.push(encodeCharacterReference(value.charCodeAt(position)));
+			start++;
+		}
+	}
+	result.push(escapeBackslashes(value.slice(start, end), config.after));
+	return result.join("");
+}
+/**
+* @param {number} a
+* @param {number} b
+* @returns {number}
+*/
+function numerical(a, b) {
+	return a - b;
+}
+/**
+* @param {string} value
+* @param {string} after
+* @returns {string}
+*/
+function escapeBackslashes(value, after) {
+	const expression = /\\(?=[!-/:-@[-`{-~])/g;
+	/** @type {Array<number>} */
+	const positions = [];
+	/** @type {Array<string>} */
+	const results = [];
+	const whole = value + after;
+	let index = -1;
+	let start = 0;
+	/** @type {RegExpExecArray | null} */
+	let match;
+	while (match = expression.exec(whole)) positions.push(match.index);
+	while (++index < positions.length) {
+		if (start !== positions[index]) results.push(value.slice(start, positions[index]));
+		results.push("\\");
+		start = positions[index];
+	}
+	results.push(value.slice(start));
+	return results.join("");
+}
+//#endregion
+export { safe };

package/dist/src/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/track.mjs

@@ -0,0 +1,59 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/track.js
+/**
+* @import {CreateTracker, TrackCurrent, TrackMove, TrackShift} from '../types.js'
+*/
+/**
+* Track positional info in the output.
+*
+* @type {CreateTracker}
+*/
+function track(config) {
+	/* c8 ignore next 5 */
+	const options = config || {};
+	const now = options.now || {};
+	let lineShift = options.lineShift || 0;
+	let line = now.line || 1;
+	let column = now.column || 1;
+	return {
+		move,
+		current,
+		shift
+	};
+	/**
+	* Get the current tracked info.
+	*
+	* @type {TrackCurrent}
+	*/
+	function current() {
+		return {
+			now: {
+				line,
+				column
+			},
+			lineShift
+		};
+	}
+	/**
+	* Define an increased line shift (the typical indent for lines).
+	*
+	* @type {TrackShift}
+	*/
+	function shift(value) {
+		lineShift += value;
+	}
+	/**
+	* Move past some generated markdown.
+	*
+	* @type {TrackMove}
+	*/
+	function move(input) {
+		const value = input || "";
+		const chunks = value.split(/\r?\n|\r/g);
+		const tail = chunks[chunks.length - 1];
+		line += chunks.length - 1;
+		column = chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift;
+		return value;
+	}
+}
+//#endregion
+export { track };

package/dist/src/node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.mjs

@@ -0,0 +1,83 @@
+//#region node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js
+/**
+* @typedef {import('mdast').Nodes} Nodes
+*
+* @typedef Options
+*   Configuration (optional).
+* @property {boolean | null | undefined} [includeImageAlt=true]
+*   Whether to use `alt` for `image`s (default: `true`).
+* @property {boolean | null | undefined} [includeHtml=true]
+*   Whether to use `value` of HTML (default: `true`).
+*/
+/** @type {Options} */
+const emptyOptions = {};
+/**
+* Get the text content of a node or list of nodes.
+*
+* Prefers the node’s plain-text fields, otherwise serializes its children,
+* and if the given value is an array, serialize the nodes in it.
+*
+* @param {unknown} [value]
+*   Thing to serialize, typically `Node`.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Serialized `value`.
+*/
+function toString(value, options) {
+	const settings = options || emptyOptions;
+	return one(value, typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true, typeof settings.includeHtml === "boolean" ? settings.includeHtml : true);
+}
+/**
+* One node or several nodes.
+*
+* @param {unknown} value
+*   Thing to serialize.
+* @param {boolean} includeImageAlt
+*   Include image `alt`s.
+* @param {boolean} includeHtml
+*   Include HTML.
+* @returns {string}
+*   Serialized node.
+*/
+function one(value, includeImageAlt, includeHtml) {
+	if (node(value)) {
+		if ("value" in value) return value.type === "html" && !includeHtml ? "" : value.value;
+		if (includeImageAlt && "alt" in value && value.alt) return value.alt;
+		if ("children" in value) return all(value.children, includeImageAlt, includeHtml);
+	}
+	if (Array.isArray(value)) return all(value, includeImageAlt, includeHtml);
+	return "";
+}
+/**
+* Serialize a list of nodes.
+*
+* @param {Array<unknown>} values
+*   Thing to serialize.
+* @param {boolean} includeImageAlt
+*   Include image `alt`s.
+* @param {boolean} includeHtml
+*   Include HTML.
+* @returns {string}
+*   Serialized nodes.
+*/
+function all(values, includeImageAlt, includeHtml) {
+	/** @type {Array<string>} */
+	const result = [];
+	let index = -1;
+	while (++index < values.length) result[index] = one(values[index], includeImageAlt, includeHtml);
+	return result.join("");
+}
+/**
+* Check if `value` looks like a node.
+*
+* @param {unknown} value
+*   Thing.
+* @returns {value is Nodes}
+*   Whether `value` is a node.
+*/
+function node(value) {
+	return Boolean(value && typeof value === "object");
+}
+//#endregion
+export { toString };

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

@@ -0,0 +1,224 @@
+import { push, splice } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.mjs";
+import { classifyCharacter } from "../../../../micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.mjs";
+import { resolveAll } from "../../../../micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.mjs";
+//#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Event,
+*   Point,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const attention = {
+	name: "attention",
+	resolveAll: resolveAllAttention,
+	tokenize: tokenizeAttention
+};
+/**
+* Take all events and resolve attention to emphasis or strong.
+*
+* @type {Resolver}
+*/
+function resolveAllAttention(events, context) {
+	let index = -1;
+	/** @type {number} */
+	let open;
+	/** @type {Token} */
+	let group;
+	/** @type {Token} */
+	let text;
+	/** @type {Token} */
+	let openingSequence;
+	/** @type {Token} */
+	let closingSequence;
+	/** @type {number} */
+	let use;
+	/** @type {Array<Event>} */
+	let nextEvents;
+	/** @type {number} */
+	let offset;
+	while (++index < events.length) if (events[index][0] === "enter" && events[index][1].type === "attentionSequence" && events[index][1]._close) {
+		open = index;
+		while (open--) if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
+			if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) continue;
+			use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
+			const start = { ...events[open][1].end };
+			const end = { ...events[index][1].start };
+			movePoint(start, -use);
+			movePoint(end, use);
+			openingSequence = {
+				type: use > 1 ? "strongSequence" : "emphasisSequence",
+				start,
+				end: { ...events[open][1].end }
+			};
+			closingSequence = {
+				type: use > 1 ? "strongSequence" : "emphasisSequence",
+				start: { ...events[index][1].start },
+				end
+			};
+			text = {
+				type: use > 1 ? "strongText" : "emphasisText",
+				start: { ...events[open][1].end },
+				end: { ...events[index][1].start }
+			};
+			group = {
+				type: use > 1 ? "strong" : "emphasis",
+				start: { ...openingSequence.start },
+				end: { ...closingSequence.end }
+			};
+			events[open][1].end = { ...openingSequence.start };
+			events[index][1].start = { ...closingSequence.end };
+			nextEvents = [];
+			if (events[open][1].end.offset - events[open][1].start.offset) nextEvents = push(nextEvents, [[
+				"enter",
+				events[open][1],
+				context
+			], [
+				"exit",
+				events[open][1],
+				context
+			]]);
+			nextEvents = push(nextEvents, [
+				[
+					"enter",
+					group,
+					context
+				],
+				[
+					"enter",
+					openingSequence,
+					context
+				],
+				[
+					"exit",
+					openingSequence,
+					context
+				],
+				[
+					"enter",
+					text,
+					context
+				]
+			]);
+			nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));
+			nextEvents = push(nextEvents, [
+				[
+					"exit",
+					text,
+					context
+				],
+				[
+					"enter",
+					closingSequence,
+					context
+				],
+				[
+					"exit",
+					closingSequence,
+					context
+				],
+				[
+					"exit",
+					group,
+					context
+				]
+			]);
+			if (events[index][1].end.offset - events[index][1].start.offset) {
+				offset = 2;
+				nextEvents = push(nextEvents, [[
+					"enter",
+					events[index][1],
+					context
+				], [
+					"exit",
+					events[index][1],
+					context
+				]]);
+			} else offset = 0;
+			splice(events, open - 1, index - open + 3, nextEvents);
+			index = open + nextEvents.length - offset - 2;
+			break;
+		}
+	}
+	index = -1;
+	while (++index < events.length) if (events[index][1].type === "attentionSequence") events[index][1].type = "data";
+	return events;
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeAttention(effects, ok) {
+	const attentionMarkers = this.parser.constructs.attentionMarkers.null;
+	const previous = this.previous;
+	const before = classifyCharacter(previous);
+	/** @type {NonNullable<Code>} */
+	let marker;
+	return start;
+	/**
+	* Before a sequence.
+	*
+	* ```markdown
+	* > | **
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		marker = code;
+		effects.enter("attentionSequence");
+		return inside(code);
+	}
+	/**
+	* In a sequence.
+	*
+	* ```markdown
+	* > | **
+	*     ^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function inside(code) {
+		if (code === marker) {
+			effects.consume(code);
+			return inside;
+		}
+		const token = effects.exit("attentionSequence");
+		const after = classifyCharacter(code);
+		const open = !after || after === 2 && before || attentionMarkers.includes(code);
+		const close = !before || before === 2 && after || attentionMarkers.includes(previous);
+		token._open = Boolean(marker === 42 ? open : open && (before || !close));
+		token._close = Boolean(marker === 42 ? close : close && (after || !open));
+		return ok(code);
+	}
+}
+/**
+* Move a point a bit.
+*
+* Note: `move` only works inside lines! It’s not possible to move past other
+* chunks (replacement characters, tabs, or line endings).
+*
+* @param {Point} point
+*   Point.
+* @param {number} offset
+*   Amount to move.
+* @returns {undefined}
+*   Nothing.
+*/
+function movePoint(point, offset) {
+	point.column += offset;
+	point.offset += offset;
+	point._bufferIndex += offset;
+}
+//#endregion
+export { attention };