cngpac 0.0.1

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

@@ -0,0 +1,47 @@
+import { blockquote } from "./blockquote.mjs";
+import { hardBreak } from "./break.mjs";
+import { code } from "./code.mjs";
+import { definition } from "./definition.mjs";
+import { emphasis } from "./emphasis.mjs";
+import { heading } from "./heading.mjs";
+import { html } from "./html.mjs";
+import { image } from "./image.mjs";
+import { imageReference } from "./image-reference.mjs";
+import { inlineCode } from "./inline-code.mjs";
+import { link } from "./link.mjs";
+import { linkReference } from "./link-reference.mjs";
+import { list } from "./list.mjs";
+import { listItem } from "./list-item.mjs";
+import { paragraph } from "./paragraph.mjs";
+import { root } from "./root.mjs";
+import { strong } from "./strong.mjs";
+import { text } from "./text.mjs";
+import { thematicBreak } from "./thematic-break.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/index.js
+/**
+* Default (CommonMark) handlers.
+*/
+const handle = {
+	blockquote,
+	break: hardBreak,
+	code,
+	definition,
+	emphasis,
+	hardBreak,
+	heading,
+	html,
+	image,
+	imageReference,
+	inlineCode,
+	link,
+	linkReference,
+	list,
+	listItem,
+	paragraph,
+	root,
+	strong,
+	text,
+	thematicBreak
+};
+//#endregion
+export { handle };

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

@@ -0,0 +1,40 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {InlineCode, Parents} from 'mdast'
+*/
+inlineCode.peek = inlineCodePeek;
+/**
+* @param {InlineCode} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @returns {string}
+*/
+function inlineCode(node, _, state) {
+	let value = node.value || "";
+	let sequence = "`";
+	let index = -1;
+	while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) sequence += "`";
+	if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) value = " " + value + " ";
+	while (++index < state.unsafe.length) {
+		const pattern = state.unsafe[index];
+		const expression = state.compilePattern(pattern);
+		/** @type {RegExpExecArray | null} */
+		let match;
+		if (!pattern.atBreak) continue;
+		while (match = expression.exec(value)) {
+			let position = match.index;
+			if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) position--;
+			value = value.slice(0, position) + " " + value.slice(match.index + 1);
+		}
+	}
+	return sequence + value + sequence;
+}
+/**
+* @returns {string}
+*/
+function inlineCodePeek() {
+	return "`";
+}
+//#endregion
+export { inlineCode };

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

@@ -0,0 +1,50 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link-reference.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {LinkReference, Parents} from 'mdast'
+*/
+linkReference.peek = linkReferencePeek;
+/**
+* @param {LinkReference} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function linkReference(node, _, state, info) {
+	const type = node.referenceType;
+	const exit = state.enter("linkReference");
+	let subexit = state.enter("label");
+	const tracker = state.createTracker(info);
+	let value = tracker.move("[");
+	const text = state.containerPhrasing(node, {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	value += tracker.move(text + "][");
+	subexit();
+	const stack = state.stack;
+	state.stack = [];
+	subexit = state.enter("reference");
+	const reference = state.safe(state.associationId(node), {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	subexit();
+	state.stack = stack;
+	exit();
+	if (type === "full" || !text || text !== reference) value += tracker.move(reference + "]");
+	else if (type === "shortcut") value = value.slice(0, -1);
+	else value += tracker.move("]");
+	return value;
+}
+/**
+* @returns {string}
+*/
+function linkReferencePeek() {
+	return "[";
+}
+//#endregion
+export { linkReference };

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

