cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyString.mjs

@@ -0,0 +1,229 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+import { require_foldFlowLines } from "./foldFlowLines.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/stringify/stringifyString.js
+var require_stringifyString = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	var foldFlowLines = require_foldFlowLines();
+	const getFoldOptions = (ctx, isBlock) => ({
+		indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
+		lineWidth: ctx.options.lineWidth,
+		minContentWidth: ctx.options.minContentWidth
+	});
+	const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
+	function lineLengthOverLimit(str, lineWidth, indentLength) {
+		if (!lineWidth || lineWidth < 0) return false;
+		const limit = lineWidth - indentLength;
+		const strLen = str.length;
+		if (strLen <= limit) return false;
+		for (let i = 0, start = 0; i < strLen; ++i) if (str[i] === "\n") {
+			if (i - start > limit) return true;
+			start = i + 1;
+			if (strLen - start <= limit) return false;
+		}
+		return true;
+	}
+	function doubleQuotedString(value, ctx) {
+		const json = JSON.stringify(value);
+		if (ctx.options.doubleQuotedAsJSON) return json;
+		const { implicitKey } = ctx;
+		const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
+		const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+		let str = "";
+		let start = 0;
+		for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
+			if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
+				str += json.slice(start, i) + "\\ ";
+				i += 1;
+				start = i;
+				ch = "\\";
+			}
+			if (ch === "\\") switch (json[i + 1]) {
+				case "u":
+					{
+						str += json.slice(start, i);
+						const code = json.substr(i + 2, 4);
+						switch (code) {
+							case "0000":
+								str += "\\0";
+								break;
+							case "0007":
+								str += "\\a";
+								break;
+							case "000b":
+								str += "\\v";
+								break;
+							case "001b":
+								str += "\\e";
+								break;
+							case "0085":
+								str += "\\N";
+								break;
+							case "00a0":
+								str += "\\_";
+								break;
+							case "2028":
+								str += "\\L";
+								break;
+							case "2029":
+								str += "\\P";
+								break;
+							default: if (code.substr(0, 2) === "00") str += "\\x" + code.substr(2);
+							else str += json.substr(i, 6);
+						}
+						i += 5;
+						start = i + 1;
+					}
+					break;
+				case "n":
+					if (implicitKey || json[i + 2] === "\"" || json.length < minMultiLineLength) i += 1;
+					else {
+						str += json.slice(start, i) + "\n\n";
+						while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== "\"") {
+							str += "\n";
+							i += 2;
+						}
+						str += indent;
+						if (json[i + 2] === " ") str += "\\";
+						i += 1;
+						start = i + 1;
+					}
+					break;
+				default: i += 1;
+			}
+		}
+		str = start ? str + json.slice(start) : json;
+		return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
+	}
+	function singleQuotedString(value, ctx) {
+		if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx);
+		const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
+		const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
+		return ctx.implicitKey ? res : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
+	}
+	function quotedString(value, ctx) {
+		const { singleQuote } = ctx.options;
+		let qs;
+		if (singleQuote === false) qs = doubleQuotedString;
+		else {
+			const hasDouble = value.includes("\"");
+			const hasSingle = value.includes("'");
+			if (hasDouble && !hasSingle) qs = singleQuotedString;
+			else if (hasSingle && !hasDouble) qs = doubleQuotedString;
+			else qs = singleQuote ? singleQuotedString : doubleQuotedString;
+		}
+		return qs(value, ctx);
+	}
+	let blockEndNewlines;
+	try {
+		blockEndNewlines = /* @__PURE__ */ new RegExp("(^|(?<!\n))\n+(?!\n|$)", "g");
+	} catch {
+		blockEndNewlines = /\n+(?!\n|$)/g;
+	}
+	function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+		const { blockQuote, commentString, lineWidth } = ctx.options;
+		if (!blockQuote || /\n[\t ]+$/.test(value)) return quotedString(value, ctx);
+		const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
+		const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
+		if (!value) return literal ? "|\n" : ">\n";
+		let chomp;
+		let endStart;
+		for (endStart = value.length; endStart > 0; --endStart) {
+			const ch = value[endStart - 1];
+			if (ch !== "\n" && ch !== "	" && ch !== " ") break;
+		}
+		let end = value.substring(endStart);
+		const endNlPos = end.indexOf("\n");
+		if (endNlPos === -1) chomp = "-";
+		else if (value === end || endNlPos !== end.length - 1) {
+			chomp = "+";
+			if (onChompKeep) onChompKeep();
+		} else chomp = "";
+		if (end) {
+			value = value.slice(0, -end.length);
+			if (end[end.length - 1] === "\n") end = end.slice(0, -1);
+			end = end.replace(blockEndNewlines, `$&${indent}`);
+		}
+		let startWithSpace = false;
+		let startEnd;
+		let startNlPos = -1;
+		for (startEnd = 0; startEnd < value.length; ++startEnd) {
+			const ch = value[startEnd];
+			if (ch === " ") startWithSpace = true;
+			else if (ch === "\n") startNlPos = startEnd;
+			else break;
+		}
+		let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+		if (start) {
+			value = value.substring(start.length);
+			start = start.replace(/\n+/g, `$&${indent}`);
+		}
+		let header = (startWithSpace ? indent ? "2" : "1" : "") + chomp;
+		if (comment) {
+			header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " "));
+			if (onComment) onComment();
+		}
+		if (!literal) {
+			const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
+			let literalFallback = false;
+			const foldOptions = getFoldOptions(ctx, true);
+			if (blockQuote !== "folded" && type !== Scalar.Scalar.BLOCK_FOLDED) foldOptions.onOverflow = () => {
+				literalFallback = true;
+			};
+			const body = foldFlowLines.foldFlowLines(`${start}${foldedValue}${end}`, indent, foldFlowLines.FOLD_BLOCK, foldOptions);
+			if (!literalFallback) return `>${header}\n${indent}${body}`;
+		}
+		value = value.replace(/\n+/g, `$&${indent}`);
+		return `|${header}\n${indent}${start}${value}${end}`;
+	}
+	function plainString(item, ctx, onComment, onChompKeep) {
+		const { type, value } = item;
+		const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+		if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) return quotedString(value, ctx);
+		if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
+		if (!implicitKey && !inFlow && type !== Scalar.Scalar.PLAIN && value.includes("\n")) return blockString(item, ctx, onComment, onChompKeep);
+		if (containsDocumentMarker(value)) {
+			if (indent === "") {
+				ctx.forceBlockIndent = true;
+				return blockString(item, ctx, onComment, onChompKeep);
+			} else if (implicitKey && indent === indentStep) return quotedString(value, ctx);
+		}
+		const str = value.replace(/\n+/g, `$&\n${indent}`);
+		if (actualString) {
+			const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str);
+			const { compat, tags } = ctx.doc.schema;
+			if (tags.some(test) || compat?.some(test)) return quotedString(value, ctx);
+		}
+		return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
+	}
+	function stringifyString(item, ctx, onComment, onChompKeep) {
+		const { implicitKey, inFlow } = ctx;
+		const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) });
+		let { type } = item;
+		if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
+			if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) type = Scalar.Scalar.QUOTE_DOUBLE;
+		}
+		const _stringify = (_type) => {
+			switch (_type) {
+				case Scalar.Scalar.BLOCK_FOLDED:
+				case Scalar.Scalar.BLOCK_LITERAL: return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep);
+				case Scalar.Scalar.QUOTE_DOUBLE: return doubleQuotedString(ss.value, ctx);
+				case Scalar.Scalar.QUOTE_SINGLE: return singleQuotedString(ss.value, ctx);
+				case Scalar.Scalar.PLAIN: return plainString(ss, ctx, onComment, onChompKeep);
+				default: return null;
+			}
+		};
+		let res = _stringify(type);
+		if (res === null) {
+			const { defaultKeyType, defaultStringType } = ctx.options;
+			const t = implicitKey && defaultKeyType || defaultStringType;
+			res = _stringify(t);
+			if (res === null) throw new Error(`Unsupported default string type ${t}`);
+		}
+		return res;
+	}
+	exports.stringifyString = stringifyString;
+}));
+//#endregion
+export default require_stringifyString();
+export { require_stringifyString };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/visit.mjs

