cngpac 0.0.1

package/dist/src/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.mjs

@@ -0,0 +1,101 @@
+import { __exportAll } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { attention } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.mjs";
+import { autolink } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.mjs";
+import { blockQuote } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.mjs";
+import { characterEscape } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.mjs";
+import { characterReference } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.mjs";
+import { codeFenced } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.mjs";
+import { codeIndented } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.mjs";
+import { codeText } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.mjs";
+import { definition } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.mjs";
+import { hardBreakEscape } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.mjs";
+import { headingAtx } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.mjs";
+import { htmlFlow } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.mjs";
+import { htmlText } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.mjs";
+import { labelEnd } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.mjs";
+import { labelStartImage } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.mjs";
+import { labelStartLink } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.mjs";
+import { lineEnding } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.mjs";
+import { thematicBreak } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.mjs";
+import { list } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.mjs";
+import { setextUnderline } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.mjs";
+import { resolver } from "./initialize/text.mjs";
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.js
+/**
+* @import {Extension} from 'micromark-util-types'
+*/
+var constructs_exports = /* @__PURE__ */ __exportAll({
+	attentionMarkers: () => attentionMarkers,
+	contentInitial: () => contentInitial,
+	disable: () => disable,
+	document: () => document,
+	flow: () => flow,
+	flowInitial: () => flowInitial,
+	insideSpan: () => insideSpan,
+	string: () => string,
+	text: () => text
+});
+/** @satisfies {Extension['document']} */
+const document = {
+	[42]: list,
+	[43]: list,
+	[45]: list,
+	[48]: list,
+	[49]: list,
+	[50]: list,
+	[51]: list,
+	[52]: list,
+	[53]: list,
+	[54]: list,
+	[55]: list,
+	[56]: list,
+	[57]: list,
+	[62]: blockQuote
+};
+/** @satisfies {Extension['contentInitial']} */
+const contentInitial = { [91]: definition };
+/** @satisfies {Extension['flowInitial']} */
+const flowInitial = {
+	[-2]: codeIndented,
+	[-1]: codeIndented,
+	[32]: codeIndented
+};
+/** @satisfies {Extension['flow']} */
+const flow = {
+	[35]: headingAtx,
+	[42]: thematicBreak,
+	[45]: [setextUnderline, thematicBreak],
+	[60]: htmlFlow,
+	[61]: setextUnderline,
+	[95]: thematicBreak,
+	[96]: codeFenced,
+	[126]: codeFenced
+};
+/** @satisfies {Extension['string']} */
+const string = {
+	[38]: characterReference,
+	[92]: characterEscape
+};
+/** @satisfies {Extension['text']} */
+const text = {
+	[-5]: lineEnding,
+	[-4]: lineEnding,
+	[-3]: lineEnding,
+	[33]: labelStartImage,
+	[38]: characterReference,
+	[42]: attention,
+	[60]: [autolink, htmlText],
+	[91]: labelStartLink,
+	[92]: [hardBreakEscape, characterEscape],
+	[93]: labelEnd,
+	[95]: attention,
+	[96]: codeText
+};
+/** @satisfies {Extension['insideSpan']} */
+const insideSpan = { null: [attention, resolver] };
+/** @satisfies {Extension['attentionMarkers']} */
+const attentionMarkers = { null: [42, 95] };
+/** @satisfies {Extension['disable']} */
+const disable = { null: [] };
+//#endregion
+export { constructs_exports };

package/dist/src/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.mjs