@@ -0,0 +1,93 @@
+import { checkQuote } from "../util/check-quote.mjs";
+import { formatLinkAsAutolink } from "../util/format-link-as-autolink.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Link, Parents} from 'mdast'
+* @import {Exit} from '../types.js'
+*/
+link.peek = linkPeek;
+/**
+* @param {Link} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function link(node, _, state, info) {
+	const quote = checkQuote(state);
+	const suffix = quote === "\"" ? "Quote" : "Apostrophe";
+	const tracker = state.createTracker(info);
+	/** @type {Exit} */
+	let exit;
+	/** @type {Exit} */
+	let subexit;
+	if (formatLinkAsAutolink(node, state)) {
+		const stack = state.stack;
+		state.stack = [];
+		exit = state.enter("autolink");
+		let value = tracker.move("<");
+		value += tracker.move(state.containerPhrasing(node, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+		exit();
+		state.stack = stack;
+		return value;
+	}
+	exit = state.enter("link");
+	subexit = state.enter("label");
+	let value = tracker.move("[");
+	value += tracker.move(state.containerPhrasing(node, {
+		before: value,
+		after: "](",
+		...tracker.current()
+	}));
+	value += tracker.move("](");
+	subexit();
+	if (!node.url && node.title || /[\0- \u007F]/.test(node.url)) {
+		subexit = state.enter("destinationLiteral");
+		value += tracker.move("<");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+	} else {
+		subexit = state.enter("destinationRaw");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: node.title ? " " : ")",
+			...tracker.current()
+		}));
+	}
+	subexit();
+	if (node.title) {
+		subexit = state.enter(`title${suffix}`);
+		value += tracker.move(" " + quote);
+		value += tracker.move(state.safe(node.title, {
+			before: value,
+			after: quote,
+			...tracker.current()
+		}));
+		value += tracker.move(quote);
+		subexit();
+	}
+	value += tracker.move(")");
+	exit();
+	return value;
+}
+/**
+* @param {Link} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @returns {string}
+*/
+function linkPeek(node, _, state) {
+	return formatLinkAsAutolink(node, state) ? "<" : "[";
+}
+//#endregion
+export { link };

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

@@ -0,0 +1,35 @@
+import { checkBullet } from "../util/check-bullet.mjs";
+import { checkListItemIndent } from "../util/check-list-item-indent.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+/**
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+* @import {ListItem, Parents} from 'mdast'
+*/
+/**
+* @param {ListItem} node
+* @param {Parents | undefined} parent
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function listItem(node, parent, state, info) {
+	const listItemIndent = checkListItemIndent(state);
+	let bullet = state.bulletCurrent || checkBullet(state);
+	if (parent && parent.type === "list" && parent.ordered) bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
+	let size = bullet.length + 1;
+	if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) size = Math.ceil(size / 4) * 4;
+	const tracker = state.createTracker(info);
+	tracker.move(bullet + " ".repeat(size - bullet.length));
+	tracker.shift(size);
+	const exit = state.enter("listItem");
+	const value = state.indentLines(state.containerFlow(node, tracker.current()), map);
+	exit();
+	return value;
+	/** @type {Map} */
+	function map(line, index, blank) {
+		if (index) return (blank ? "" : " ".repeat(size)) + line;
+		return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+	}
+}
+//#endregion
+export { listItem };

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

@@ -0,0 +1,48 @@
+import { checkBullet } from "../util/check-bullet.mjs";
+import { checkBulletOther } from "../util/check-bullet-other.mjs";
+import { checkBulletOrdered } from "../util/check-bullet-ordered.mjs";
+import { checkRule } from "../util/check-rule.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {List, Parents} from 'mdast'
+*/
+/**
+* @param {List} node
+* @param {Parents | undefined} parent
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function list(node, parent, state, info) {
+	const exit = state.enter("list");
+	const bulletCurrent = state.bulletCurrent;
+	/** @type {string} */
+	let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state);
+	/** @type {string} */
+	const bulletOther = node.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state);
+	let useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
+	if (!node.ordered) {
+		const firstListItem = node.children ? node.children[0] : void 0;
+		if ((bullet === "*" || bullet === "-") && firstListItem && (!firstListItem.children || !firstListItem.children[0]) && state.stack[state.stack.length - 1] === "list" && state.stack[state.stack.length - 2] === "listItem" && state.stack[state.stack.length - 3] === "list" && state.stack[state.stack.length - 4] === "listItem" && state.indexStack[state.indexStack.length - 1] === 0 && state.indexStack[state.indexStack.length - 2] === 0 && state.indexStack[state.indexStack.length - 3] === 0) useDifferentMarker = true;
+		if (checkRule(state) === bullet && firstListItem) {
+			let index = -1;
+			while (++index < node.children.length) {
+				const item = node.children[index];
+				if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
+					useDifferentMarker = true;
+					break;
+				}
+			}
+		}
+	}
+	if (useDifferentMarker) bullet = bulletOther;
+	state.bulletCurrent = bullet;
+	const value = state.containerFlow(node, info);
+	state.bulletLastUsed = bullet;
+	state.bulletCurrent = bulletCurrent;
+	exit();
+	return value;
+}
+//#endregion
+export { list };

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