@@ -0,0 +1,194 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "./nodes/identity.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/visit.js
+var require_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	const BREAK = Symbol("break visit");
+	const SKIP = Symbol("skip children");
+	const REMOVE = Symbol("remove node");
+	/**
+	* Apply a visitor to an AST node or document.
+	*
+	* Walks through the tree (depth-first) starting from `node`, calling a
+	* `visitor` function with three arguments:
+	*   - `key`: For sequence values and map `Pair`, the node's index in the
+	*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+	*     `null` for the root node.
+	*   - `node`: The current node.
+	*   - `path`: The ancestry of the current node.
+	*
+	* The return value of the visitor may be used to control the traversal:
+	*   - `undefined` (default): Do nothing and continue
+	*   - `visit.SKIP`: Do not visit the children of this node, continue with next
+	*     sibling
+	*   - `visit.BREAK`: Terminate traversal completely
+	*   - `visit.REMOVE`: Remove the current node, then continue with the next one
+	*   - `Node`: Replace the current node, then continue by visiting it
+	*   - `number`: While iterating the items of a sequence or map, set the index
+	*     of the next step. This is useful especially if the index of the current
+	*     node has changed.
+	*
+	* If `visitor` is a single function, it will be called with all values
+	* encountered in the tree, including e.g. `null` values. Alternatively,
+	* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+	* `Alias` and `Scalar` node. To define the same visitor function for more than
+	* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+	* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+	* specific defined one will be used for each node.
+	*/
+	function visit(node, visitor) {
+		const visitor_ = initVisitor(visitor);
+		if (identity.isDocument(node)) {
+			if (visit_(null, node.contents, visitor_, Object.freeze([node])) === REMOVE) node.contents = null;
+		} else visit_(null, node, visitor_, Object.freeze([]));
+	}
+	/** Terminate visit traversal completely */
+	visit.BREAK = BREAK;
+	/** Do not visit the children of the current node */
+	visit.SKIP = SKIP;
+	/** Remove the current node */
+	visit.REMOVE = REMOVE;
+	function visit_(key, node, visitor, path) {
+		const ctrl = callVisitor(key, node, visitor, path);
+		if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
+			replaceNode(key, path, ctrl);
+			return visit_(key, ctrl, visitor, path);
+		}
+		if (typeof ctrl !== "symbol") {
+			if (identity.isCollection(node)) {
+				path = Object.freeze(path.concat(node));
+				for (let i = 0; i < node.items.length; ++i) {
+					const ci = visit_(i, node.items[i], visitor, path);
+					if (typeof ci === "number") i = ci - 1;
+					else if (ci === BREAK) return BREAK;
+					else if (ci === REMOVE) {
+						node.items.splice(i, 1);
+						i -= 1;
+					}
+				}
+			} else if (identity.isPair(node)) {
+				path = Object.freeze(path.concat(node));
+				const ck = visit_("key", node.key, visitor, path);
+				if (ck === BREAK) return BREAK;
+				else if (ck === REMOVE) node.key = null;
+				const cv = visit_("value", node.value, visitor, path);
+				if (cv === BREAK) return BREAK;
+				else if (cv === REMOVE) node.value = null;
+			}
+		}
+		return ctrl;
+	}
+	/**
+	* Apply an async visitor to an AST node or document.
+	*
+	* Walks through the tree (depth-first) starting from `node`, calling a
+	* `visitor` function with three arguments:
+	*   - `key`: For sequence values and map `Pair`, the node's index in the
+	*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+	*     `null` for the root node.
+	*   - `node`: The current node.
+	*   - `path`: The ancestry of the current node.
+	*
+	* The return value of the visitor may be used to control the traversal:
+	*   - `Promise`: Must resolve to one of the following values
+	*   - `undefined` (default): Do nothing and continue
+	*   - `visit.SKIP`: Do not visit the children of this node, continue with next
+	*     sibling
+	*   - `visit.BREAK`: Terminate traversal completely
+	*   - `visit.REMOVE`: Remove the current node, then continue with the next one
+	*   - `Node`: Replace the current node, then continue by visiting it
+	*   - `number`: While iterating the items of a sequence or map, set the index
+	*     of the next step. This is useful especially if the index of the current
+	*     node has changed.
+	*
+	* If `visitor` is a single function, it will be called with all values
+	* encountered in the tree, including e.g. `null` values. Alternatively,
+	* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+	* `Alias` and `Scalar` node. To define the same visitor function for more than
+	* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+	* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+	* specific defined one will be used for each node.
+	*/
+	async function visitAsync(node, visitor) {
+		const visitor_ = initVisitor(visitor);
+		if (identity.isDocument(node)) {
+			if (await visitAsync_(null, node.contents, visitor_, Object.freeze([node])) === REMOVE) node.contents = null;
+		} else await visitAsync_(null, node, visitor_, Object.freeze([]));
+	}
+	/** Terminate visit traversal completely */
+	visitAsync.BREAK = BREAK;
+	/** Do not visit the children of the current node */
+	visitAsync.SKIP = SKIP;
+	/** Remove the current node */
+	visitAsync.REMOVE = REMOVE;
+	async function visitAsync_(key, node, visitor, path) {
+		const ctrl = await callVisitor(key, node, visitor, path);
+		if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
+			replaceNode(key, path, ctrl);
+			return visitAsync_(key, ctrl, visitor, path);
+		}
+		if (typeof ctrl !== "symbol") {
+			if (identity.isCollection(node)) {
+				path = Object.freeze(path.concat(node));
+				for (let i = 0; i < node.items.length; ++i) {
+					const ci = await visitAsync_(i, node.items[i], visitor, path);
+					if (typeof ci === "number") i = ci - 1;
+					else if (ci === BREAK) return BREAK;
+					else if (ci === REMOVE) {
+						node.items.splice(i, 1);
+						i -= 1;
+					}
+				}
+			} else if (identity.isPair(node)) {
+				path = Object.freeze(path.concat(node));
+				const ck = await visitAsync_("key", node.key, visitor, path);
+				if (ck === BREAK) return BREAK;
+				else if (ck === REMOVE) node.key = null;
+				const cv = await visitAsync_("value", node.value, visitor, path);
+				if (cv === BREAK) return BREAK;
+				else if (cv === REMOVE) node.value = null;
+			}
+		}
+		return ctrl;
+	}
+	function initVisitor(visitor) {
+		if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) return Object.assign({
+			Alias: visitor.Node,
+			Map: visitor.Node,
+			Scalar: visitor.Node,
+			Seq: visitor.Node
+		}, visitor.Value && {
+			Map: visitor.Value,
+			Scalar: visitor.Value,
+			Seq: visitor.Value
+		}, visitor.Collection && {
+			Map: visitor.Collection,
+			Seq: visitor.Collection
+		}, visitor);
+		return visitor;
+	}
+	function callVisitor(key, node, visitor, path) {
+		if (typeof visitor === "function") return visitor(key, node, path);
+		if (identity.isMap(node)) return visitor.Map?.(key, node, path);
+		if (identity.isSeq(node)) return visitor.Seq?.(key, node, path);
+		if (identity.isPair(node)) return visitor.Pair?.(key, node, path);
+		if (identity.isScalar(node)) return visitor.Scalar?.(key, node, path);
+		if (identity.isAlias(node)) return visitor.Alias?.(key, node, path);
+	}
+	function replaceNode(key, path, node) {
+		const parent = path[path.length - 1];
+		if (identity.isCollection(parent)) parent.items[key] = node;
+		else if (identity.isPair(parent)) if (key === "key") parent.key = node;
+		else parent.value = node;
+		else if (identity.isDocument(parent)) parent.contents = node;
+		else {
+			const pt = identity.isAlias(parent) ? "alias" : "scalar";
+			throw new Error(`Cannot replace node with ${pt} parent`);
+		}
+	}
+	exports.visit = visit;
+	exports.visitAsync = visitAsync;
+}));
+//#endregion
+export default require_visit();
+export { require_visit };

