cngpac 0.0.1

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

@@ -0,0 +1,220 @@
+import { markdownLineEnding } from "../../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { splice } from "../../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/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/document.js
+/**
+* @import {
+*   Construct,
+*   ContainerState,
+*   InitialConstruct,
+*   Initializer,
+*   Point,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
+* @typedef {[Construct, ContainerState]} StackItem
+*   Construct and its state.
+*/
+/** @type {InitialConstruct} */
+const document = { tokenize: initializeDocument };
+/** @type {Construct} */
+const containerConstruct = { tokenize: tokenizeContainer };
+/**
+* @this {TokenizeContext}
+*   Self.
+* @type {Initializer}
+*   Initializer.
+*/
+function initializeDocument(effects) {
+	const self = this;
+	/** @type {Array<StackItem>} */
+	const stack = [];
+	let continued = 0;
+	/** @type {TokenizeContext | undefined} */
+	let childFlow;
+	/** @type {Token | undefined} */
+	let childToken;
+	/** @type {number} */
+	let lineStartOffset;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (continued < stack.length) {
+			const item = stack[continued];
+			self.containerState = item[1];
+			return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);
+		}
+		return checkNewContainers(code);
+	}
+	/** @type {State} */
+	function documentContinue(code) {
+		continued++;
+		if (self.containerState._closeFlow) {
+			self.containerState._closeFlow = void 0;
+			if (childFlow) closeFlow();
+			const indexBeforeExits = self.events.length;
+			let indexBeforeFlow = indexBeforeExits;
+			/** @type {Point | undefined} */
+			let point;
+			while (indexBeforeFlow--) if (self.events[indexBeforeFlow][0] === "exit" && self.events[indexBeforeFlow][1].type === "chunkFlow") {
+				point = self.events[indexBeforeFlow][1].end;
+				break;
+			}
+			exitContainers(continued);
+			let index = indexBeforeExits;
+			while (index < self.events.length) {
+				self.events[index][1].end = { ...point };
+				index++;
+			}
+			splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
+			self.events.length = index;
+			return checkNewContainers(code);
+		}
+		return start(code);
+	}
+	/** @type {State} */
+	function checkNewContainers(code) {
+		if (continued === stack.length) {
+			if (!childFlow) return documentContinued(code);
+			if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) return flowStart(code);
+			self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);
+		}
+		self.containerState = {};
+		return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);
+	}
+	/** @type {State} */
+	function thereIsANewContainer(code) {
+		if (childFlow) closeFlow();
+		exitContainers(continued);
+		return documentContinued(code);
+	}
+	/** @type {State} */
+	function thereIsNoNewContainer(code) {
+		self.parser.lazy[self.now().line] = continued !== stack.length;
+		lineStartOffset = self.now().offset;
+		return flowStart(code);
+	}
+	/** @type {State} */
+	function documentContinued(code) {
+		self.containerState = {};
+		return effects.attempt(containerConstruct, containerContinue, flowStart)(code);
+	}
+	/** @type {State} */
+	function containerContinue(code) {
+		continued++;
+		stack.push([self.currentConstruct, self.containerState]);
+		return documentContinued(code);
+	}
+	/** @type {State} */
+	function flowStart(code) {
+		if (code === null) {
+			if (childFlow) closeFlow();
+			exitContainers(0);
+			effects.consume(code);
+			return;
+		}
+		childFlow = childFlow || self.parser.flow(self.now());
+		effects.enter("chunkFlow", {
+			_tokenizer: childFlow,
+			contentType: "flow",
+			previous: childToken
+		});
+		return flowContinue(code);
+	}
+	/** @type {State} */
+	function flowContinue(code) {
+		if (code === null) {
+			writeToChild(effects.exit("chunkFlow"), true);
+			exitContainers(0);
+			effects.consume(code);
+			return;
+		}
+		if (markdownLineEnding(code)) {
+			effects.consume(code);
+			writeToChild(effects.exit("chunkFlow"));
+			continued = 0;
+			self.interrupt = void 0;
+			return start;
+		}
+		effects.consume(code);
+		return flowContinue;
+	}
+	/**
+	* @param {Token} token
+	*   Token.
+	* @param {boolean | undefined} [endOfFile]
+	*   Whether the token is at the end of the file (default: `false`).
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function writeToChild(token, endOfFile) {
+		const stream = self.sliceStream(token);
+		if (endOfFile) stream.push(null);
+		token.previous = childToken;
+		if (childToken) childToken.next = token;
+		childToken = token;
+		childFlow.defineSkip(token.start);
+		childFlow.write(stream);
+		if (self.parser.lazy[token.start.line]) {
+			let index = childFlow.events.length;
+			while (index--) if (childFlow.events[index][1].start.offset < lineStartOffset && (!childFlow.events[index][1].end || childFlow.events[index][1].end.offset > lineStartOffset)) return;
+			const indexBeforeExits = self.events.length;
+			let indexBeforeFlow = indexBeforeExits;
+			/** @type {boolean | undefined} */
+			let seen;
+			/** @type {Point | undefined} */
+			let point;
+			while (indexBeforeFlow--) if (self.events[indexBeforeFlow][0] === "exit" && self.events[indexBeforeFlow][1].type === "chunkFlow") {
+				if (seen) {
+					point = self.events[indexBeforeFlow][1].end;
+					break;
+				}
+				seen = true;
+			}
+			exitContainers(continued);
+			index = indexBeforeExits;
+			while (index < self.events.length) {
+				self.events[index][1].end = { ...point };
+				index++;
+			}
+			splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
+			self.events.length = index;
+		}
+	}
+	/**
+	* @param {number} size
+	*   Size.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function exitContainers(size) {
+		let index = stack.length;
+		while (index-- > size) {
+			const entry = stack[index];
+			self.containerState = entry[1];
+			entry[0].exit.call(self, effects);
+		}
+		stack.length = size;
+	}
+	function closeFlow() {
+		childFlow.write([null]);
+		childToken = void 0;
+		childFlow = void 0;
+		self.containerState._closeFlow = void 0;
+	}
+}
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*   Tokenizer.
+*/
+function tokenizeContainer(effects, ok, nok) {
+	return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+}
+//#endregion
+export { document };

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

