kotlin-format 0.0.0-stage → 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,738 @@
+#!/usr/bin/env node
+import { exists, loadConfig, projectRoot, resolveOptions, validateConfig } from "./config.mjs";
+import { glob, lstat, readFile, readdir, writeFile } from "node:fs/promises";
+import { extname, join, relative, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+// \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+// js/cli.ts
+var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function makeArray(subject) {
+		return Array.isArray(subject) ? subject : [subject];
+	}
+	const UNDEFINED = void 0;
+	const EMPTY = "";
+	const SPACE = " ";
+	const ESCAPE = "\\";
+	const REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+	const BOM = "";
+	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+	const REGEX_ANCHORED_GLOBSTAR = /^\/\*{2,}$/;
+	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+	const REGEX_SPLITALL_CRLF = /\r?\n/g;
+	const DOUBLE_SLASH = "//";
+	const SLASH_CODE = 47;
+	const DOT_CODE = 46;
+	const SLASH = "/";
+	let TMP_KEY_IGNORE = "node-ignore";
+	/* istanbul ignore else */
+	if (typeof Symbol !== "undefined") TMP_KEY_IGNORE = Symbol.for("node-ignore");
+	const KEY_IGNORE = TMP_KEY_IGNORE;
+	const define = (object, key, value) => {
+		Object.defineProperty(object, key, { value });
+		return value;
+	};
+	const RETURN_FALSE = () => false;
+	const POSIX_CLASSES = {
+		alnum: "0-9A-Za-z",
+		alpha: "A-Za-z",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1f\\x7f",
+		digit: "0-9",
+		graph: "!-.0-~",
+		lower: "a-z",
+		print: " -.0-~",
+		punct: "!-.:-@\\[-`{-~",
+		space: " \\t\\n\\r",
+		upper: "A-Z",
+		xdigit: "0-9A-Fa-f"
+	};
+	const CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+	const escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+	const NON_SLASH = "(?!\\/)";
+	const classSource = (negated, body) => {
+		if (negated) return `[^\\/${body}]`;
+		const source = `[${body}]`;
+		return new RegExp(source).test("/") ? NON_SLASH + source : source;
+	};
+	const scanBracket = (pattern, start) => {
+		const { length } = pattern;
+		let index = start + 1;
+		let negated = EMPTY;
+		const lead = pattern[index];
+		if (lead === "!" || lead === "^") {
+			negated = "^";
+			index++;
+		}
+		let body = EMPTY;
+		let prev = EMPTY;
+		for (;;) {
+			const char = pattern[index];
+			if (char === UNDEFINED) return null;
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED) return null;
+				body += escapeMember(escaped);
+				prev = escaped;
+				index++;
+			} else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+				index++;
+				let to = pattern[index];
+				if (to === ESCAPE) to = pattern[index += 1];
+				if (prev <= to) body += `-${escapeMember(to)}`;
+				prev = EMPTY;
+			} else if (char === "[" && pattern[index + 1] === ":") {
+				const nameStart = index + 2;
+				let end = nameStart;
+				while (end < length && pattern[end] !== "]") end++;
+				if (end === length) return null;
+				if (end > nameStart && pattern[end - 1] === ":") {
+					const name = pattern.slice(nameStart, end - 1);
+					if (!Object.prototype.hasOwnProperty.call(POSIX_CLASSES, name)) return null;
+					body += POSIX_CLASSES[name];
+					prev = EMPTY;
+					index = end;
+				} else {
+					body += escapeMember("[");
+					prev = "[";
+					index = nameStart - 2;
+				}
+			} else {
+				body += escapeMember(char);
+				prev = char;
+			}
+			index++;
+			if (pattern[index] === "]") return {
+				end: index,
+				source: classSource(negated, body)
+			};
+		}
+	};
+	const NEVER_MATCH = "[]";
+	const PLACEHOLDER = "\0";
+	const REGEX_RESTORE_PLACEHOLDER = new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g");
+	const TRAILING_WILDCARD = "";
+	const TRAILING_DOUBLESTAR = "";
+	const isReserved = (char) => char === PLACEHOLDER || char === TRAILING_WILDCARD || char === TRAILING_DOUBLESTAR;
+	const extractBrackets = (pattern) => {
+		const sources = [];
+		const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
+		const { length } = pattern;
+		let out = EMPTY;
+		let index = 0;
+		while (index < length) {
+			const char = pattern[index];
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) out += hold(NEVER_MATCH);
+				else if (escaped === "*" || escaped === "[" || escaped === SPACE) out += pattern.slice(index, index + 2);
+				else out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : isReserved(escaped) ? `[${escaped}]` : escaped);
+				index += 2;
+			} else if (isReserved(char)) {
+				out += hold(`[${char}]`);
+				index++;
+			} else if (char === "[") {
+				const scanned = scanBracket(pattern, index);
+				if (scanned === null) {
+					out += hold(NEVER_MATCH);
+					index = length;
+				} else {
+					out += hold(scanned.source);
+					index = scanned.end + 1;
+				}
+			} else {
+				out += char;
+				index++;
+			}
+		}
+		return {
+			source: out,
+			sources
+		};
+	};
+	const DIRECT = null;
+	const REGEX_INNER_SLASH = /\/(?!$)/;
+	const REPLACERS = [
+		[
+			/(\\+)( ?)/g,
+			(_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+			"\\ "
+		],
+		[
+			/(^|\/)\*{3,}(?=\/|$)/g,
+			(_, start) => `${start}**`,
+			"*"
+		],
+		[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
+		[
+			/(?!\\)\?/g,
+			() => "[^/]",
+			"?"
+		],
+		[
+			/^\//,
+			() => "^",
+			SLASH
+		],
+		[
+			/\//g,
+			() => "\\/",
+			SLASH
+		],
+		[
+			/^\^*(?:\\\*\\\*\\\/)+/,
+			() => "^(?:.*\\/)?",
+			"*"
+		],
+		[DIRECT, (source, pattern) => {
+			if (!source || source[0] === "^") return source;
+			return (!REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^") + source;
+		}],
+		[
+			/\\\/\\\*\\\*(?=\\\/|$)/g,
+			(_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+			"*"
+		],
+		[
+			/(^|[^\\]+)(\\\*)+(?=.+)/g,
+			(_, p1, p2) => {
+				return p1 + p2.replace(/\\\*/g, "[^\\/]*");
+			},
+			"*"
+		],
+		[
+			/(^|[^\\])((?:\\\\)*)\\\*$/,
+			(match, p1, p2) => p2 === EMPTY ? p1 + TRAILING_WILDCARD : match,
+			"*"
+		],
+		[
+			/\\\\\\(?=[$.|*+(){^])/g,
+			() => ESCAPE,
+			"\\\\"
+		],
+		[
+			/\\\\/g,
+			() => ESCAPE,
+			"\\\\"
+		],
+		[
+			/\\\[([^\]/]*?)($|\])/g,
+			(match, range, close) => `\\[${range}${close}`,
+			"["
+		],
+		[DIRECT, (source) => {
+			const last = source[source.length - 1];
+			if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) return source;
+			return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+		}]
+	];
+	const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+	const MODE_IGNORE = "regex";
+	const MODE_CHECK_IGNORE = "checkRegex";
+	const replaceTrailingWildcard = (_, p1) => {
+		return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
+	};
+	const REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+	const replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
+	const WILDCARD = "[^\\/]*";
+	const separatorAfter = (run, at) => {
+		let separator = EMPTY;
+		for (let index = at + 1; index < run.length && !run[index].wildcard; index++) separator += run[index].single;
+		return separator;
+	};
+	const pinWildcards = (source) => {
+		if (source.indexOf(WILDCARD) < 0) return source;
+		const tokens = [];
+		const { length } = source;
+		let index = 0;
+		while (index < length) {
+			const char = source[index];
+			if (source.startsWith(WILDCARD, index)) {
+				tokens.push({ wildcard: true });
+				index += 6;
+			} else if (char === "[") {
+				let end = index + 1;
+				if (source[end] === "^") end++;
+				if (source[end] === "]") end++;
+				while (end < length && source[end] !== "]") end += source[end] === ESCAPE ? 2 : 1;
+				end++;
+				tokens.push({ single: source.slice(index, end) });
+				index = end;
+			} else if (char === ESCAPE) {
+				tokens.push({ single: source.slice(index, index + 2) });
+				index += 2;
+			} else if (char === "(") {
+				let depth = 0;
+				let end = index;
+				do {
+					if (source[end] === ESCAPE) end++;
+					else if (source[end] === "(") depth++;
+					else if (source[end] === ")") depth--;
+					end++;
+				} while (end < length && depth > 0);
+				if ("*+?".indexOf(source[end]) >= 0) end++;
+				tokens.push({ boundary: source.slice(index, end) });
+				index = end;
+			} else if (char === "^" || char === "$") {
+				tokens.push({ boundary: char });
+				index++;
+			} else {
+				tokens.push({ single: char });
+				index++;
+			}
+		}
+		let out = EMPTY;
+		let run = [];
+		const flush = () => {
+			let lastWildcard;
+			run.forEach((token, at) => {
+				if (token.wildcard) lastWildcard = at;
+			});
+			run.forEach((token, at) => {
+				if (!token.wildcard) {
+					out += token.single;
+					return;
+				}
+				out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+			});
+			run = [];
+		};
+		tokens.forEach((token) => {
+			if (token.boundary === void 0) {
+				run.push(token);
+				return;
+			}
+			flush();
+			out += token.boundary;
+		});
+		flush();
+		return out;
+	};
+	const makeRegexPrefix = (pattern) => {
+		if (REGEX_ANCHORED_GLOBSTAR.test(pattern)) pattern = "**";
+		const { source, sources } = extractBrackets(pattern);
+		const replaced = REPLACERS.reduce((prev, [matcher, replacer, required]) => {
+			if (matcher === DIRECT) return replacer(prev, pattern);
+			if (required !== UNDEFINED && prev.indexOf(required) < 0) return prev;
+			return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+		}, source);
+		return sources.length ? replaced.replace(REGEX_RESTORE_PLACEHOLDER, (match, index) => sources[index]) : replaced;
+	};
+	const checkSourceOf = (body, prefix) => {
+		if (body[body.length - 1] === SLASH) prefix = makeRegexPrefix(body.slice(0, -1));
+		const head = prefix.slice(0, -1);
+		const last = prefix[prefix.length - 1];
+		return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+	};
+	const matchesBasename = (body) => {
+		const index = body.indexOf(SLASH);
+		return index < 0 || index === body.length - 1;
+	};
+	const basenameOf = (path) => {
+		const end = path.length - 1;
+		const index = path.lastIndexOf(SLASH, path[end] === SLASH ? end - 1 : end);
+		return index < 0 ? path : path.slice(index + 1);
+	};
+	const parentOf = (path) => {
+		if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
+			const slices = path.split(SLASH).filter(Boolean);
+			slices.pop();
+			return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+		}
+		const end = path.length - 1;
+		const cut = path.lastIndexOf(SLASH, path.charCodeAt(end) === SLASH_CODE ? end - 1 : end);
+		return cut < 0 ? EMPTY : path.slice(0, cut + 1);
+	};
+	const isString = (subject) => typeof subject === "string";
+	const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern);
+	const splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+	var IgnoreRule = class {
+		constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+			this.pattern = pattern;
+			this.mark = mark;
+			this.negative = negative;
+			define(this, "body", body);
+			define(this, "ignoreCase", ignoreCase);
+			define(this, "regexPrefix", prefix);
+		}
+		get _basenameOnly() {
+			return define(this, "_basenameOnly", matchesBasename(this.body));
+		}
+		get regex() {
+			const key = "_regex";
+			if (this[key]) return this[key];
+			return this._make(MODE_IGNORE, key);
+		}
+		get checkRegex() {
+			const key = "_checkRegex";
+			if (this[key]) return this[key];
+			return this._make(MODE_CHECK_IGNORE, key);
+		}
+		_make(mode, key) {
+			const str = pinWildcards(mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix));
+			const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+			return define(this, key, regex);
+		}
+	};
+	const isLineEnd = (char) => char === "\r" || char === "\n";
+	const trimEnd = (body) => {
+		let end = body.length;
+		while (end && isLineEnd(body[end - 1])) end--;
+		const lineEnd = end;
+		while (end && body[end - 1] === SPACE) end--;
+		if (end === lineEnd) return body.slice(0, end);
+		let backslashes = 0;
+		while (backslashes < end && body[end - backslashes - 1] === ESCAPE) backslashes++;
+		return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+	};
+	const createRule = ({ pattern, mark }, ignoreCase) => {
+		let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+		if (body[0] === "#") return;
+		let negative = false;
+		if (body[0] === "!") {
+			negative = true;
+			body = body.slice(1);
+		}
+		const last = body[body.length - 1];
+		if (last === SPACE || last === "\r" || last === "\n") body = trimEnd(body);
+		if (!body) return;
+		body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+		const regexPrefix = makeRegexPrefix(body);
+		return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+	};
+	var RuleManager = class {
+		constructor(ignoreCase) {
+			this._ignoreCase = ignoreCase;
+			this._rules = [];
+			this._basenameCount = 0;
+		}
+		_add(pattern) {
+			if (pattern && pattern[KEY_IGNORE]) {
+				this._rules = this._rules.concat(pattern._rules._rules);
+				this._basenameCount += pattern._rules._basenameCount;
+				this._added = true;
+				return;
+			}
+			if (isString(pattern)) pattern = { pattern };
+			const rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+			if (rule) {
+				this._added = true;
+				this._rules.push(rule);
+				if (matchesBasename(rule.body)) this._basenameCount++;
+			}
+		}
+		add(pattern) {
+			this._added = false;
+			makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+			if (this._added) this._literalRules = UNDEFINED;
+			return this._added;
+		}
+		testLiteral(path) {
+			const rules = this._literalRules || (this._literalRules = this._rules.filter(({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"));
+			let ignored = false;
+			let unignored = false;
+			let matchedRule;
+			for (let index = rules.length - 1; index >= 0; index--) {
+				const rule = rules[index];
+				if (rule.checkRegex.test(path)) {
+					ignored = !rule.negative;
+					unignored = rule.negative;
+					matchedRule = rule.negative ? UNDEFINED : rule;
+					break;
+				}
+			}
+			const ret = {
+				ignored,
+				unignored
+			};
+			if (matchedRule) ret.rule = matchedRule;
+			return ret;
+		}
+		test(path, mode) {
+			const rules = this._rules;
+			const { length } = rules;
+			const shortcut = this._basenameCount * 2 >= length;
+			const basename = shortcut ? basenameOf(path) : path;
+			for (let index = length - 1; index >= 0; index--) {
+				const rule = rules[index];
+				if (rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
+					const { negative } = rule;
+					const ret = {
+						ignored: !negative,
+						unignored: negative
+					};
+					if (!negative) ret.rule = rule;
+					return ret;
+				}
+			}
+			return {
+				ignored: false,
+				unignored: false
+			};
+		}
+	};
+	const throwError = (message, Ctor) => {
+		throw new Ctor(message);
+	};
+	const checkPath = (path, originalPath, doThrow) => {
+		if (!isString(path)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+		if (!path) return doThrow(`path must not be empty`, TypeError);
+		if (checkPath.isNotRelative(path)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
+		return true;
+	};
+	const isNotRelative = (path) => {
+		const first = path.charCodeAt(0);
+		if (first === SLASH_CODE) return true;
+		if (first !== DOT_CODE) return false;
+		if (path.length === 1) return true;
+		const second = path.charCodeAt(1);
+		if (second === SLASH_CODE) return true;
+		if (second !== DOT_CODE) return false;
+		return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+	};
+	checkPath.isNotRelative = isNotRelative;
+	/* istanbul ignore next */
+	checkPath.convert = (p) => p;
+	var Ignore = class {
+		constructor({ ignorecase = true, ignoreCase = ignorecase, allowRelativePaths = false } = {}) {
+			define(this, KEY_IGNORE, true);
+			this._rules = new RuleManager(ignoreCase);
+			this._strictPathCheck = !allowRelativePaths;
+			this._initCache();
+		}
+		_initCache() {
+			this._ignoreCache = Object.create(null);
+			this._testCache = Object.create(null);
+		}
+		add(pattern) {
+			if (this._rules.add(pattern)) this._initCache();
+			return this;
+		}
+		addPattern(pattern) {
+			return this.add(pattern);
+		}
+		_test(originalPath, cache) {
+			const path = originalPath && checkPath.convert(originalPath);
+			checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+			return this._t(path, cache);
+		}
+		checkIgnore(path) {
+			if (path.charCodeAt(path.length - 1) !== SLASH_CODE) return this.test(path);
+			const dir = this._t(path, this._testCache);
+			if (dir.ignored) return dir;
+			const literal = this._rules.testLiteral(path);
+			return literal.ignored || literal.unignored ? literal : dir;
+		}
+		_t(path, cache) {
+			if (path in cache) return cache[path];
+			const parentPath = parentOf(path);
+			const parent = parentPath ? this._t(parentPath, cache) : UNDEFINED;
+			return cache[path] = parent && parent.ignored ? parent : this._rules.test(path, MODE_IGNORE);
+		}
+		ignores(path) {
+			return this._test(path, this._ignoreCache).ignored;
+		}
+		createFilter() {
+			return (path) => !this.ignores(path);
+		}
+		filter(paths) {
+			return makeArray(paths).filter(this.createFilter());
+		}
+		test(path) {
+			return this._test(path, this._testCache);
+		}
+	};
+	const factory = (options) => new Ignore(options);
+	const isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+	/* istanbul ignore next */
+	const setupWindows = () => {
+		const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+		checkPath.convert = makePosix;
+		const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+		checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+	};
+	/* istanbul ignore next */
+	if (typeof process !== "undefined" && process.platform === "win32") setupWindows();
+	module.exports = factory;
+	factory.default = factory;
+	module.exports.isPathValid = isPathValid;
+	define(module.exports, Symbol.for("setupWindows"), setupWindows);
+})))(), 1);
+const help = `Usage: kotlin-format [files/directories/globs...] [options]
+
+  --write                       Format files in place
+  --check                       Report files that need formatting (exit 1)
+  --stdin-filepath <file.kt>     Format stdin; use this path for config and .kts
+  --config <path>               Use an explicit JSON/JS/MJS/TS config
+  --style <KOTLINLANG|GOOGLE|META>
+  --max-width <1..999>
+  --remove-unused-imports / --no-remove-unused-imports
+  --preserve-lambda-breaks / --no-preserve-lambda-breaks
+  --help, -h                    Show help
+  --version, -v                 Show version
+
+Without --write/--check, a single file (or stdin) is formatted to stdout.
+With --write/--check and no paths, scan the current directory.
+Directories scan .kt/.kts files and respect .gitignore; symlinks are skipped.
+Exit codes: 0 success, 1 formatting required, 2 invalid input/config or failure.
+`;
+async function main() {
+	const { values, positionals } = parseArgs({
+		allowPositionals: true,
+		allowNegative: true,
+		options: {
+			write: { type: "boolean" },
+			check: { type: "boolean" },
+			"stdin-filepath": { type: "string" },
+			config: { type: "string" },
+			style: { type: "string" },
+			"max-width": { type: "string" },
+			"remove-unused-imports": { type: "boolean" },
+			"preserve-lambda-breaks": { type: "boolean" },
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			version: {
+				type: "boolean",
+				short: "v"
+			}
+		}
+	});
+	if (values.help) {
+		process.stdout.write(help);
+		return;
+	}
+	if (values.version) {
+		const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+		process.stdout.write(`${pkg.version}\n`);
+		return;
+	}
+	if (values.write && values.check) throw new Error("--write and --check cannot be combined");
+	const overrides = {};
+	for (const [flag, key] of [
+		["style", "style"],
+		["max-width", "maxWidth"],
+		["remove-unused-imports", "removeUnusedImports"],
+		["preserve-lambda-breaks", "preserveLambdaBreaks"]
+	]) if (values[flag] !== void 0) overrides[key] = flag === "max-width" ? Number(values[flag]) : values[flag];
+	const cliConfig = validateConfig(overrides, "arguments");
+	const stdin = values["stdin-filepath"] !== void 0 || positionals.includes("-") || !positionals.length && !values.write && !values.check;
+	if (stdin && (positionals.some((p) => p !== "-") || positionals.length > 1 || values.write)) throw new Error("stdin cannot be combined with file paths or --write");
+	if (stdin && process.stdin.isTTY) throw new Error("Provide a file path or pipe source to stdin");
+	const { formatWithOptions } = await import("./kotlin-format.mjs");
+	async function format(source, file) {
+		const config = {
+			...await loadConfig(file, { configPath: values.config }),
+			...cliConfig
+		};
+		const o = resolveOptions(config);
+		return formatWithOptions(source, o.maxWidth, o.blockIndent, o.continuationIndent, o.trailingCommas, o.removeUnusedImports, o.preserveLambdaBreaks, file.endsWith(".kts"));
+	}
+	if (stdin) {
+		const file = resolve(values["stdin-filepath"] ?? "stdin.kt");
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+		const source = Buffer.concat(chunks).toString("utf8");
+		const result = await format(source, file);
+		if (values.check) {
+			if (source !== result) {
+				process.stdout.write(`${file}\n`);
+				process.exitCode = 1;
+			}
+		} else process.stdout.write(result);
+		return;
+	}
+	const files = /* @__PURE__ */ new Set();
+	const ignoreCache = /* @__PURE__ */ new Map();
+	async function ignored(path, directory) {
+		const root = await projectRoot(path);
+		const parts = relative(root, path).split(sep);
+		let current = root;
+		const inherited = [];
+		for (let i = 0; i < parts.length; i++) {
+			if ([".git", "node_modules"].includes(parts[i])) return true;
+			let rules = ignoreCache.get(current);
+			if (!rules) {
+				rules = (0, import_ignore.default)();
+				const config = join(current, ".gitignore");
+				if (await exists(config)) rules.add(await readFile(config, "utf8"));
+				ignoreCache.set(current, rules);
+			}
+			inherited.push({
+				base: current,
+				rules
+			});
+			current = join(current, parts[i]);
+			let excluded = false;
+			for (const entry of inherited) {
+				const result = entry.rules.test(relative(entry.base, current).split(sep).join("/") + (i < parts.length - 1 || directory ? "/" : ""));
+				if (result.ignored) excluded = true;
+				else if (result.unignored) excluded = false;
+			}
+			if (excluded) return true;
+		}
+		return false;
+	}
+	async function visit(path) {
+		const info = await lstat(path);
+		if (info.isSymbolicLink() || await ignored(path, info.isDirectory())) return;
+		if (info.isDirectory()) for (const name of (await readdir(path)).sort()) await visit(join(path, name));
+		else if (info.isFile() && [".kt", ".kts"].includes(extname(path))) files.add(path);
+	}
+	for (const input of positionals.length ? positionals : ["."]) if (await exists(resolve(input))) await visit(resolve(input));
+	else {
+		let matched = false;
+		for await (const path of glob(input)) {
+			matched = true;
+			await visit(resolve(path));
+		}
+		if (!matched) throw new Error(`No files match: ${input}`);
+	}
+	if (!files.size) throw new Error("No Kotlin files found");
+	if (!values.write && !values.check && files.size !== 1) throw new Error("Use --write or --check for multiple files");
+	for (const file of [...files].sort()) try {
+		const source = await readFile(file, "utf8");
+		const result = await format(source, file);
+		if (values.write) {
+			if (source !== result) {
+				await writeFile(file, result);
+				process.stdout.write(`${file}\n`);
+			}
+		} else if (values.check) {
+			if (source !== result) {
+				process.stdout.write(`${file}\n`);
+				process.exitCode ||= 1;
+			}
+		} else process.stdout.write(result);
+	} catch (error) {
+		process.stderr.write(`${file}: ${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 2;
+	}
+}
+main().catch((error) => {
+	process.stderr.write(`kotlin-format: ${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = 2;
+});
+export {};