package/dist/src/node_modules/.pnpm/zwitch@2.0.4/node_modules/zwitch/index.mjs

@@ -0,0 +1,106 @@
+//#region node_modules/.pnpm/zwitch@2.0.4/node_modules/zwitch/index.js
+/**
+* @callback Handler
+*   Handle a value, with a certain ID field set to a certain value.
+*   The ID field is passed to `zwitch`, and it’s value is this function’s
+*   place on the `handlers` record.
+* @param {...any} parameters
+*   Arbitrary parameters passed to the zwitch.
+*   The first will be an object with a certain ID field set to a certain value.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback UnknownHandler
+*   Handle values that do have a certain ID field, but it’s set to a value
+*   that is not listed in the `handlers` record.
+* @param {unknown} value
+*   An object with a certain ID field set to an unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback InvalidHandler
+*   Handle values that do not have a certain ID field.
+* @param {unknown} value
+*   Any unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {void|null|undefined|never}
+*   This should crash or return nothing.
+*/
+/**
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @typedef Options
+*   Configuration (required).
+* @property {Invalid} [invalid]
+*   Handler to use for invalid values.
+* @property {Unknown} [unknown]
+*   Handler to use for unknown values.
+* @property {Handlers} [handlers]
+*   Handlers to use.
+*/
+const own = {}.hasOwnProperty;
+/**
+* Handle values based on a field.
+*
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @param {string} key
+*   Field to switch on.
+* @param {Options<Invalid, Unknown, Handlers>} [options]
+*   Configuration (required).
+* @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}
+*/
+function zwitch(key, options) {
+	const settings = options || {};
+	/**
+	* Handle one value.
+	*
+	* Based on the bound `key`, a respective handler will be called.
+	* If `value` is not an object, or doesn’t have a `key` property, the special
+	* “invalid” handler will be called.
+	* If `value` has an unknown `key`, the special “unknown” handler will be
+	* called.
+	*
+	* All arguments, and the context object, are passed through to the handler,
+	* and it’s result is returned.
+	*
+	* @this {unknown}
+	*   Any context object.
+	* @param {unknown} [value]
+	*   Any value.
+	* @param {...unknown} parameters
+	*   Arbitrary parameters passed to the zwitch.
+	* @property {Handler} invalid
+	*   Handle for values that do not have a certain ID field.
+	* @property {Handler} unknown
+	*   Handle values that do have a certain ID field, but it’s set to a value
+	*   that is not listed in the `handlers` record.
+	* @property {Handlers} handlers
+	*   Record of handlers.
+	* @returns {unknown}
+	*   Anything.
+	*/
+	function one(value, ...parameters) {
+		/** @type {Handler|undefined} */
+		let fn = one.invalid;
+		const handlers = one.handlers;
+		if (value && own.call(value, key)) {
+			const id = String(value[key]);
+			fn = own.call(handlers, id) ? handlers[id] : one.unknown;
+		}
+		if (fn) return fn.call(this, value, ...parameters);
+	}
+	one.handlers = settings.handlers || {};
+	one.invalid = settings.invalid;
+	one.unknown = settings.unknown;
+	return one;
+}
+//#endregion
+export { zwitch };