@@ -0,0 +1,51 @@
+import { factorySpace } from "../../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.mjs";
+import { blankLine } from "../../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.mjs";
+import { content } from "../../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.mjs";
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/flow.js
+/**
+* @import {
+*   InitialConstruct,
+*   Initializer,
+*   State,
+*   TokenizeContext
+* } from 'micromark-util-types'
+*/
+/** @type {InitialConstruct} */
+const flow = { tokenize: initializeFlow };
+/**
+* @this {TokenizeContext}
+*   Self.
+* @type {Initializer}
+*   Initializer.
+*/
+function initializeFlow(effects) {
+	const self = this;
+	const initial = effects.attempt(blankLine, atBlankEnding, effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), "linePrefix")));
+	return initial;
+	/** @type {State} */
+	function atBlankEnding(code) {
+		if (code === null) {
+			effects.consume(code);
+			return;
+		}
+		effects.enter("lineEndingBlank");
+		effects.consume(code);
+		effects.exit("lineEndingBlank");
+		self.currentConstruct = void 0;
+		return initial;
+	}
+	/** @type {State} */
+	function afterConstruct(code) {
+		if (code === null) {
+			effects.consume(code);
+			return;
+		}
+		effects.enter("lineEnding");
+		effects.consume(code);
+		effects.exit("lineEnding");
+		self.currentConstruct = void 0;
+		return initial;
+	}
+}
+//#endregion
+export { flow };

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

