cngpac 0.0.1

package/dist/src/node_modules/.pnpm/micromark-extension-frontmatter@2.0.0/node_modules/micromark-extension-frontmatter/lib/syntax.mjs

@@ -0,0 +1,352 @@
+import { markdownLineEnding, markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+import { toMatters } from "./to-matters.mjs";
+//#region node_modules/.pnpm/micromark-extension-frontmatter@2.0.0/node_modules/micromark-extension-frontmatter/lib/syntax.js
+/**
+* @typedef {import('micromark-util-types').Construct} Construct
+* @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+* @typedef {import('micromark-util-types').Extension} Extension
+* @typedef {import('micromark-util-types').State} State
+* @typedef {import('micromark-util-types').TokenType} TokenType
+* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+*
+* @typedef {import('./to-matters.js').Info} Info
+* @typedef {import('./to-matters.js').Matter} Matter
+* @typedef {import('./to-matters.js').Options} Options
+*/
+/**
+* Create an extension for `micromark` to enable frontmatter syntax.
+*
+* @param {Options | null | undefined} [options='yaml']
+*   Configuration (default: `'yaml'`).
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions`, to
+*   enable frontmatter syntax.
+*/
+function frontmatter(options) {
+	const matters = toMatters(options);
+	/** @type {ConstructRecord} */
+	const flow = {};
+	let index = -1;
+	while (++index < matters.length) {
+		const matter = matters[index];
+		const code = fence(matter, "open").charCodeAt(0);
+		const construct = createConstruct(matter);
+		const existing = flow[code];
+		if (Array.isArray(existing)) existing.push(construct);
+		else flow[code] = [construct];
+	}
+	return { flow };
+}
+/**
+* @param {Matter} matter
+* @returns {Construct}
+*/
+function createConstruct(matter) {
+	const anywhere = matter.anywhere;
+	const frontmatterType = matter.type;
+	const fenceType = frontmatterType + "Fence";
+	const sequenceType = fenceType + "Sequence";
+	const valueType = frontmatterType + "Value";
+	const closingFenceConstruct = {
+		tokenize: tokenizeClosingFence,
+		partial: true
+	};
+	/**
+	* Fence to look for.
+	*
+	* @type {string}
+	*/
+	let buffer;
+	let bufferIndex = 0;
+	return {
+		tokenize: tokenizeFrontmatter,
+		concrete: true
+	};
+	/**
+	* @this {TokenizeContext}
+	* @type {Tokenizer}
+	*/
+	function tokenizeFrontmatter(effects, ok, nok) {
+		const self = this;
+		return start;
+		/**
+		* Start of frontmatter.
+		*
+		* ```markdown
+		* > | ---
+		*     ^
+		*   | title: "Venus"
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function start(code) {
+			const position = self.now();
+			if (position.column === 1 && (position.line === 1 || anywhere)) {
+				buffer = fence(matter, "open");
+				bufferIndex = 0;
+				if (code === buffer.charCodeAt(bufferIndex)) {
+					effects.enter(frontmatterType);
+					effects.enter(fenceType);
+					effects.enter(sequenceType);
+					return openSequence(code);
+				}
+			}
+			return nok(code);
+		}
+		/**
+		* In open sequence.
+		*
+		* ```markdown
+		* > | ---
+		*     ^
+		*   | title: "Venus"
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function openSequence(code) {
+			if (bufferIndex === buffer.length) {
+				effects.exit(sequenceType);
+				if (markdownSpace(code)) {
+					effects.enter("whitespace");
+					return openSequenceWhitespace(code);
+				}
+				return openAfter(code);
+			}
+			if (code === buffer.charCodeAt(bufferIndex++)) {
+				effects.consume(code);
+				return openSequence;
+			}
+			return nok(code);
+		}
+		/**
+		* In whitespace after open sequence.
+		*
+		* ```markdown
+		* > | ---␠
+		*        ^
+		*   | title: "Venus"
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function openSequenceWhitespace(code) {
+			if (markdownSpace(code)) {
+				effects.consume(code);
+				return openSequenceWhitespace;
+			}
+			effects.exit("whitespace");
+			return openAfter(code);
+		}
+		/**
+		* After open sequence.
+		*
+		* ```markdown
+		* > | ---
+		*        ^
+		*   | title: "Venus"
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function openAfter(code) {
+			if (markdownLineEnding(code)) {
+				effects.exit(fenceType);
+				effects.enter("lineEnding");
+				effects.consume(code);
+				effects.exit("lineEnding");
+				buffer = fence(matter, "close");
+				bufferIndex = 0;
+				return effects.attempt(closingFenceConstruct, after, contentStart);
+			}
+			return nok(code);
+		}
+		/**
+		* Start of content chunk.
+		*
+		* ```markdown
+		*   | ---
+		* > | title: "Venus"
+		*     ^
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function contentStart(code) {
+			if (code === null || markdownLineEnding(code)) return contentEnd(code);
+			effects.enter(valueType);
+			return contentInside(code);
+		}
+		/**
+		* In content chunk.
+		*
+		* ```markdown
+		*   | ---
+		* > | title: "Venus"
+		*     ^
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function contentInside(code) {
+			if (code === null || markdownLineEnding(code)) {
+				effects.exit(valueType);
+				return contentEnd(code);
+			}
+			effects.consume(code);
+			return contentInside;
+		}
+		/**
+		* End of content chunk.
+		*
+		* ```markdown
+		*   | ---
+		* > | title: "Venus"
+		*                   ^
+		*   | ---
+		* ```
+		*
+		* @type {State}
+		*/
+		function contentEnd(code) {
+			if (code === null) return nok(code);
+			effects.enter("lineEnding");
+			effects.consume(code);
+			effects.exit("lineEnding");
+			return effects.attempt(closingFenceConstruct, after, contentStart);
+		}
+		/**
+		* After frontmatter.
+		*
+		* ```markdown
+		*   | ---
+		*   | title: "Venus"
+		* > | ---
+		*        ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function after(code) {
+			effects.exit(frontmatterType);
+			return ok(code);
+		}
+	}
+	/** @type {Tokenizer} */
+	function tokenizeClosingFence(effects, ok, nok) {
+		let bufferIndex = 0;
+		return closeStart;
+		/**
+		* Start of close sequence.
+		*
+		* ```markdown
+		*   | ---
+		*   | title: "Venus"
+		* > | ---
+		*     ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function closeStart(code) {
+			if (code === buffer.charCodeAt(bufferIndex)) {
+				effects.enter(fenceType);
+				effects.enter(sequenceType);
+				return closeSequence(code);
+			}
+			return nok(code);
+		}
+		/**
+		* In close sequence.
+		*
+		* ```markdown
+		*   | ---
+		*   | title: "Venus"
+		* > | ---
+		*     ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function closeSequence(code) {
+			if (bufferIndex === buffer.length) {
+				effects.exit(sequenceType);
+				if (markdownSpace(code)) {
+					effects.enter("whitespace");
+					return closeSequenceWhitespace(code);
+				}
+				return closeAfter(code);
+			}
+			if (code === buffer.charCodeAt(bufferIndex++)) {
+				effects.consume(code);
+				return closeSequence;
+			}
+			return nok(code);
+		}
+		/**
+		* In whitespace after close sequence.
+		*
+		* ```markdown
+		* > | ---
+		*   | title: "Venus"
+		*   | ---␠
+		*        ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function closeSequenceWhitespace(code) {
+			if (markdownSpace(code)) {
+				effects.consume(code);
+				return closeSequenceWhitespace;
+			}
+			effects.exit("whitespace");
+			return closeAfter(code);
+		}
+		/**
+		* After close sequence.
+		*
+		* ```markdown
+		*   | ---
+		*   | title: "Venus"
+		* > | ---
+		*        ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function closeAfter(code) {
+			if (code === null || markdownLineEnding(code)) {
+				effects.exit(fenceType);
+				return ok(code);
+			}
+			return nok(code);
+		}
+	}
+}
+/**
+* @param {Matter} matter
+* @param {'close' | 'open'} prop
+* @returns {string}
+*/
+function fence(matter, prop) {
+	return matter.marker ? pick(matter.marker, prop).repeat(3) : pick(matter.fence, prop);
+}
+/**
+* @param {Info | string} schema
+* @param {'close' | 'open'} prop
+* @returns {string}
+*/
+function pick(schema, prop) {
+	return typeof schema === "string" ? schema : schema[prop];
+}
+//#endregion
+export { frontmatter };

package/dist/src/node_modules/.pnpm/micromark-extension-frontmatter@2.0.0/node_modules/micromark-extension-frontmatter/lib/to-matters.mjs

@@ -0,0 +1,109 @@
+import { fault } from "../../../../fault@2.0.1/node_modules/fault/index.mjs";
+//#region node_modules/.pnpm/micromark-extension-frontmatter@2.0.0/node_modules/micromark-extension-frontmatter/lib/to-matters.js
+/**
+* @typedef {'toml' | 'yaml'} Preset
+*   Known name of a frontmatter style.
+*
+* @typedef Info
+*   Sequence.
+*
+*   Depending on how this structure is used, it reflects a marker or a fence.
+* @property {string} close
+*   Closing.
+* @property {string} open
+*   Opening.
+*
+* @typedef MatterProps
+*   Fields describing a kind of matter.
+* @property {string} type
+*   Node type to tokenize as.
+* @property {boolean | null | undefined} [anywhere=false]
+*   Whether matter can be found anywhere in the document, normally, only matter
+*   at the start of the document is recognized.
+*
+*   > 👉 **Note**: using this is a terrible idea.
+*   > It’s called frontmatter, not matter-in-the-middle or so.
+*   > This makes your markdown less portable.
+*
+* @typedef MarkerProps
+*   Marker configuration.
+* @property {Info | string} marker
+*   Character repeated 3 times, used as complete fences.
+*
+*   For example the character `'-'` will result in `'---'` being used as the
+*   fence
+*   Pass `open` and `close` to specify different characters for opening and
+*   closing fences.
+* @property {never} [fence]
+*   If `marker` is set, `fence` must not be set.
+*
+* @typedef FenceProps
+*   Fence configuration.
+* @property {Info | string} fence
+*   Complete fences.
+*
+*   This can be used when fences contain different characters or lengths
+*   other than 3.
+*   Pass `open` and `close` to interface to specify different characters for opening and
+*   closing fences.
+* @property {never} [marker]
+*   If `fence` is set, `marker` must not be set.
+*
+* @typedef {(MatterProps & FenceProps) | (MatterProps & MarkerProps)} Matter
+*   Fields describing a kind of matter.
+*
+*   > 👉 **Note**: using `anywhere` is a terrible idea.
+*   > It’s called frontmatter, not matter-in-the-middle or so.
+*   > This makes your markdown less portable.
+*
+*   > 👉 **Note**: `marker` and `fence` are mutually exclusive.
+*   > If `marker` is set, `fence` must not be set, and vice versa.
+*
+* @typedef {Matter | Preset | Array<Matter | Preset>} Options
+*   Configuration.
+*/
+const own = {}.hasOwnProperty;
+const markers = {
+	yaml: "-",
+	toml: "+"
+};
+/**
+* Simplify options by normalizing them to an array of matters.
+*
+* @param {Options | null | undefined} [options='yaml']
+*   Configuration (default: `'yaml'`).
+* @returns {Array<Matter>}
+*   List of matters.
+*/
+function toMatters(options) {
+	/** @type {Array<Matter>} */
+	const result = [];
+	let index = -1;
+	/** @type {Array<Matter | Preset>} */
+	const presetsOrMatters = Array.isArray(options) ? options : options ? [options] : ["yaml"];
+	while (++index < presetsOrMatters.length) result[index] = matter(presetsOrMatters[index]);
+	return result;
+}
+/**
+* Simplify an option.
+*
+* @param {Matter | Preset} option
+*   Configuration.
+* @returns {Matter}
+*   Matter.
+*/
+function matter(option) {
+	let result = option;
+	if (typeof result === "string") {
+		if (!own.call(markers, result)) throw fault("Missing matter definition for `%s`", result);
+		result = {
+			type: result,
+			marker: markers[result]
+		};
+	} else if (typeof result !== "object") throw fault("Expected matter to be an object, not `%j`", result);
+	if (!own.call(result, "type")) throw fault("Missing `type` in matter `%j`", result);
+	if (!own.call(result, "fence") && !own.call(result, "marker")) throw fault("Missing `marker` or `fence` in matter `%j`", result);
+	return result;
+}
+//#endregion
+export { toMatters };

package/dist/src/node_modules/.pnpm/micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.mjs

@@ -0,0 +1,186 @@
+import { asciiControl, markdownLineEnding, markdownLineEndingOrSpace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.mjs";
+//#region node_modules/.pnpm/micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.js
+/**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
+* Parse destinations.
+*
+* ###### Examples
+*
+* ```markdown
+* <a>
+* <a\>b>
+* <a b>
+* <a)>
+* a
+* a\)b
+* a(b)c
+* a(b)
+* ```
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {State} nok
+*   State switched to when unsuccessful.
+* @param {TokenType} type
+*   Type for whole (`<a>` or `b`).
+* @param {TokenType} literalType
+*   Type when enclosed (`<a>`).
+* @param {TokenType} literalMarkerType
+*   Type for enclosing (`<` and `>`).
+* @param {TokenType} rawType
+*   Type when not enclosed (`b`).
+* @param {TokenType} stringType
+*   Type for the value (`a` or `b`).
+* @param {number | undefined} [max=Infinity]
+*   Depth of nested parens (inclusive).
+* @returns {State}
+*   Start state.
+*/
+function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {
+	const limit = max || Number.POSITIVE_INFINITY;
+	let balance = 0;
+	return start;
+	/**
+	* Start of destination.
+	*
+	* ```markdown
+	* > | <aa>
+	*     ^
+	* > | aa
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		if (code === 60) {
+			effects.enter(type);
+			effects.enter(literalType);
+			effects.enter(literalMarkerType);
+			effects.consume(code);
+			effects.exit(literalMarkerType);
+			return enclosedBefore;
+		}
+		if (code === null || code === 32 || code === 41 || asciiControl(code)) return nok(code);
+		effects.enter(type);
+		effects.enter(rawType);
+		effects.enter(stringType);
+		effects.enter("chunkString", { contentType: "string" });
+		return raw(code);
+	}
+	/**
+	* After `<`, at an enclosed destination.
+	*
+	* ```markdown
+	* > | <aa>
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function enclosedBefore(code) {
+		if (code === 62) {
+			effects.enter(literalMarkerType);
+			effects.consume(code);
+			effects.exit(literalMarkerType);
+			effects.exit(literalType);
+			effects.exit(type);
+			return ok;
+		}
+		effects.enter(stringType);
+		effects.enter("chunkString", { contentType: "string" });
+		return enclosed(code);
+	}
+	/**
+	* In enclosed destination.
+	*
+	* ```markdown
+	* > | <aa>
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function enclosed(code) {
+		if (code === 62) {
+			effects.exit("chunkString");
+			effects.exit(stringType);
+			return enclosedBefore(code);
+		}
+		if (code === null || code === 60 || markdownLineEnding(code)) return nok(code);
+		effects.consume(code);
+		return code === 92 ? enclosedEscape : enclosed;
+	}
+	/**
+	* After `\`, at a special character.
+	*
+	* ```markdown
+	* > | <a\*a>
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function enclosedEscape(code) {
+		if (code === 60 || code === 62 || code === 92) {
+			effects.consume(code);
+			return enclosed;
+		}
+		return enclosed(code);
+	}
+	/**
+	* In raw destination.
+	*
+	* ```markdown
+	* > | aa
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function raw(code) {
+		if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {
+			effects.exit("chunkString");
+			effects.exit(stringType);
+			effects.exit(rawType);
+			effects.exit(type);
+			return ok(code);
+		}
+		if (balance < limit && code === 40) {
+			effects.consume(code);
+			balance++;
+			return raw;
+		}
+		if (code === 41) {
+			effects.consume(code);
+			balance--;
+			return raw;
+		}
+		if (code === null || code === 32 || code === 40 || asciiControl(code)) return nok(code);
+		effects.consume(code);
+		return code === 92 ? rawEscape : raw;
+	}
+	/**
+	* After `\`, at special character.
+	*
+	* ```markdown
+	* > | a\*a
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function rawEscape(code) {
+		if (code === 40 || code === 41 || code === 92) {
+			effects.consume(code);
+			return raw;
+		}
+		return raw(code);
+	}
+}
+//#endregion
+export { factoryDestination };