package/dist/src/pkg.d.mts

@@ -0,0 +1,24 @@
+import { DirtyFileAbsPath, Package, PkgFileAbsPath } from "./types.mjs";
+
+//#region src/pkg.d.ts
+/**
+ * Read the name and version of a package from its package.json.
+ *
+ * @param pkgFilePath - The package descriptor (name + file path)
+ * @param rootDir - The root directory of the monorepo
+ * @returns Pack
+ * @throws If the package.json is missing or has no valid name or version
+ */
+declare function readPkg(pkgFilePath: PkgFileAbsPath, rootDir: string): Package;
+/**
+ * Update the version of a package in its package.json,
+ * preserving the original indentation style.
+ *
+ * @param pkgFilePath - The package descriptor (name + file path)
+ * @param rootDir - The root directory of the monorepo
+ * @param newVersion - The new version string to set
+ * @throws If the package.json is missing or cannot be written
+ */
+declare function updatePkgVersion(pkgFilePath: PkgFileAbsPath, rootDir: string, newVersion: string): DirtyFileAbsPath[];
+//#endregion
+export { readPkg, updatePkgVersion };

package/dist/src/pkg.mjs

@@ -0,0 +1,39 @@
+import { detectIndentation } from "./utils.mjs";
+import fs from "node:fs";
+//#region src/pkg.ts
+/**
+* Read the name and version of a package from its package.json.
+*
+* @param pkgFilePath - The package descriptor (name + file path)
+* @param rootDir - The root directory of the monorepo
+* @returns Pack
+* @throws If the package.json is missing or has no valid name or version
+*/
+function readPkg(pkgFilePath, rootDir) {
+	const content = fs.readFileSync(pkgFilePath, "utf-8");
+	const pkg = JSON.parse(content);
+	if (!pkg.name || !pkg.version) throw new Error(`Invalid package.json: ${pkgFilePath}`);
+	return {
+		name: pkg.name,
+		version: pkg.version
+	};
+}
+/**
+* Update the version of a package in its package.json,
+* preserving the original indentation style.
+*
+* @param pkgFilePath - The package descriptor (name + file path)
+* @param rootDir - The root directory of the monorepo
+* @param newVersion - The new version string to set
+* @throws If the package.json is missing or cannot be written
+*/
+function updatePkgVersion(pkgFilePath, rootDir, newVersion) {
+	const packageJsonRaw = fs.readFileSync(pkgFilePath, "utf-8");
+	const indent = detectIndentation(packageJsonRaw);
+	const pkgJson = JSON.parse(packageJsonRaw);
+	pkgJson.version = newVersion;
+	fs.writeFileSync(pkgFilePath, `${JSON.stringify(pkgJson, null, indent)}\n`, "utf-8");
+	return [pkgFilePath];
+}
+//#endregion
+export { readPkg, updatePkgVersion };