@@ -0,0 +1,22 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Paragraph, Parents} from 'mdast'
+*/
+/**
+* @param {Paragraph} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function paragraph(node, _, state, info) {
+	const exit = state.enter("paragraph");
+	const subexit = state.enter("phrasing");
+	const value = state.containerPhrasing(node, info);
+	subexit();
+	exit();
+	return value;
+}
+//#endregion
+export { paragraph };

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

@@ -0,0 +1,20 @@
+import { phrasing } from "../../../../../mdast-util-phrasing@4.1.0/node_modules/mdast-util-phrasing/lib/index.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/root.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Root} from 'mdast'
+*/
+/**
+* @param {Root} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function root(node, _, state, info) {
+	return (node.children.some(function(d) {
+		return phrasing(d);
+	}) ? state.containerPhrasing : state.containerFlow).call(state, node, info);
+}
+//#endregion
+export { root };

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

@@ -0,0 +1,51 @@
+import { encodeCharacterReference } from "../util/encode-character-reference.mjs";
+import { encodeInfo } from "../util/encode-info.mjs";
+import { checkStrong } from "../util/check-strong.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/strong.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Strong} from 'mdast'
+*/
+strong.peek = strongPeek;
+/**
+* @param {Strong} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function strong(node, _, state, info) {
+	const marker = checkStrong(state);
+	const exit = state.enter("strong");
+	const tracker = state.createTracker(info);
+	const before = tracker.move(marker + marker);
+	let between = tracker.move(state.containerPhrasing(node, {
+		after: marker,
+		before,
+		...tracker.current()
+	}));
+	const betweenHead = between.charCodeAt(0);
+	const open = encodeInfo(info.before.charCodeAt(info.before.length - 1), betweenHead, marker);
+	if (open.inside) between = encodeCharacterReference(betweenHead) + between.slice(1);
+	const betweenTail = between.charCodeAt(between.length - 1);
+	const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+	if (close.inside) between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+	const after = tracker.move(marker + marker);
+	exit();
+	state.attentionEncodeSurroundingInfo = {
+		after: close.outside,
+		before: open.outside
+	};
+	return before + between + after;
+}
+/**
+* @param {Strong} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @returns {string}
+*/
+function strongPeek(_, _1, state) {
+	return state.options.strong || "*";
+}
+//#endregion
+export { strong };

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