@@ -0,0 +1,473 @@
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { push, splice } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/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@4.0.2/node_modules/micromark/lib/create-tokenizer.js
+/**
+* @import {
+*   Chunk,
+*   Code,
+*   ConstructRecord,
+*   Construct,
+*   Effects,
+*   InitialConstruct,
+*   ParseContext,
+*   Point,
+*   State,
+*   TokenizeContext,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
+* @callback Restore
+*   Restore the state.
+* @returns {undefined}
+*   Nothing.
+*
+* @typedef Info
+*   Info.
+* @property {Restore} restore
+*   Restore.
+* @property {number} from
+*   From.
+*
+* @callback ReturnHandle
+*   Handle a successful run.
+* @param {Construct} construct
+*   Construct.
+* @param {Info} info
+*   Info.
+* @returns {undefined}
+*   Nothing.
+*/
+/**
+* Create a tokenizer.
+* Tokenizers deal with one type of data (e.g., containers, flow, text).
+* The parser is the object dealing with it all.
+* `initialize` works like other constructs, except that only its `tokenize`
+* function is used, in which case it doesn’t receive an `ok` or `nok`.
+* `from` can be given to set the point before the first character, although
+* when further lines are indented, they must be set with `defineSkip`.
+*
+* @param {ParseContext} parser
+*   Parser.
+* @param {InitialConstruct} initialize
+*   Construct.
+* @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]
+*   Point (optional).
+* @returns {TokenizeContext}
+*   Context.
+*/
+function createTokenizer(parser, initialize, from) {
+	/** @type {Point} */
+	let point = {
+		_bufferIndex: -1,
+		_index: 0,
+		line: from && from.line || 1,
+		column: from && from.column || 1,
+		offset: from && from.offset || 0
+	};
+	/** @type {Record<string, number>} */
+	const columnStart = {};
+	/** @type {Array<Construct>} */
+	const resolveAllConstructs = [];
+	/** @type {Array<Chunk>} */
+	let chunks = [];
+	/** @type {Array<Token>} */
+	let stack = [];
+	/**
+	* Tools used for tokenizing.
+	*
+	* @type {Effects}
+	*/
+	const effects = {
+		attempt: constructFactory(onsuccessfulconstruct),
+		check: constructFactory(onsuccessfulcheck),
+		consume,
+		enter,
+		exit,
+		interrupt: constructFactory(onsuccessfulcheck, { interrupt: true })
+	};
+	/**
+	* State and tools for resolving and serializing.
+	*
+	* @type {TokenizeContext}
+	*/
+	const context = {
+		code: null,
+		containerState: {},
+		defineSkip,
+		events: [],
+		now,
+		parser,
+		previous: null,
+		sliceSerialize,
+		sliceStream,
+		write
+	};
+	/**
+	* The state function.
+	*
+	* @type {State | undefined}
+	*/
+	let state = initialize.tokenize.call(context, effects);
+	if (initialize.resolveAll) resolveAllConstructs.push(initialize);
+	return context;
+	/** @type {TokenizeContext['write']} */
+	function write(slice) {
+		chunks = push(chunks, slice);
+		main();
+		if (chunks[chunks.length - 1] !== null) return [];
+		addResult(initialize, 0);
+		context.events = resolveAll(resolveAllConstructs, context.events, context);
+		return context.events;
+	}
+	/** @type {TokenizeContext['sliceSerialize']} */
+	function sliceSerialize(token, expandTabs) {
+		return serializeChunks(sliceStream(token), expandTabs);
+	}
+	/** @type {TokenizeContext['sliceStream']} */
+	function sliceStream(token) {
+		return sliceChunks(chunks, token);
+	}
+	/** @type {TokenizeContext['now']} */
+	function now() {
+		const { _bufferIndex, _index, line, column, offset } = point;
+		return {
+			_bufferIndex,
+			_index,
+			line,
+			column,
+			offset
+		};
+	}
+	/** @type {TokenizeContext['defineSkip']} */
+	function defineSkip(value) {
+		columnStart[value.line] = value.column;
+		accountForPotentialSkip();
+	}
+	/**
+	* Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
+	* `consume`).
+	* Here is where we walk through the chunks, which either include strings of
+	* several characters, or numerical character codes.
+	* The reason to do this in a loop instead of a call is so the stack can
+	* drain.
+	*
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function main() {
+		/** @type {number} */
+		let chunkIndex;
+		while (point._index < chunks.length) {
+			const chunk = chunks[point._index];
+			if (typeof chunk === "string") {
+				chunkIndex = point._index;
+				if (point._bufferIndex < 0) point._bufferIndex = 0;
+				while (point._index === chunkIndex && point._bufferIndex < chunk.length) go(chunk.charCodeAt(point._bufferIndex));
+			} else go(chunk);
+		}
+	}
+	/**
+	* Deal with one code.
+	*
+	* @param {Code} code
+	*   Code.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function go(code) {
+		state = state(code);
+	}
+	/** @type {Effects['consume']} */
+	function consume(code) {
+		if (markdownLineEnding(code)) {
+			point.line++;
+			point.column = 1;
+			point.offset += code === -3 ? 2 : 1;
+			accountForPotentialSkip();
+		} else if (code !== -1) {
+			point.column++;
+			point.offset++;
+		}
+		if (point._bufferIndex < 0) point._index++;
+		else {
+			point._bufferIndex++;
+			if (point._bufferIndex === chunks[point._index].length) {
+				point._bufferIndex = -1;
+				point._index++;
+			}
+		}
+		context.previous = code;
+	}
+	/** @type {Effects['enter']} */
+	function enter(type, fields) {
+		/** @type {Token} */
+		const token = fields || {};
+		token.type = type;
+		token.start = now();
+		context.events.push([
+			"enter",
+			token,
+			context
+		]);
+		stack.push(token);
+		return token;
+	}
+	/** @type {Effects['exit']} */
+	function exit(type) {
+		const token = stack.pop();
+		token.end = now();
+		context.events.push([
+			"exit",
+			token,
+			context
+		]);
+		return token;
+	}
+	/**
+	* Use results.
+	*
+	* @type {ReturnHandle}
+	*/
+	function onsuccessfulconstruct(construct, info) {
+		addResult(construct, info.from);
+	}
+	/**
+	* Discard results.
+	*
+	* @type {ReturnHandle}
+	*/
+	function onsuccessfulcheck(_, info) {
+		info.restore();
+	}
+	/**
+	* Factory to attempt/check/interrupt.
+	*
+	* @param {ReturnHandle} onreturn
+	*   Callback.
+	* @param {{interrupt?: boolean | undefined} | undefined} [fields]
+	*   Fields.
+	*/
+	function constructFactory(onreturn, fields) {
+		return hook;
+		/**
+		* Handle either an object mapping codes to constructs, a list of
+		* constructs, or a single construct.
+		*
+		* @param {Array<Construct> | ConstructRecord | Construct} constructs
+		*   Constructs.
+		* @param {State} returnState
+		*   State.
+		* @param {State | undefined} [bogusState]
+		*   State.
+		* @returns {State}
+		*   State.
+		*/
+		function hook(constructs, returnState, bogusState) {
+			/** @type {ReadonlyArray<Construct>} */
+			let listOfConstructs;
+			/** @type {number} */
+			let constructIndex;
+			/** @type {Construct} */
+			let currentConstruct;
+			/** @type {Info} */
+			let info;
+			return Array.isArray(constructs) ? handleListOfConstructs(constructs) : "tokenize" in constructs ? handleListOfConstructs([constructs]) : handleMapOfConstructs(constructs);
+			/**
+			* Handle a list of construct.
+			*
+			* @param {ConstructRecord} map
+			*   Constructs.
+			* @returns {State}
+			*   State.
+			*/
+			function handleMapOfConstructs(map) {
+				return start;
+				/** @type {State} */
+				function start(code) {
+					const left = code !== null && map[code];
+					const all = code !== null && map.null;
+					return handleListOfConstructs([...Array.isArray(left) ? left : left ? [left] : [], ...Array.isArray(all) ? all : all ? [all] : []])(code);
+				}
+			}
+			/**
+			* Handle a list of construct.
+			*
+			* @param {ReadonlyArray<Construct>} list
+			*   Constructs.
+			* @returns {State}
+			*   State.
+			*/
+			function handleListOfConstructs(list) {
+				listOfConstructs = list;
+				constructIndex = 0;
+				if (list.length === 0) return bogusState;
+				return handleConstruct(list[constructIndex]);
+			}
+			/**
+			* Handle a single construct.
+			*
+			* @param {Construct} construct
+			*   Construct.
+			* @returns {State}
+			*   State.
+			*/
+			function handleConstruct(construct) {
+				return start;
+				/** @type {State} */
+				function start(code) {
+					info = store();
+					currentConstruct = construct;
+					if (!construct.partial) context.currentConstruct = construct;
+					if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) return nok(code);
+					return construct.tokenize.call(fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);
+				}
+			}
+			/** @type {State} */
+			function ok(code) {
+				onreturn(currentConstruct, info);
+				return returnState;
+			}
+			/** @type {State} */
+			function nok(code) {
+				info.restore();
+				if (++constructIndex < listOfConstructs.length) return handleConstruct(listOfConstructs[constructIndex]);
+				return bogusState;
+			}
+		}
+	}
+	/**
+	* @param {Construct} construct
+	*   Construct.
+	* @param {number} from
+	*   From.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function addResult(construct, from) {
+		if (construct.resolveAll && !resolveAllConstructs.includes(construct)) resolveAllConstructs.push(construct);
+		if (construct.resolve) splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));
+		if (construct.resolveTo) context.events = construct.resolveTo(context.events, context);
+	}
+	/**
+	* Store state.
+	*
+	* @returns {Info}
+	*   Info.
+	*/
+	function store() {
+		const startPoint = now();
+		const startPrevious = context.previous;
+		const startCurrentConstruct = context.currentConstruct;
+		const startEventsIndex = context.events.length;
+		const startStack = Array.from(stack);
+		return {
+			from: startEventsIndex,
+			restore
+		};
+		/**
+		* Restore state.
+		*
+		* @returns {undefined}
+		*   Nothing.
+		*/
+		function restore() {
+			point = startPoint;
+			context.previous = startPrevious;
+			context.currentConstruct = startCurrentConstruct;
+			context.events.length = startEventsIndex;
+			stack = startStack;
+			accountForPotentialSkip();
+		}
+	}
+	/**
+	* Move the current point a bit forward in the line when it’s on a column
+	* skip.
+	*
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function accountForPotentialSkip() {
+		if (point.line in columnStart && point.column < 2) {
+			point.column = columnStart[point.line];
+			point.offset += columnStart[point.line] - 1;
+		}
+	}
+}
+/**
+* Get the chunks from a slice of chunks in the range of a token.
+*
+* @param {ReadonlyArray<Chunk>} chunks
+*   Chunks.
+* @param {Pick<Token, 'end' | 'start'>} token
+*   Token.
+* @returns {Array<Chunk>}
+*   Chunks.
+*/
+function sliceChunks(chunks, token) {
+	const startIndex = token.start._index;
+	const startBufferIndex = token.start._bufferIndex;
+	const endIndex = token.end._index;
+	const endBufferIndex = token.end._bufferIndex;
+	/** @type {Array<Chunk>} */
+	let view;
+	if (startIndex === endIndex) view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
+	else {
+		view = chunks.slice(startIndex, endIndex);
+		if (startBufferIndex > -1) {
+			const head = view[0];
+			if (typeof head === "string") view[0] = head.slice(startBufferIndex);
+			else view.shift();
+		}
+		if (endBufferIndex > 0) view.push(chunks[endIndex].slice(0, endBufferIndex));
+	}
+	return view;
+}
+/**
+* Get the string value of a slice of chunks.
+*
+* @param {ReadonlyArray<Chunk>} chunks
+*   Chunks.
+* @param {boolean | undefined} [expandTabs=false]
+*   Whether to expand tabs (default: `false`).
+* @returns {string}
+*   Result.
+*/
+function serializeChunks(chunks, expandTabs) {
+	let index = -1;
+	/** @type {Array<string>} */
+	const result = [];
+	/** @type {boolean | undefined} */
+	let atTab;
+	while (++index < chunks.length) {
+		const chunk = chunks[index];
+		/** @type {string} */
+		let value;
+		if (typeof chunk === "string") value = chunk;
+		else switch (chunk) {
+			case -5:
+				value = "\r";
+				break;
+			case -4:
+				value = "\n";
+				break;
+			case -3:
+				value = "\r\n";
+				break;
+			case -2:
+				value = expandTabs ? " " : "	";
+				break;
+			case -1:
+				if (!expandTabs && atTab) continue;
+				value = " ";
+				break;
+			default: value = String.fromCharCode(chunk);
+		}
+		atTab = chunk === -2;
+		result.push(value);
+	}
+	return result.join("");
+}
+//#endregion
+export { createTokenizer };