@@ -0,0 +1,178 @@
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/text.js
+/**
+* @import {
+*   Code,
+*   InitialConstruct,
+*   Initializer,
+*   Resolver,
+*   State,
+*   TokenizeContext
+* } from 'micromark-util-types'
+*/
+const resolver = { resolveAll: createResolver() };
+const string = initializeFactory("string");
+const text = initializeFactory("text");
+/**
+* @param {'string' | 'text'} field
+*   Field.
+* @returns {InitialConstruct}
+*   Construct.
+*/
+function initializeFactory(field) {
+	return {
+		resolveAll: createResolver(field === "text" ? resolveAllLineSuffixes : void 0),
+		tokenize: initializeText
+	};
+	/**
+	* @this {TokenizeContext}
+	*   Context.
+	* @type {Initializer}
+	*/
+	function initializeText(effects) {
+		const self = this;
+		const constructs = this.parser.constructs[field];
+		const text = effects.attempt(constructs, start, notText);
+		return start;
+		/** @type {State} */
+		function start(code) {
+			return atBreak(code) ? text(code) : notText(code);
+		}
+		/** @type {State} */
+		function notText(code) {
+			if (code === null) {
+				effects.consume(code);
+				return;
+			}
+			effects.enter("data");
+			effects.consume(code);
+			return data;
+		}
+		/** @type {State} */
+		function data(code) {
+			if (atBreak(code)) {
+				effects.exit("data");
+				return text(code);
+			}
+			effects.consume(code);
+			return data;
+		}
+		/**
+		* @param {Code} code
+		*   Code.
+		* @returns {boolean}
+		*   Whether the code is a break.
+		*/
+		function atBreak(code) {
+			if (code === null) return true;
+			const list = constructs[code];
+			let index = -1;
+			if (list) while (++index < list.length) {
+				const item = list[index];
+				if (!item.previous || item.previous.call(self, self.previous)) return true;
+			}
+			return false;
+		}
+	}
+}
+/**
+* @param {Resolver | undefined} [extraResolver]
+*   Resolver.
+* @returns {Resolver}
+*   Resolver.
+*/
+function createResolver(extraResolver) {
+	return resolveAllText;
+	/** @type {Resolver} */
+	function resolveAllText(events, context) {
+		let index = -1;
+		/** @type {number | undefined} */
+		let enter;
+		while (++index <= events.length) if (enter === void 0) {
+			if (events[index] && events[index][1].type === "data") {
+				enter = index;
+				index++;
+			}
+		} else if (!events[index] || events[index][1].type !== "data") {
+			if (index !== enter + 2) {
+				events[enter][1].end = events[index - 1][1].end;
+				events.splice(enter + 2, index - enter - 2);
+				index = enter + 2;
+			}
+			enter = void 0;
+		}
+		return extraResolver ? extraResolver(events, context) : events;
+	}
+}
+/**
+* A rather ugly set of instructions which again looks at chunks in the input
+* stream.
+* The reason to do this here is that it is *much* faster to parse in reverse.
+* And that we can’t hook into `null` to split the line suffix before an EOF.
+* To do: figure out if we can make this into a clean utility, or even in core.
+* As it will be useful for GFMs literal autolink extension (and maybe even
+* tables?)
+*
+* @type {Resolver}
+*/
+function resolveAllLineSuffixes(events, context) {
+	let eventIndex = 0;
+	while (++eventIndex <= events.length) if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
+		const data = events[eventIndex - 1][1];
+		const chunks = context.sliceStream(data);
+		let index = chunks.length;
+		let bufferIndex = -1;
+		let size = 0;
+		/** @type {boolean | undefined} */
+		let tabs;
+		while (index--) {
+			const chunk = chunks[index];
+			if (typeof chunk === "string") {
+				bufferIndex = chunk.length;
+				while (chunk.charCodeAt(bufferIndex - 1) === 32) {
+					size++;
+					bufferIndex--;
+				}
+				if (bufferIndex) break;
+				bufferIndex = -1;
+			} else if (chunk === -2) {
+				tabs = true;
+				size++;
+			} else if (chunk === -1) {} else {
+				index++;
+				break;
+			}
+		}
+		if (context._contentTypeTextTrailing && eventIndex === events.length) size = 0;
+		if (size) {
+			const token = {
+				type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
+				start: {
+					_bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,
+					_index: data.start._index + index,
+					line: data.end.line,
+					column: data.end.column - size,
+					offset: data.end.offset - size
+				},
+				end: { ...data.end }
+			};
+			data.end = { ...token.start };
+			if (data.start.offset === data.end.offset) Object.assign(data, token);
+			else {
+				events.splice(eventIndex, 0, [
+					"enter",
+					token,
+					context
+				], [
+					"exit",
+					token,
+					context
+				]);
+				eventIndex += 2;
+			}
+		}
+		eventIndex++;
+	}
+	return events;
+}
+//#endregion
+export { resolver, string, text };

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