@@ -0,0 +1,17 @@
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/text.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Text} from 'mdast'
+*/
+/**
+* @param {Text} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function text(node, _, state, info) {
+	return state.safe(node.value, info);
+}
+//#endregion
+export { text };

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

@@ -0,0 +1,19 @@
+import { checkRule } from "../util/check-rule.mjs";
+import { checkRuleRepetition } from "../util/check-rule-repetition.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Parents, ThematicBreak} from 'mdast'
+*/
+/**
+* @param {ThematicBreak} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @returns {string}
+*/
+function thematicBreak(_, _1, state) {
+	const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+	return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+//#endregion
+export { thematicBreak };

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

@@ -0,0 +1,161 @@
+import { zwitch } from "../../../../zwitch@2.0.4/node_modules/zwitch/index.mjs";
+import { configure } from "./configure.mjs";
+import { handle } from "./handle/index.mjs";
+import { join } from "./join.mjs";
+import { unsafe } from "./unsafe.mjs";
+import { association } from "./util/association.mjs";
+import { compilePattern } from "./util/compile-pattern.mjs";
+import { containerPhrasing } from "./util/container-phrasing.mjs";
+import { containerFlow } from "./util/container-flow.mjs";
+import { indentLines } from "./util/indent-lines.mjs";
+import { safe } from "./util/safe.mjs";
+import { track } from "./util/track.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/index.js
+/**
+* @import {Info, Join, Options, SafeConfig, State} from 'mdast-util-to-markdown'
+* @import {Nodes} from 'mdast'
+* @import {Enter, FlowParents, PhrasingParents, TrackFields} from './types.js'
+*/
+/**
+* Turn an mdast syntax tree into markdown.
+*
+* @param {Nodes} tree
+*   Tree to serialize.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Serialized markdown representing `tree`.
+*/
+function toMarkdown(tree, options) {
+	const settings = options || {};
+	/** @type {State} */
+	const state = {
+		associationId: association,
+		containerPhrasing: containerPhrasingBound,
+		containerFlow: containerFlowBound,
+		createTracker: track,
+		compilePattern,
+		enter,
+		handlers: { ...handle },
+		handle: void 0,
+		indentLines,
+		indexStack: [],
+		join: [...join],
+		options: {},
+		safe: safeBound,
+		stack: [],
+		unsafe: [...unsafe]
+	};
+	configure(state, settings);
+	if (state.options.tightDefinitions) state.join.push(joinDefinition);
+	state.handle = zwitch("type", {
+		invalid,
+		unknown,
+		handlers: state.handlers
+	});
+	let result = state.handle(tree, void 0, state, {
+		before: "\n",
+		after: "\n",
+		now: {
+			line: 1,
+			column: 1
+		},
+		lineShift: 0
+	});
+	if (result && result.charCodeAt(result.length - 1) !== 10 && result.charCodeAt(result.length - 1) !== 13) result += "\n";
+	return result;
+	/** @type {Enter} */
+	function enter(name) {
+		state.stack.push(name);
+		return exit;
+		/**
+		* @returns {undefined}
+		*/
+		function exit() {
+			state.stack.pop();
+		}
+	}
+}
+/**
+* @param {unknown} value
+* @returns {never}
+*/
+function invalid(value) {
+	throw new Error("Cannot handle value `" + value + "`, expected node");
+}
+/**
+* @param {unknown} value
+* @returns {never}
+*/
+function unknown(value) {
+	throw new Error("Cannot handle unknown node `" + value.type + "`");
+}
+/** @type {Join} */
+function joinDefinition(left, right) {
+	if (left.type === "definition" && left.type === right.type) return 0;
+}
+/**
+* Serialize the children of a parent that contains phrasing children.
+*
+* These children will be joined flush together.
+*
+* @this {State}
+*   Info passed around about the current state.
+* @param {PhrasingParents} parent
+*   Parent of flow nodes.
+* @param {Info} info
+*   Info on where we are in the document we are generating.
+* @returns {string}
+*   Serialized children, joined together.
+*/
+function containerPhrasingBound(parent, info) {
+	return containerPhrasing(parent, this, info);
+}
+/**
+* Serialize the children of a parent that contains flow children.
+*
+* These children will typically be joined by blank lines.
+* What they are joined by exactly is defined by `Join` functions.
+*
+* @this {State}
+*   Info passed around about the current state.
+* @param {FlowParents} parent
+*   Parent of flow nodes.
+* @param {TrackFields} info
+*   Info on where we are in the document we are generating.
+* @returns {string}
+*   Serialized children, joined by (blank) lines.
+*/
+function containerFlowBound(parent, info) {
+	return containerFlow(parent, this, info);
+}
+/**
+* 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.
+*
+* @this {State}
+*   Info passed around about the current state.
+* @param {string | null | undefined} value
+*   Raw value to make safe.
+* @param {SafeConfig} config
+*   Configuration.
+* @returns {string}
+*   Serialized markdown safe for embedding.
+*/
+function safeBound(value, config) {
+	return safe(this, value, config);
+}
+//#endregion
+export { toMarkdown };

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

@@ -0,0 +1,18 @@
+import { formatCodeAsIndented } from "./util/format-code-as-indented.mjs";
+import { formatHeadingAsSetext } from "./util/format-heading-as-setext.mjs";
+//#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/join.js
+/**
+* @import {Join} from 'mdast-util-to-markdown'
+*/
+/** @type {Array<Join>} */
+const join = [joinDefaults];
+/** @type {Join} */
+function joinDefaults(left, right, parent, state) {
+	if (right.type === "code" && formatCodeAsIndented(right, state) && (left.type === "list" || left.type === right.type && formatCodeAsIndented(left, state))) return false;
+	if ("spread" in parent && typeof parent.spread === "boolean") {
+		if (left.type === "paragraph" && (left.type === right.type || right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state))) return;
+		return parent.spread ? 1 : 0;
+	}
+}
+//#endregion
+export { join };