@kubb/cli 5.14.5 → 5.15.0

package/dist/configFile-C0DIXNMD.js

@@ -0,0 +1,993 @@
+import "./rolldown-runtime-xo6NMXYd.js";
+import { t as getErrorMessage } from "./errors-wzqmMpMo.js";
+import { c as writeRaw, o as read } from "./spinner-BZaln7O8.js";
+import { isPackageName } from "@kubb/core";
+import { parse } from "yuku-parser";
+// ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function convert(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+const cache = /* @__PURE__ */ new Map();
+const cacheLimit = 1e5;
+function toCamelOrPascal(text, pascal) {
+	const key = `${pascal ? "P" : "c"}${text}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const result = convert(text, pascal);
+	if (cache.size >= cacheLimit) cache.clear();
+	cache.set(key, result);
+	return result;
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+// ../../internals/shared/src/configFile/ast.ts
+/** Node types the config editor reads from the yuku AST. */
+const nodeTypes = {
+	arrayExpression: "ArrayExpression",
+	arrowFunctionExpression: "ArrowFunctionExpression",
+	assignmentExpression: "AssignmentExpression",
+	blockStatement: "BlockStatement",
+	callExpression: "CallExpression",
+	exportDefaultDeclaration: "ExportDefaultDeclaration",
+	expressionStatement: "ExpressionStatement",
+	functionExpression: "FunctionExpression",
+	identifier: "Identifier",
+	importDeclaration: "ImportDeclaration",
+	importSpecifier: "ImportSpecifier",
+	literal: "Literal",
+	memberExpression: "MemberExpression",
+	objectExpression: "ObjectExpression",
+	objectPattern: "ObjectPattern",
+	property: "Property",
+	returnStatement: "ReturnStatement",
+	spreadElement: "SpreadElement",
+	tSAsExpression: "TSAsExpression",
+	tSSatisfiesExpression: "TSSatisfiesExpression",
+	templateLiteral: "TemplateLiteral",
+	unaryExpression: "UnaryExpression",
+	variableDeclaration: "VariableDeclaration"
+};
+const commentTypes = { line: "Line" };
+const propertyKinds = { init: "init" };
+const unaryOperators = {
+	minus: "-",
+	plus: "+"
+};
+const diagnosticSeverities = { error: "error" };
+/**
+* Parses `source` as a TypeScript module. Never throws: a syntax error, or a native parser that
+* cannot load on this platform, comes back as a `reason`.
+*/
+function parseSource(source) {
+	try {
+		const { program, comments, diagnostics } = parse(source, {
+			lang: "ts",
+			sourceType: "module",
+			preserveParens: false
+		});
+		if (diagnostics.some((diagnostic) => diagnostic.severity === diagnosticSeverities.error)) return { reason: "the config file could not be parsed" };
+		return {
+			program,
+			comments
+		};
+	} catch (error) {
+		return { reason: `the config parser could not load on this platform: ${getErrorMessage(error)}` };
+	}
+}
+/** Parses `source` as one expression, such as a commented-out `pluginTs({ ... })` call. */
+function parseExpression(source) {
+	const parsed = parseSource(source);
+	if ("reason" in parsed) return void 0;
+	const [statement] = parsed.program.body;
+	return parsed.program.body.length === 1 && statement?.type === nodeTypes.expressionStatement ? statement.expression : void 0;
+}
+// ../../internals/shared/src/configFile/types.ts
+const extensionKinds = {
+	plugin: "plugin",
+	adapter: "adapter",
+	parser: "parser"
+};
+const ConfigEditOperation = {
+	SET_OPTION: "set-option",
+	REMOVE_OPTION: "remove-option",
+	ADD_PLUGIN: "add-plugin",
+	REMOVE_EXTENSION: "remove-extension",
+	DISABLE_PLUGIN: "disable-plugin",
+	ENABLE_PLUGIN: "enable-plugin",
+	SET_INPUT: "set-input",
+	SET_OUTPUT: "set-output",
+	REMOVE_OUTPUT: "remove-output"
+};
+// ../../internals/shared/src/configFile/rules.ts
+/** `@kubb/plugin-ts` becomes `plugin-ts`, the `name` Kubb plugin factories use. */
+function toPluginName(packageName) {
+	return packageName.split("/").pop() ?? packageName;
+}
+/** `@kubb/plugin-react-query` becomes `pluginReactQuery`, the export a plugin package uses by convention. */
+function toExportName(packageName) {
+	return camelCase(toPluginName(packageName));
+}
+const KUBB_PLUGIN_SPECIFIER = /^@kubb\/plugin-[\w.-]+$/;
+/** Only a `@kubb/plugin-*` package or an installed extension of `kind` may be imported, never a path or URL. */
+function isAllowedPlugin({ packageName, extensions, kind = extensionKinds.plugin }) {
+	if (!isPackageName(packageName)) return false;
+	return kind === extensionKinds.plugin && KUBB_PLUGIN_SPECIFIER.test(packageName) || extensions.get(packageName)?.manifest.kind === kind;
+}
+const UNSAFE_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Whether `key` can be an option key without reaching the object's prototype. */
+function isSafeKey(key) {
+	return !UNSAFE_KEYS.has(key);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+}
+/** Whether `value` survives a JSON round trip, so an edit never writes a lossy copy into the file. */
+function isOptionValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isOptionValue);
+	if (isPlainObject(value)) return Object.entries(value).every(([key, entry]) => isSafeKey(key) && isOptionValue(entry));
+	return false;
+}
+/** The root `output` members Studio may set, with the values each takes. */
+const OUTPUT_VALUES = {
+	barrel: (value) => value === false || isPlainObject(value) && Object.keys(value).length === 1 && (value.type === "named" || value.type === "all"),
+	format: (value) => value === false || [
+		"auto",
+		"prettier",
+		"biome",
+		"oxfmt"
+	].includes(value),
+	lint: (value) => value === false || [
+		"auto",
+		"eslint",
+		"biome",
+		"oxlint"
+	].includes(value),
+	clean: (value) => typeof value === "boolean",
+	defaultBanner: (value) => value === false || value === "simple" || value === "full"
+};
+function isOutputKey(key) {
+	return Object.hasOwn(OUTPUT_VALUES, key);
+}
+function isOutputValue({ key, value }) {
+	return isOutputKey(key) && OUTPUT_VALUES[key](value);
+}
+function pickOutput(output) {
+	return Object.fromEntries(Object.entries(output).filter(([key]) => isOutputKey(key)));
+}
+// ../../internals/shared/src/configFile/text.ts
+/**
+* A valid JavaScript identifier, so an import name can only ever print as `import { name } from`,
+* never as source that breaks out of the import statement.
+*/
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/;
+const quotes = {
+	single: `'`,
+	double: `"`
+};
+/** `source` with the text between `start` and `end` replaced by `text`. */
+function replaceText(source, start, end, text = "") {
+	return `${source.slice(0, start)}${text}${source.slice(end)}`;
+}
+/** The 1-based line and 0-based column of `offset` in `source`. */
+function getPosition(source, offset) {
+	return {
+		line: source.slice(0, offset).split("\n").length,
+		column: offset - source.lastIndexOf("\n", offset - 1) - 1
+	};
+}
+/** Writes `value` as a single-line literal with the file's quote style. */
+function printValue(value, quote) {
+	if (typeof value === "string") {
+		const escaped = JSON.stringify(value).slice(1, -1);
+		return quote === quotes.double ? `"${escaped}"` : `'${escaped.replaceAll(`\\"`, `"`).replaceAll(`'`, `\\'`)}'`;
+	}
+	if (value === null || typeof value !== "object") return String(value);
+	if (Array.isArray(value)) return `[${value.map((item) => printValue(item, quote)).join(", ")}]`;
+	const entries = Object.entries(value);
+	return entries.length ? `{ ${entries.map(([key, item]) => `${printKey(key, quote)}: ${printValue(item, quote)}`).join(", ")} }` : "{}";
+}
+/** An object key as source text: bare when it is an identifier, quoted otherwise. */
+function printKey(key, quote) {
+	return IDENTIFIER_PATTERN.test(key) ? key : printValue(key, quote);
+}
+/** `value` wrapped in one object per key of `path`: `wrapPath(['enum', 'type'], 'enum')` is `{ enum: { type: 'enum' } }`. */
+function wrapPath(path, value) {
+	return path.reduceRight((inner, key) => ({ [key]: inner }), value);
+}
+/**
+* Adds `text` as the last item of an object or array literal, following its layout: on a line of
+* its own with the last item's indentation when the literal spans lines, inline otherwise.
+*/
+function appendItem(source, container, text) {
+	const { start, end } = container;
+	const last = (container.type === nodeTypes.objectExpression ? container.properties : container.elements).filter((item) => item !== null).at(-1);
+	if (!last) {
+		const inner = source.slice(start + 1, end - 1);
+		if (inner.trim()) return replaceText(source, start + 1, start + 1, /^\s/.test(inner) ? `${text},` : `${text}, `);
+		return replaceText(source, start, end, container.type === nodeTypes.objectExpression ? `{ ${text} }` : `[${text}]`);
+	}
+	const between = source.slice(last.end, end - 1);
+	if (!between.includes("\n")) return replaceText(source, last.end, last.end, `, ${text}`);
+	const lineStart = source.lastIndexOf("\n", last.start - 1) + 1;
+	const indent = source.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
+	const lineEnd = source.indexOf("\n", last.end);
+	const comma = /^\s*,/.test(between);
+	return `${source.slice(0, last.end)}${comma ? "" : ","}${source.slice(last.end, lineEnd)}\n${indent}${text}${comma ? "," : ""}${source.slice(lineEnd)}`;
+}
+/** Drops the item at `index` from an object or array literal, with its own lines when it sits on them alone. */
+function removeItem(source, node, index) {
+	const items = node.type === nodeTypes.objectExpression ? node.properties : node.elements.filter((element) => element !== null);
+	if (items.length === 1) return replaceText(source, node.start, node.end, node.type === nodeTypes.objectExpression ? "{}" : "[]");
+	const { start, end } = items[index];
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	const nextNewline = source.indexOf("\n", end);
+	const lineEnd = nextNewline === -1 ? source.length : nextNewline;
+	if (!source.slice(lineStart, start).trim() && /^\s*,?\s*(\/\/.*)?$/.test(source.slice(end, lineEnd))) return replaceText(source, lineStart, Math.min(lineEnd + 1, source.length));
+	const next = items[index + 1];
+	return next ? replaceText(source, start, next.start) : replaceText(source, items[index - 1].end, end);
+}
+// ../../internals/shared/src/configFile/configFile.ts
+/** The marker `disable-plugin` writes, with the block's line count so `enable-plugin` restores exactly those lines. */
+const DISABLED_MARKER_PATTERN = /^kubb:disabled (.+)\s+(\d+)$/;
+const OPERATIONS = new Set(Object.values(ConfigEditOperation));
+const OPTION_OPERATIONS = /* @__PURE__ */ new Set([ConfigEditOperation.SET_OPTION, ConfigEditOperation.REMOVE_OPTION]);
+const OUTPUT_OPERATIONS = /* @__PURE__ */ new Set([ConfigEditOperation.SET_OUTPUT, ConfigEditOperation.REMOVE_OUTPUT]);
+const KINDS = new Set(Object.values(extensionKinds));
+/** Identifiers the editor matches by name. */
+const identifiers = {
+	defineConfig: "defineConfig",
+	require: "require",
+	module: "module",
+	exports: "exports"
+};
+const moduleKinds = {
+	esm: "esm",
+	cjs: "cjs"
+};
+function isNonEmptyString(value) {
+	return typeof value === "string" && value !== "";
+}
+/** Edits cross the wire, so their shape is checked before anything reads them. */
+function validateEdit(edit) {
+	const { operation, plugin, config, path, kind, input } = typeof edit === "object" && edit !== null ? edit : {};
+	if (typeof operation !== "string" || !OPERATIONS.has(operation)) return `unknown operation ${JSON.stringify(operation)}`;
+	if (config !== void 0 && typeof config !== "string" && !Number.isSafeInteger(config)) return "config must name an entry or give its index";
+	if (operation === ConfigEditOperation.SET_INPUT) return typeof input === "string" && input.trim() !== "" ? void 0 : "the edit names no input";
+	const isOption = OPTION_OPERATIONS.has(operation);
+	const isOutput = OUTPUT_OPERATIONS.has(operation);
+	if (!isOutput && !isNonEmptyString(plugin)) return "the edit names no plugin";
+	if (kind !== void 0) {
+		if (typeof kind !== "string" || !KINDS.has(kind)) return `unknown kind ${JSON.stringify(kind)}`;
+		const takesKind = operation === ConfigEditOperation.ADD_PLUGIN || operation === ConfigEditOperation.REMOVE_EXTENSION;
+		if (takesKind && kind === extensionKinds.adapter) return `${operation} takes a plugin or a parser, since a config has one adapter`;
+		if (!isOption && !takesKind) return `${operation} edits the plugins array, so it takes no kind`;
+	}
+	if (!isOption && !isOutput) return void 0;
+	if (!Array.isArray(path) || !path.every(isNonEmptyString)) return "path must be a list of option names";
+	if (path.length === 0) return "no option path given";
+	const unsafe = path.find((key) => !isSafeKey(key));
+	if (unsafe !== void 0) return `${unsafe} cannot be used as an option name`;
+	if (isOutput && !isOutputKey(path[0])) return `output.${path[0]} can only be changed in the config file`;
+}
+/** Steps through `as`/`satisfies` and `() => ...` wrappers to the config object. */
+function unwrapValue(node) {
+	if (!node) return void 0;
+	if (node.type === nodeTypes.tSAsExpression || node.type === nodeTypes.tSSatisfiesExpression) return unwrapValue(node.expression);
+	if (node.type !== nodeTypes.arrowFunctionExpression && node.type !== nodeTypes.functionExpression) return node;
+	if (node.body?.type !== nodeTypes.blockStatement) return unwrapValue(node.body);
+	const returned = node.body.body.find((statement) => statement.type === nodeTypes.returnStatement);
+	return unwrapValue(returned?.type === nodeTypes.returnStatement ? returned.argument : void 0);
+}
+function isModuleExports(node) {
+	return node.type === nodeTypes.memberExpression && !node.computed && node.object.type === nodeTypes.identifier && node.object.name === identifiers.module && node.property.type === nodeTypes.identifier && node.property.name === identifiers.exports;
+}
+/** The exported config value and how the file exports it. */
+function findExport(program) {
+	for (const node of program.body) {
+		if (node.type === nodeTypes.exportDefaultDeclaration) return {
+			exported: node.declaration,
+			kind: moduleKinds.esm
+		};
+		if (node.type === nodeTypes.expressionStatement && node.expression.type === nodeTypes.assignmentExpression && isModuleExports(node.expression.left)) return {
+			exported: node.expression.right,
+			kind: moduleKinds.cjs
+		};
+	}
+	return {
+		exported: void 0,
+		kind: moduleKinds.esm
+	};
+}
+/** Every config object in `export default` or `module.exports = defineConfig(...)`, or why the file is unmanaged. */
+function findConfigs(source) {
+	const parsed = parseSource(source);
+	if ("reason" in parsed) return parsed;
+	const { exported, kind } = findExport(parsed.program);
+	const value = unwrapValue(exported);
+	if (!value) return { reason: "no `export default` or `module.exports` found" };
+	if (value.type !== nodeTypes.callExpression || value.callee.type !== nodeTypes.identifier || value.callee.name !== identifiers.defineConfig) return { reason: "the exported config is not a defineConfig(...) call" };
+	const argument = unwrapValue(value.arguments[0]);
+	if (!argument) return { reason: "defineConfig(...) was called without a config" };
+	const entries = argument.type === nodeTypes.arrayExpression ? argument.elements.map((element) => unwrapValue(element)) : [argument];
+	const configs = entries.filter((entry) => entry?.type === nodeTypes.objectExpression);
+	if (configs.length !== entries.length) return { reason: "config is not an object literal" };
+	return {
+		...parsed,
+		configs,
+		kind
+	};
+}
+function findConfigEntry(configs, ref) {
+	return typeof ref === "string" ? configs.find((entry) => getConfigName(entry) === ref) : configs[ref ?? 0];
+}
+function getKey(entry) {
+	if (entry.type !== nodeTypes.property || entry.computed) return void 0;
+	if (entry.key.type === nodeTypes.identifier) return entry.key.name;
+	return entry.key.type === nodeTypes.literal && typeof entry.key.value === "string" ? entry.key.value : void 0;
+}
+/** The last one wins when the key repeats, as at runtime. */
+function findProperty(node, key) {
+	const index = node.properties.findLastIndex((entry) => getKey(entry) === key);
+	return index === -1 ? void 0 : {
+		member: node.properties[index],
+		index
+	};
+}
+function getValue(node, key) {
+	const member = findProperty(node, key)?.member;
+	return member?.type === nodeTypes.property ? member.value : member;
+}
+function getConfigName(config) {
+	const name = getValue(config, "name");
+	return name?.type === nodeTypes.literal && typeof name.value === "string" ? name.value : void 0;
+}
+function isOverridden(node, index) {
+	return node.properties.slice(index + 1).some((entry) => entry.type === nodeTypes.spreadElement);
+}
+/** `key: value`, not a method, getter, setter, or `{ key }` shorthand. */
+function isPlainProperty(member) {
+	return !member.method && !member.shorthand && member.kind === propertyKinds.init;
+}
+/** A literal's value, `undefined` for code. */
+function readLiteral(node) {
+	switch (node?.type) {
+		case nodeTypes.literal: return "regex" in node || "bigint" in node ? void 0 : node.value;
+		case nodeTypes.templateLiteral: return node.expressions.length ? void 0 : node.quasis[0]?.value.cooked ?? "";
+		case nodeTypes.unaryExpression: {
+			const value = readLiteral(node.argument);
+			if (typeof value !== "number") return void 0;
+			if (node.operator === unaryOperators.minus) return -value;
+			if (node.operator === unaryOperators.plus) return value;
+			return;
+		}
+		case nodeTypes.arrayExpression: {
+			const values = node.elements.map((element) => readLiteral(element));
+			return values.every((value) => value !== void 0) ? values : void 0;
+		}
+		case nodeTypes.objectExpression: {
+			const entries = {};
+			for (const entry of node.properties) {
+				if (entry.type !== nodeTypes.property) return void 0;
+				const key = getKey(entry);
+				const value = readLiteral(entry.value);
+				if (key === void 0 || !isSafeKey(key) || value === void 0) return void 0;
+				entries[key] = value;
+			}
+			return entries;
+		}
+	}
+}
+function getRequirePath(node) {
+	if (node?.type !== nodeTypes.callExpression || node.callee.type !== nodeTypes.identifier || node.callee.name !== identifiers.require) return void 0;
+	const [argument] = node.arguments;
+	return argument?.type === nodeTypes.literal && typeof argument.value === "string" ? argument.value : void 0;
+}
+/** `import { exported as local } from '...'`. A default or namespace import has no exported name, so its local name stands in. */
+function importBindings(statement) {
+	return statement.specifiers.map((specifier) => {
+		const imported = specifier.type === nodeTypes.importSpecifier ? specifier.imported : specifier.local;
+		const exported = imported.type === nodeTypes.identifier ? imported.name : imported.value;
+		return [specifier.local.name, {
+			from: statement.source.value,
+			exported
+		}];
+	});
+}
+/** `const { exported: local } = require('...')`. */
+function requireBindings(statement) {
+	return statement.declarations.flatMap((declarator) => {
+		const from = getRequirePath(declarator.init);
+		if (from === void 0 || declarator.id.type !== nodeTypes.objectPattern) return [];
+		return declarator.id.properties.flatMap((entry) => {
+			if (entry.type !== nodeTypes.property || entry.value.type !== nodeTypes.identifier) return [];
+			return [[entry.value.name, {
+				from,
+				exported: getKey(entry) ?? entry.value.name
+			}]];
+		});
+	});
+}
+function getImports(program) {
+	return new Map(program.body.flatMap((statement) => {
+		if (statement.type === nodeTypes.importDeclaration) return importBindings(statement);
+		if (statement.type === nodeTypes.variableDeclaration) return requireBindings(statement);
+		return [];
+	}));
+}
+function isImportStatement(node, kind) {
+	if (kind === moduleKinds.esm) return node.type === nodeTypes.importDeclaration;
+	return node.type === nodeTypes.variableDeclaration && node.declarations.some((declarator) => getRequirePath(declarator.init) !== void 0);
+}
+/** The quote of the first string literal in the file, so new code matches it. */
+function detectQuote(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const { type, raw } = node;
+	if (type === nodeTypes.literal && typeof raw === "string" && (raw[0] === quotes.single || raw[0] === quotes.double)) return raw[0];
+	for (const child of Object.values(node)) {
+		const quote = detectQuote(child);
+		if (quote) return quote;
+	}
+}
+/** The `adapter` value, or the elements of the `plugins` or `parsers` array. */
+function factoryNodes(config, kind) {
+	if (kind === extensionKinds.adapter) return [getValue(config, "adapter")];
+	const array = getValue(config, `${kind}s`);
+	return array?.type === nodeTypes.arrayExpression ? array.elements : [];
+}
+/** The factory calls of one kind whose callee the file imports. */
+function findCalls(program, config, kind = extensionKinds.plugin) {
+	const imports = getImports(program);
+	return factoryNodes(config, kind).flatMap((node) => {
+		if (node?.type !== nodeTypes.callExpression || node.callee.type !== nodeTypes.identifier) return [];
+		const imported = imports.get(node.callee.name);
+		return imported ? [{
+			importName: node.callee.name,
+			exportName: imported.exported,
+			packageName: imported.from,
+			call: node
+		}] : [];
+	});
+}
+/** Whether nothing but whitespace precedes `offset` on its line. */
+function startsLine(source, offset) {
+	return source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset).trim() === "";
+}
+/** The `disable-plugin` blocks in this config, read from marker comments since the call is no longer a node. */
+function findDisabled(source, comments, config) {
+	const lines = source.split("\n");
+	return comments.flatMap((comment) => {
+		const match = comment.type === commentTypes.line ? comment.value.trim().match(DISABLED_MARKER_PATTERN) : null;
+		if (!match || comment.start < config.start || comment.end > config.end || !startsLine(source, comment.start)) return [];
+		const line = getPosition(source, comment.start).line;
+		const end = line + Number(match[2]);
+		const code = lines.slice(line, end).map((text) => text.replace(/^(\s*)\/\/ ?/, "$1").replace(/^\s+$/, ""));
+		return [{
+			packageName: match[1],
+			line,
+			end,
+			code
+		}];
+	});
+}
+/** Literal members as `value` and code paths as `locked`, `undefined` for a computed key. */
+function readEditable(node, prefix = []) {
+	const value = {};
+	const locked = [];
+	for (const [index, entry] of node.properties.entries()) {
+		if (entry.type === nodeTypes.spreadElement) continue;
+		const key = getKey(entry);
+		if (key === void 0) return void 0;
+		if (findProperty(node, key)?.index !== index) continue;
+		const path = [...prefix, key];
+		if (!isSafeKey(key)) {
+			locked.push(path);
+			continue;
+		}
+		const member = isOverridden(node, index) ? void 0 : entry.value;
+		const literal = readLiteral(member);
+		if (literal !== void 0) {
+			value[key] = literal;
+			continue;
+		}
+		if (member?.type !== nodeTypes.objectExpression) {
+			locked.push(path);
+			continue;
+		}
+		const nested = readEditable(member, path);
+		if (!nested) return void 0;
+		value[key] = nested.value;
+		locked.push(...nested.locked);
+	}
+	return {
+		value,
+		locked
+	};
+}
+function readObjectOptions(options) {
+	const entries = {};
+	for (const [index, entry] of options.properties.entries()) {
+		const key = getKey(entry);
+		if (key === void 0 || !isSafeKey(key)) continue;
+		const member = entry.type === nodeTypes.property && !isOverridden(options, index) ? entry.value : void 0;
+		const value = readLiteral(member);
+		if (value !== void 0) {
+			entries[key] = {
+				literal: true,
+				value
+			};
+			continue;
+		}
+		entries[key] = {
+			literal: false,
+			...member?.type === nodeTypes.objectExpression ? readEditable(member) : void 0
+		};
+	}
+	return entries;
+}
+function readCallOptions(call) {
+	const options = call.arguments[0];
+	return options?.type === nodeTypes.objectExpression ? readObjectOptions(options) : {};
+}
+function readDisabledOptions(code) {
+	const call = parseExpression(code.join("\n").trim().replace(/,$/, ""));
+	return call?.type === nodeTypes.callExpression ? readCallOptions(call) : {};
+}
+function toPluginView({ importName, packageName, call }) {
+	return {
+		importName,
+		packageName,
+		options: readCallOptions(call)
+	};
+}
+/** Active and disabled plugins, in source order so a disabled plugin keeps its place. */
+function readPlugins({ source, parsed, config }) {
+	const importNames = new Map([...getImports(parsed.program)].map(([local, { from }]) => [from, local]));
+	const active = findCalls(parsed.program, config).map((call) => ({
+		line: getPosition(source, call.call.start).line,
+		plugin: toPluginView(call)
+	}));
+	const disabled = findDisabled(source, parsed.comments, config).map(({ packageName, line, code }) => ({
+		line,
+		plugin: {
+			importName: importNames.get(packageName) ?? toExportName(packageName),
+			packageName,
+			options: readDisabledOptions(code),
+			disabled: true
+		}
+	}));
+	return [...active, ...disabled].sort((a, b) => a.line - b.line).map(({ plugin }) => plugin);
+}
+function readConfigView({ source, parsed, config }) {
+	const [adapter] = findCalls(parsed.program, config, extensionKinds.adapter).map(toPluginView);
+	const parsers = findCalls(parsed.program, config, extensionKinds.parser).map(toPluginView);
+	const output = getOutput(config);
+	return {
+		name: getConfigName(config),
+		plugins: readPlugins({
+			source,
+			parsed,
+			config
+		}),
+		...adapter && { adapter },
+		...parsers.length ? { parsers } : {},
+		...!("reason" in output) && { output: pickOutput(readObjectOptions(output.object)) }
+	};
+}
+/** Which plugins the file declares and which options Studio may write. */
+function readConfig(source) {
+	const parsed = findConfigs(source);
+	if ("reason" in parsed) return {
+		managed: false,
+		reason: parsed.reason
+	};
+	return {
+		managed: true,
+		configs: parsed.configs.map((config) => readConfigView({
+			source,
+			parsed,
+			config
+		}))
+	};
+}
+/** The modules the file imports, empty when it cannot be parsed. */
+function readImports(source) {
+	const parsed = parseSource(source);
+	if ("reason" in parsed) return [];
+	return [...new Set([...getImports(parsed.program).values()].map(({ from }) => from))];
+}
+/** Follows `path` to its literal, or to the first missing key. Refuses a value set in code. */
+function findPath(options, path) {
+	let object = options;
+	for (const [depth, key] of path.entries()) {
+		const found = findProperty(object, key);
+		if (!found) return {
+			object,
+			missing: depth
+		};
+		if (isOverridden(object, found.index)) return { reason: `${path.slice(0, depth + 1).join(".")} can be overridden by a spread after it, so it is customized in code` };
+		const { member, index } = found;
+		if (depth === path.length - 1) return member.type === nodeTypes.property && readLiteral(member.value) !== void 0 ? {
+			object,
+			index,
+			value: member.value
+		} : { reason: `${path.join(".")} is customized in code` };
+		if (member.type !== nodeTypes.property || member.value.type !== nodeTypes.objectExpression) return { reason: `${key} is not an object, so ${path.join(".")} cannot be reached` };
+		object = member.value;
+	}
+	return { reason: "no option path given" };
+}
+function setAtPath({ source, options, path, value, quote }) {
+	const target = findPath(options, path);
+	if ("reason" in target) return target;
+	if ("missing" in target) {
+		const [key, ...rest] = path.slice(target.missing);
+		return { source: appendItem(source, target.object, `${printKey(key, quote)}: ${printValue(wrapPath(rest, value), quote)}`) };
+	}
+	return { source: replaceText(source, target.value.start, target.value.end, printValue(value, quote)) };
+}
+function removeAtPath({ source, options, path }) {
+	const target = findPath(options, path);
+	if ("reason" in target) return target;
+	if ("missing" in target) return { source };
+	return { source: removeItem(source, target.object, target.index) };
+}
+function setOption(source, call, path, value, quote) {
+	if (!isOptionValue(value)) return { reason: "the value is not a literal that can be written to a config file" };
+	const options = call.arguments[0];
+	if (!options) {
+		const closing = call.end - 1;
+		if (source[closing] !== ")") return { reason: "the factory call could not be located in the file" };
+		return { source: replaceText(source, closing, closing, printValue(wrapPath(path, value), quote)) };
+	}
+	if (options.type !== nodeTypes.objectExpression) return { reason: "the factory was not called with an object literal" };
+	return setAtPath({
+		source,
+		options,
+		path,
+		value,
+		quote
+	});
+}
+function removeOption(source, call, path) {
+	const options = call.arguments[0];
+	if (!options) return { source };
+	if (options.type !== nodeTypes.objectExpression) return { reason: "the factory was not called with an object literal" };
+	return removeAtPath({
+		source,
+		options,
+		path
+	});
+}
+function editOption({ source, parsed, config, edit, quote, extensions }) {
+	const kind = edit.kind ?? extensionKinds.plugin;
+	const calls = findCalls(parsed.program, config, kind).filter((entry) => entry.packageName === edit.plugin);
+	const exportName = extensions.get(edit.plugin)?.manifest.export ?? toExportName(edit.plugin);
+	const call = (calls.find((entry) => entry.exportName === exportName) ?? calls[0])?.call;
+	if (!call) {
+		if (kind === extensionKinds.adapter) return { reason: `${edit.plugin} is not the config's adapter` };
+		return { reason: kind === extensionKinds.plugin && findDisabled(source, parsed.comments, config).some((block) => block.packageName === edit.plugin) ? `${edit.plugin} is disabled, enable it first` : `${edit.plugin} is not in the ${kind}s array` };
+	}
+	if (edit.operation === ConfigEditOperation.SET_OPTION) return setOption(source, call, edit.path, edit.value, quote);
+	return removeOption(source, call, edit.path);
+}
+function setInput(source, config, input, quote) {
+	const value = printValue(input, quote);
+	const found = findProperty(config, "input");
+	if (!found) return { source: appendItem(source, config, `input: ${value}`) };
+	if (found.member.type !== nodeTypes.property || !isPlainProperty(found.member)) return { reason: "input is not a plain property" };
+	if (isOverridden(config, found.index)) return { reason: "a spread after input could override it" };
+	return { source: replaceText(source, found.member.value.start, found.member.value.end, value) };
+}
+function getOutput(config) {
+	const found = findProperty(config, "output");
+	if (found?.member.type !== nodeTypes.property || found.member.value.type !== nodeTypes.objectExpression) return { reason: "output is not an object literal" };
+	if (isOverridden(config, found.index)) return { reason: "a spread after output could override it" };
+	return { object: found.member.value };
+}
+function editOutput({ source, config, edit, quote }) {
+	const output = getOutput(config);
+	if ("reason" in output) return output;
+	if (edit.operation === ConfigEditOperation.REMOVE_OUTPUT) return removeAtPath({
+		source,
+		options: output.object,
+		path: edit.path
+	});
+	const [key, ...rest] = edit.path;
+	if (!isOptionValue(edit.value) || !isOutputValue({
+		key,
+		value: wrapPath(rest, edit.value)
+	})) return { reason: `the value is not one output.${key} takes` };
+	return setAtPath({
+		source,
+		options: output.object,
+		path: edit.path,
+		value: edit.value,
+		quote
+	});
+}
+/** Adds the import after the last one, matching its semicolon style. */
+function addImport({ source, parsed, importNames, moduleSpecifier, quote }) {
+	const lastImport = parsed.program.body.findLast((node) => isImportStatement(node, parsed.kind));
+	const afterLine = lastImport ? getPosition(source, lastImport.end).line : 0;
+	const lines = source.split("\n");
+	const semicolon = afterLine > 0 && lines[afterLine - 1]?.trimEnd().endsWith(";") ? ";" : "";
+	const specifier = `${quote}${moduleSpecifier}${quote}`;
+	const statement = parsed.kind === moduleKinds.esm ? `import { ${importNames.join(", ")} } from ${specifier}` : `const { ${importNames.join(", ")} } = require(${specifier})`;
+	lines.splice(afterLine, 0, `${statement}${semicolon}`);
+	if (afterLine === 0) lines.splice(1, 0, "");
+	return lines.join("\n");
+}
+/**
+* The parsers `defineConfig` applies when a config sets no `parsers`, by import name. Adding a parser
+* to such a config writes these too, or the new array would replace them.
+*/
+const DEFAULT_PARSERS = [
+	{
+		importName: "parserTs",
+		packageName: "@kubb/parser-ts"
+	},
+	{
+		importName: "parserTsx",
+		packageName: "@kubb/parser-ts"
+	},
+	{
+		importName: "parserMd",
+		packageName: "@kubb/parser-md"
+	}
+];
+/**
+* Adds a plugin to `plugins`, or with `kind: 'parser'` a parser to `parsers`. Replaying the same add
+* is a no-op, while an import name taken by another package is an error.
+*/
+function addPlugin({ source, parsed, config, edit, quote, extensions }) {
+	const kind = edit.kind ?? extensionKinds.plugin;
+	const isParser = kind === extensionKinds.parser;
+	if (!isAllowedPlugin({
+		packageName: edit.plugin,
+		extensions,
+		kind
+	})) return { reason: isParser ? `"${edit.plugin}" is not an installed Kubb parser` : `"${edit.plugin}" is not a @kubb/plugin-* package or an installed Kubb plugin` };
+	const importName = extensions.get(edit.plugin)?.manifest.export ?? toExportName(edit.plugin);
+	if (!IDENTIFIER_PATTERN.test(importName)) return { reason: `"${importName}" is not a valid import name` };
+	if (findCalls(parsed.program, config, kind).some((entry) => entry.packageName === edit.plugin && (!isParser || entry.exportName === importName))) return { source };
+	const options = edit.options ?? {};
+	if (!isOptionValue(options)) return { reason: "the options are not literals that can be written to a config file" };
+	const key = `${kind}s`;
+	const array = getValue(config, key);
+	if (array ? array.type !== nodeTypes.arrayExpression : !isParser) return { reason: `${key} is not an array literal` };
+	const defaults = isParser && !array ? DEFAULT_PARSERS.filter((parser) => parser.importName !== importName) : [];
+	const imports = getImports(parsed.program);
+	const missing = /* @__PURE__ */ new Map();
+	for (const item of [...defaults, {
+		importName,
+		packageName: edit.plugin
+	}]) {
+		const from = imports.get(item.importName)?.from;
+		if (from && from !== item.packageName) return { reason: `${item.importName} is already imported from ${from}` };
+		if (!from) missing.set(item.packageName, [...missing.get(item.packageName) ?? [], item.importName]);
+	}
+	const call = `${importName}(${Object.keys(options).length ? printValue(options, quote) : ""})`;
+	const next = array?.type === nodeTypes.arrayExpression ? appendItem(source, array, call) : appendItem(source, config, `parsers: [${[...defaults.map((parser) => `${parser.importName}()`), call].join(", ")}]`);
+	return { source: [...missing].reduceRight((current, [moduleSpecifier, importNames]) => addImport({
+		source: current,
+		parsed,
+		importNames,
+		moduleSpecifier,
+		quote
+	}), next) };
+}
+/** One item per line, so a call can be commented out alone. Skipped when comments sit between items. */
+function splitPlugins(source, config) {
+	const array = getValue(config, "plugins");
+	if (array?.type !== nodeTypes.arrayExpression) return void 0;
+	const items = array.elements.flatMap((element) => element ? [element] : []);
+	const { start, end } = array;
+	const gaps = [source.slice(start + 1, items[0]?.start ?? end - 1), ...items.map((item, index) => source.slice(item.end, items[index + 1]?.start ?? end - 1))];
+	if (!items.length || gaps.some((gap) => !/^[\s,]*$/.test(gap))) return void 0;
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	const indent = source.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
+	return replaceText(source, start, end, `[\n${items.map((item) => `${indent}  ${source.slice(item.start, item.end)},`).join("\n")}\n${indent}]`);
+}
+function disablePlugin(source, program, config, plugin) {
+	const call = findCalls(program, config).find((entry) => entry.packageName === plugin)?.call;
+	if (!call) return { reason: `${plugin} is not in the plugins array` };
+	const start = getPosition(source, call.start);
+	const end = getPosition(source, call.end);
+	const lines = source.split("\n");
+	const from = start.line - 1;
+	const to = end.line - 1;
+	const firstLine = lines[from] ?? "";
+	if (firstLine.slice(0, start.column).trim() || !/^,?\s*$/.test((lines[to] ?? "").slice(end.column))) return { reason: `${plugin} shares a line with other code, so it cannot be commented out safely` };
+	const indent = firstLine.match(/^\s*/)?.[0] ?? "";
+	const commented = lines.slice(from, to + 1).map((line) => line.trim() ? `${indent}// ${line.slice(indent.length)}` : `${indent}//`);
+	lines.splice(from, commented.length, `${indent}// kubb:disabled ${plugin} ${commented.length}`, ...commented);
+	return { source: lines.join("\n") };
+}
+/** Disables the plugin, first putting a one-line `plugins: [a(), b()]` (what `add-plugin` writes) on separate lines. */
+function disablePluginInConfig({ source, parsed, config, edit }) {
+	const result = disablePlugin(source, parsed.program, config, edit.plugin);
+	if (!("reason" in result) || !result.reason.includes("shares a line")) return result;
+	const split = splitPlugins(source, config);
+	if (split === void 0) return result;
+	const reparsed = findConfigs(split);
+	const reparsedConfig = "reason" in reparsed ? void 0 : findConfigEntry(reparsed.configs, edit.config);
+	if ("reason" in reparsed || !reparsedConfig) return result;
+	return disablePlugin(split, reparsed.program, reparsedConfig, edit.plugin);
+}
+function enablePlugin(source, comments, config, plugin) {
+	const block = findDisabled(source, comments, config).find((entry) => entry.packageName === plugin);
+	if (!block) return { reason: `${plugin} is not disabled` };
+	const lines = source.split("\n");
+	lines.splice(block.line - 1, block.end - block.line + 1, ...block.code);
+	return { source: lines.join("\n") };
+}
+/** Drops the import statements of `packageName` once nothing else in the file uses their names. */
+function removeUnusedImports(source, packageName) {
+	const parsed = parseSource(source);
+	if ("reason" in parsed) return source;
+	return parsed.program.body.reduceRight((current, statement) => {
+		const bindings = statement.type === nodeTypes.importDeclaration ? importBindings(statement) : statement.type === nodeTypes.variableDeclaration ? requireBindings(statement) : [];
+		if (!bindings.length || bindings.some(([, { from }]) => from !== packageName)) return current;
+		const rest = replaceText(current, statement.start, statement.end);
+		if (bindings.some(([local]) => new RegExp(`(?<![\\w$])${local.replaceAll("$", "\\$")}(?![\\w$])`).test(rest))) return current;
+		const lineStart = current.lastIndexOf("\n", statement.start - 1) + 1;
+		const lineEnd = current.indexOf("\n", statement.end);
+		const after = lineEnd === -1 ? current.length : lineEnd + 1;
+		return replaceText(current, lineStart, lineStart === 0 && current[after] === "\n" ? after + 1 : after);
+	}, source);
+}
+/**
+* Removes every call of a plugin or parser package, and the block `disable-plugin` commented out,
+* then its unused imports. Removing what the config does not hold is a no-op. Refuses to empty
+* `parsers`, since a config with no parser cannot print files.
+*/
+function removeExtension(source, edit) {
+	const kind = edit.kind ?? extensionKinds.plugin;
+	let current = source;
+	for (;;) {
+		const parsed = findConfigs(current);
+		if ("reason" in parsed) return parsed;
+		const config = findConfigEntry(parsed.configs, edit.config);
+		if (!config) return { reason: `no config entry found for ${JSON.stringify(edit.config)}` };
+		const array = getValue(config, `${kind}s`);
+		const calls = findCalls(parsed.program, config, kind).filter((entry) => entry.packageName === edit.plugin);
+		const block = findDisabled(current, parsed.comments, config).find((entry) => entry.packageName === edit.plugin);
+		if (calls[0] && array?.type === nodeTypes.arrayExpression) {
+			const elements = array.elements.filter((element) => element !== null);
+			if (kind === extensionKinds.parser && elements.length === calls.length) return { reason: `${edit.plugin} is the last parser in the parsers array` };
+			current = removeItem(current, array, elements.indexOf(calls[0].call));
+			continue;
+		}
+		if (block && kind === extensionKinds.plugin) {
+			const lines = current.split("\n");
+			lines.splice(block.line - 1, block.end - block.line + 1);
+			current = lines.join("\n");
+			continue;
+		}
+		return { source: current === source ? source : removeUnusedImports(current, edit.plugin) };
+	}
+}
+/** Every edit re-parses the file, since the previous one rewrote it. */
+function applyEdit({ source, edit, extensions }) {
+	const parsed = findConfigs(source);
+	if ("reason" in parsed) return parsed;
+	const config = findConfigEntry(parsed.configs, edit.config);
+	if (!config) return { reason: `no config entry found for ${JSON.stringify(edit.config)}` };
+	const quote = detectQuote(parsed.program) ?? quotes.single;
+	switch (edit.operation) {
+		case ConfigEditOperation.SET_INPUT: return setInput(source, config, edit.input, quote);
+		case ConfigEditOperation.SET_OUTPUT:
+		case ConfigEditOperation.REMOVE_OUTPUT: return editOutput({
+			source,
+			config,
+			edit,
+			quote
+		});
+		case ConfigEditOperation.DISABLE_PLUGIN: return disablePluginInConfig({
+			source,
+			parsed,
+			config,
+			edit
+		});
+		case ConfigEditOperation.ENABLE_PLUGIN: return enablePlugin(source, parsed.comments, config, edit.plugin);
+		case ConfigEditOperation.ADD_PLUGIN: return addPlugin({
+			source,
+			parsed,
+			config,
+			edit,
+			quote,
+			extensions
+		});
+		case ConfigEditOperation.REMOVE_EXTENSION: return removeExtension(source, edit);
+		case ConfigEditOperation.SET_OPTION:
+		case ConfigEditOperation.REMOVE_OPTION: return editOption({
+			source,
+			parsed,
+			config,
+			edit,
+			quote,
+			extensions
+		});
+	}
+}
+/** Applies edits in place, touching only the text each targets. A refused edit is reported and the rest still run. */
+function editConfig({ source, edits, extensions = /* @__PURE__ */ new Map() }) {
+	let current = source;
+	const outcomes = edits.map((edit) => {
+		const invalid = validateEdit(edit);
+		if (invalid) return {
+			edit,
+			applied: false,
+			reason: invalid
+		};
+		try {
+			const result = applyEdit({
+				source: current,
+				edit,
+				extensions
+			});
+			if ("reason" in result) return {
+				edit,
+				applied: false,
+				reason: result.reason
+			};
+			current = result.source;
+			return {
+				edit,
+				applied: true
+			};
+		} catch (error) {
+			return {
+				edit,
+				applied: false,
+				reason: getErrorMessage(error)
+			};
+		}
+	});
+	return {
+		source: current,
+		outcomes,
+		changed: current !== source
+	};
+}
+/** Applies `edits` to `filePath`, writing only when something changed. */
+async function editConfigFile({ filePath, edits, extensions }) {
+	const result = editConfig({
+		source: await read(filePath),
+		edits,
+		extensions
+	});
+	if (result.changed) await writeRaw(filePath, result.source);
+	return result;
+}
+export { ConfigEditOperation as a, readImports as i, editConfigFile as n, extensionKinds as o, readConfig as r, editConfig as t };
+
+//# sourceMappingURL=configFile-C0DIXNMD.js.map