@@ -0,0 +1,52 @@
+import { combineExtensions } from "../../../../micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.mjs";
+import { content } from "./initialize/content.mjs";
+import { document } from "./initialize/document.mjs";
+import { flow } from "./initialize/flow.mjs";
+import { string, text } from "./initialize/text.mjs";
+import { constructs_exports } from "./constructs.mjs";
+import { createTokenizer } from "./create-tokenizer.mjs";
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/parse.js
+/**
+* @import {
+*   Create,
+*   FullNormalizedExtension,
+*   InitialConstruct,
+*   ParseContext,
+*   ParseOptions
+* } from 'micromark-util-types'
+*/
+/**
+* @param {ParseOptions | null | undefined} [options]
+*   Configuration (optional).
+* @returns {ParseContext}
+*   Parser.
+*/
+function parse(options) {
+	/** @type {ParseContext} */
+	const parser = {
+		constructs: combineExtensions([constructs_exports, ...(options || {}).extensions || []]),
+		content: create(content),
+		defined: [],
+		document: create(document),
+		flow: create(flow),
+		lazy: {},
+		string: create(string),
+		text: create(text)
+	};
+	return parser;
+	/**
+	* @param {InitialConstruct} initial
+	*   Construct to start with.
+	* @returns {Create}
+	*   Create a tokenizer.
+	*/
+	function create(initial) {
+		return creator;
+		/** @type {Create} */
+		function creator(from) {
+			return createTokenizer(parser, initial, from);
+		}
+	}
+}
+//#endregion
+export { parse };

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

@@ -0,0 +1,17 @@
+import { subtokenize } from "../../../../micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.mjs";
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/postprocess.js
+/**
+* @import {Event} from 'micromark-util-types'
+*/
+/**
+* @param {Array<Event>} events
+*   Events.
+* @returns {Array<Event>}
+*   Events.
+*/
+function postprocess(events) {
+	while (!subtokenize(events));
+	return events;
+}
+//#endregion
+export { postprocess };

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

@@ -0,0 +1,102 @@
+//#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/preprocess.js
+/**
+* @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'
+*/
+/**
+* @callback Preprocessor
+*   Preprocess a value.
+* @param {Value} value
+*   Value.
+* @param {Encoding | null | undefined} [encoding]
+*   Encoding when `value` is a typed array (optional).
+* @param {boolean | null | undefined} [end=false]
+*   Whether this is the last chunk (default: `false`).
+* @returns {Array<Chunk>}
+*   Chunks.
+*/
+const search = /[\0\t\n\r]/g;
+/**
+* @returns {Preprocessor}
+*   Preprocess a value.
+*/
+function preprocess() {
+	let column = 1;
+	let buffer = "";
+	/** @type {boolean | undefined} */
+	let start = true;
+	/** @type {boolean | undefined} */
+	let atCarriageReturn;
+	return preprocessor;
+	/** @type {Preprocessor} */
+	function preprocessor(value, encoding, end) {
+		/** @type {Array<Chunk>} */
+		const chunks = [];
+		/** @type {RegExpMatchArray | null} */
+		let match;
+		/** @type {number} */
+		let next;
+		/** @type {number} */
+		let startPosition;
+		/** @type {number} */
+		let endPosition;
+		/** @type {Code} */
+		let code;
+		value = buffer + (typeof value === "string" ? value.toString() : new TextDecoder(encoding || void 0).decode(value));
+		startPosition = 0;
+		buffer = "";
+		if (start) {
+			if (value.charCodeAt(0) === 65279) startPosition++;
+			start = void 0;
+		}
+		while (startPosition < value.length) {
+			search.lastIndex = startPosition;
+			match = search.exec(value);
+			endPosition = match && match.index !== void 0 ? match.index : value.length;
+			code = value.charCodeAt(endPosition);
+			if (!match) {
+				buffer = value.slice(startPosition);
+				break;
+			}
+			if (code === 10 && startPosition === endPosition && atCarriageReturn) {
+				chunks.push(-3);
+				atCarriageReturn = void 0;
+			} else {
+				if (atCarriageReturn) {
+					chunks.push(-5);
+					atCarriageReturn = void 0;
+				}
+				if (startPosition < endPosition) {
+					chunks.push(value.slice(startPosition, endPosition));
+					column += endPosition - startPosition;
+				}
+				switch (code) {
+					case 0:
+						chunks.push(65533);
+						column++;
+						break;
+					case 9:
+						next = Math.ceil(column / 4) * 4;
+						chunks.push(-2);
+						while (column++ < next) chunks.push(-1);
+						break;
+					case 10:
+						chunks.push(-4);
+						column = 1;
+						break;
+					default:
+						atCarriageReturn = true;
+						column = 1;
+				}
+			}
+			startPosition = endPosition + 1;
+		}
+		if (end) {
+			if (atCarriageReturn) chunks.push(-5);
+			if (buffer) chunks.push(buffer);
+			chunks.push(null);
+		}
+		return chunks;
+	}
+}
+//#endregion
+export { preprocess };