package/dist/src/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.mjs

@@ -0,0 +1,70 @@
+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@4.0.2/node_modules/micromark/lib/initialize/content.js
+/**
+* @import {
+*   InitialConstruct,
+*   Initializer,
+*   State,
+*   TokenizeContext,
+*   Token
+* } from 'micromark-util-types'
+*/
+/** @type {InitialConstruct} */
+const content = { tokenize: initializeContent };
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Initializer}
+*   Content.
+*/
+function initializeContent(effects) {
+	const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);
+	/** @type {Token} */
+	let previous;
+	return contentStart;
+	/** @type {State} */
+	function afterContentStartConstruct(code) {
+		if (code === null) {
+			effects.consume(code);
+			return;
+		}
+		effects.enter("lineEnding");
+		effects.consume(code);
+		effects.exit("lineEnding");
+		return factorySpace(effects, contentStart, "linePrefix");
+	}
+	/** @type {State} */
+	function paragraphInitial(code) {
+		effects.enter("paragraph");
+		return lineStart(code);
+	}
+	/** @type {State} */
+	function lineStart(code) {
+		const token = effects.enter("chunkText", {
+			contentType: "text",
+			previous
+		});
+		if (previous) previous.next = token;
+		previous = token;
+		return data(code);
+	}
+	/** @type {State} */
+	function data(code) {
+		if (code === null) {
+			effects.exit("chunkText");
+			effects.exit("paragraph");
+			effects.consume(code);
+			return;
+		}
+		if (markdownLineEnding(code)) {
+			effects.consume(code);
+			effects.exit("chunkText");
+			return lineStart;
+		}
+		effects.consume(code);
+		return data;
+	}
+}
+//#endregion
+export { content };