package/dist/src/prepare.d.mts

@@ -0,0 +1,14 @@
+import { Changenote, ChangenoteCommit, PkgFileAbsPath, VersionBump } from "./types.mjs";
+
+//#region src/prepare.d.ts
+/** Calculate version bump from changenotes */
+declare function calculateVersionBump(pkgFilePath: PkgFileAbsPath, changenotes: (Changenote & {
+  commit?: ChangenoteCommit;
+})[], rootDir: string, prepareConfig?: {
+  type: "release";
+} | {
+  type: "prerelease" | "prepatch" | "preminor" | "premajor";
+  tag: string;
+}): Promise<VersionBump>;
+//#endregion
+export { calculateVersionBump };

package/dist/src/prepare.mjs

@@ -0,0 +1,41 @@
+import { readPkg } from "./pkg.mjs";
+import * as semver from "semver";
+//#region src/prepare.ts
+const BUMP_PRIORITY = {
+	major: 3,
+	minor: 2,
+	patch: 1
+};
+/** Get the highest priority bump from a list */
+function highestBump(bumps) {
+	let max = "patch";
+	for (const b of bumps) if (BUMP_PRIORITY[b] > BUMP_PRIORITY[max]) max = b;
+	return max;
+}
+/** Calculate version bump from changenotes */
+async function calculateVersionBump(pkgFilePath, changenotes, rootDir, prepareConfig) {
+	const pkgJson = readPkg(pkgFilePath, rootDir);
+	const currentVersion = pkgJson.version;
+	const packageName = pkgJson.name;
+	if (!currentVersion || !semver.valid(currentVersion)) throw new Error(`Package "${packageName}" has invalid version: ${currentVersion}`);
+	const bumps = /* @__PURE__ */ new Set();
+	for (const cn of changenotes) bumps.add(cn.meta.bump);
+	const bump = highestBump(Array.from(bumps));
+	let newVersion;
+	if (prepareConfig?.type === "prerelease") {
+		const tag = prepareConfig.tag;
+		const pre = semver.prerelease(currentVersion);
+		if (pre && pre[0] === tag) newVersion = semver.inc(currentVersion, "prerelease", tag);
+		else newVersion = semver.inc(currentVersion, `pre${bump}`, tag);
+	} else if (prepareConfig?.type === "prepatch" || prepareConfig?.type === "preminor" || prepareConfig?.type === "premajor") newVersion = semver.inc(currentVersion, prepareConfig.type, prepareConfig.tag);
+	else newVersion = semver.inc(currentVersion, bump);
+	if (!newVersion) throw new Error(`Failed to increment version ${currentVersion} with bump ${bump}`);
+	return {
+		packageName,
+		currentVersion,
+		newVersion,
+		bump
+	};
+}
+//#endregion
+export { calculateVersionBump };

package/dist/src/publishers/npm.d.mts

@@ -0,0 +1,21 @@
+import { PublisherPlugin } from "../types.mjs";
+
+//#region src/publishers/npm.d.ts
+interface NpmPublisherOptions {
+  /** NPM registry URL (defaults to https://registry.npmjs.org) */
+  registry?: string;
+  /** Environment variables to pass to the npm publish command */
+  env?: Record<string, string>;
+  /** Custom publish arguments (e.g., ['--access', 'public'] for scoped packages) */
+  args?: string[];
+  /** Whether to enable GitHub Actions Provenance (SLSA attestation) (defaults to true) */
+  provenance?: boolean;
+}
+/**
+ * Creates an npm publisher plugin.
+ * Publishes the package to the npm registry.
+ * Supports GitHub Actions Provenance (SLSA attestation) for signed releases.
+ */
+declare function createNpmPublisher(options?: NpmPublisherOptions): PublisherPlugin;
+//#endregion
+export { NpmPublisherOptions, createNpmPublisher };