resultar-check 1.0.0

package/dist/lint-D-D2dmLi.cjs

@@ -0,0 +1,1030 @@
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+//#region src/result-usage-core.ts
+const resultTypeNames = new Set([
+	"DisposableResult",
+	"DisposableResultAsync",
+	"ErrResult",
+	"OkResult",
+	"Result",
+	"ResultAsync",
+	"StrictResult",
+	"StrictResultAsync"
+]);
+const consumerMethods = new Set([
+	"_unsafeUnwrap",
+	"_unsafeUnwrapErr",
+	"isErr",
+	"isOk",
+	"match",
+	"matchTags",
+	"matchTagsPartial",
+	"unwrapOr",
+	"unwrapOrThrow"
+]);
+const consumerProperties = new Set(["error", "value"]);
+const getUnionOrIntersectionTypes$1 = (tsApi, type) => (type.flags & (tsApi.TypeFlags.Union | tsApi.TypeFlags.Intersection)) === 0 ? void 0 : type.types ?? [];
+const getSymbolName = (symbol) => {
+	if (symbol === void 0) return;
+	if (typeof symbol.getName === "function") return symbol.getName();
+	const { escapedName } = symbol;
+	return typeof escapedName === "string" ? escapedName : void 0;
+};
+const getTypeSymbolName = (type) => {
+	if (typeof type.getSymbol === "function") return getSymbolName(type.getSymbol());
+	return getSymbolName(type.symbol);
+};
+const getTokenPosOfNode$1 = (tsApi, node, sourceFile) => {
+	const getTokenPos = tsApi.getTokenPosOfNode;
+	return getTokenPos === void 0 ? node.pos : getTokenPos(node, sourceFile);
+};
+const getNodeStart$1 = (tsApi, node, sourceFile) => typeof node.getStart === "function" ? node.getStart(sourceFile) : getTokenPosOfNode$1(tsApi, node, sourceFile);
+const getIdentifierText$1 = (identifier) => {
+	if (typeof identifier.text === "string") return identifier.text;
+	return identifier.escapedText === void 0 ? "" : String(identifier.escapedText);
+};
+const getNodeWidth$1 = (tsApi, node, sourceFile) => {
+	if (typeof node.getWidth === "function") return node.getWidth(sourceFile);
+	const start = getNodeStart$1(tsApi, node, sourceFile);
+	return node.end - start;
+};
+const getEntityNameText = (tsApi, name) => tsApi.isIdentifier(name) ? getIdentifierText$1(name) : `${getEntityNameText(tsApi, name.left)}.${getIdentifierText$1(name.right)}`;
+const normalizeNoDiscardMode = (mode) => mode === "direct" ? "direct" : "must-use";
+const isResultLikeType = (tsApi, checker, node, type) => {
+	const unionOrIntersectionTypes = getUnionOrIntersectionTypes$1(tsApi, type);
+	if (unionOrIntersectionTypes !== void 0) return unionOrIntersectionTypes.some((innerType) => isResultLikeType(tsApi, checker, node, innerType));
+	const aliasName = getSymbolName(type.aliasSymbol);
+	const symbolName = getTypeSymbolName(type);
+	if (aliasName !== void 0 && resultTypeNames.has(aliasName) || symbolName !== void 0 && resultTypeNames.has(symbolName)) return true;
+	if (tsApi.isTypeReferenceNode(node)) {
+		const typeName = getEntityNameText(tsApi, node.typeName);
+		const unqualifiedName = typeName.includes(".") ? typeName.split(".").at(-1) : typeName;
+		return unqualifiedName !== void 0 && resultTypeNames.has(unqualifiedName);
+	}
+	return false;
+};
+const unwrapExpression = (tsApi, expression) => {
+	let current = expression;
+	for (;;) if (tsApi.isParenthesizedExpression(current)) current = current.expression;
+	else if (tsApi.isAsExpression(current)) current = current.expression;
+	else if (tsApi.isTypeAssertionExpression(current)) current = current.expression;
+	else if (tsApi.isNonNullExpression(current)) current = current.expression;
+	else if (tsApi.isSatisfiesExpression(current)) current = current.expression;
+	else return current;
+};
+const isExplicitDiscard = (tsApi, expression) => tsApi.isVoidExpression(unwrapExpression(tsApi, expression));
+const isCallLikeDiscard = (tsApi, expression) => {
+	const unwrapped = unwrapExpression(tsApi, expression);
+	if (tsApi.isAwaitExpression(unwrapped)) return isCallLikeDiscard(tsApi, unwrapped.expression);
+	if (tsApi.isCallExpression(unwrapped)) return true;
+	if (tsApi.isConditionalExpression(unwrapped)) return isCallLikeDiscard(tsApi, unwrapped.whenTrue) || isCallLikeDiscard(tsApi, unwrapped.whenFalse);
+	if (tsApi.isBinaryExpression(unwrapped)) {
+		const { kind } = unwrapped.operatorToken;
+		return (kind === tsApi.SyntaxKind.AmpersandAmpersandToken || kind === tsApi.SyntaxKind.BarBarToken || kind === tsApi.SyntaxKind.QuestionQuestionToken) && isCallLikeDiscard(tsApi, unwrapped.right);
+	}
+	return false;
+};
+const getTypeName$1 = (context, node, type) => context.checker.typeToString(type, node, context.tsApi.TypeFormatFlags.NoTruncation);
+const createFinding$1 = (context, node, typeName, message) => {
+	const start = getNodeStart$1(context.tsApi, node, context.sourceFile);
+	const position = context.tsApi.getLineAndCharacterOfPosition(context.sourceFile, start);
+	return {
+		column: position.character + 1,
+		file: context.sourceFile.fileName,
+		length: getNodeWidth$1(context.tsApi, node, context.sourceFile),
+		line: position.line + 1,
+		message,
+		rule: "no-discard",
+		severity: "error",
+		start,
+		type: typeName
+	};
+};
+const createIgnoredFinding = (context, node, typeName) => createFinding$1(context, node, typeName, `Ignored ${typeName} value. Handle it or explicitly discard it with \`void\`.`);
+const createUnhandledFinding = (context, tracked) => createFinding$1(context, tracked.identifier, tracked.typeName, `Unhandled ${tracked.typeName} value assigned to \`${tracked.name}\`. Handle it, return it, or explicitly discard it with \`void\`.`);
+const symbolsEqual = (left, right) => left === right || left.valueDeclaration === right.valueDeclaration;
+const isWrapperParent = (tsApi, parent, child) => tsApi.isParenthesizedExpression(parent) && parent.expression === child || tsApi.isAsExpression(parent) && parent.expression === child || tsApi.isTypeAssertionExpression(parent) && parent.expression === child || tsApi.isNonNullExpression(parent) && parent.expression === child || tsApi.isSatisfiesExpression(parent) && parent.expression === child;
+const isReturnValueContainerParent = (tsApi, parent, child) => isWrapperParent(tsApi, parent, child) || tsApi.isShorthandPropertyAssignment(parent) && parent.name === child || tsApi.isPropertyAssignment(parent) && parent.initializer === child || tsApi.isSpreadAssignment(parent) && parent.expression === child || tsApi.isSpreadElement(parent) && parent.expression === child || tsApi.isObjectLiteralExpression(parent) && parent.properties.some((property) => property === child) || tsApi.isArrayLiteralExpression(parent) && parent.elements.some((element) => element === child) || tsApi.isConditionalExpression(parent) && (parent.whenTrue === child || parent.whenFalse === child);
+const getReferenceChainRoot = (tsApi, identifier, ancestors) => {
+	let current = identifier;
+	let parentIndex = ancestors.length - 1;
+	for (;;) {
+		const parent = ancestors[parentIndex];
+		if (parent === void 0) return {
+			parent: void 0,
+			root: current
+		};
+		if (isWrapperParent(tsApi, parent, current)) current = parent;
+		else if (tsApi.isAwaitExpression(parent) && parent.expression === current) current = parent;
+		else if (tsApi.isPropertyAccessExpression(parent) && parent.expression === current) current = parent;
+		else if (tsApi.isCallExpression(parent) && parent.expression === current) current = parent;
+		else return {
+			parent,
+			root: current
+		};
+		parentIndex -= 1;
+	}
+};
+const isReturnedReference = (tsApi, identifier, ancestors) => {
+	const { parent, root } = getReferenceChainRoot(tsApi, identifier, ancestors);
+	if (parent !== void 0 && tsApi.isReturnStatement(parent) && parent.expression === root || parent !== void 0 && tsApi.isArrowFunction(parent) && parent.body === root) return true;
+	let current = identifier;
+	for (let parentIndex = ancestors.length - 1; parentIndex >= 0; parentIndex -= 1) {
+		const containerParent = ancestors[parentIndex];
+		if (containerParent === void 0) return false;
+		if (isReturnValueContainerParent(tsApi, containerParent, current)) {
+			current = containerParent;
+			continue;
+		}
+		return tsApi.isReturnStatement(containerParent) && containerParent.expression === current || tsApi.isArrowFunction(containerParent) && containerParent.body === current;
+	}
+	return false;
+};
+const isExplicitDiscardReference = (tsApi, identifier, ancestors) => {
+	const { parent, root } = getReferenceChainRoot(tsApi, identifier, ancestors);
+	return parent !== void 0 && tsApi.isVoidExpression(parent) && parent.expression === root;
+};
+const isConsumedByReceiverChain = (tsApi, identifier, ancestors) => {
+	let current = identifier;
+	let parentIndex = ancestors.length - 1;
+	for (;;) {
+		const parent = ancestors[parentIndex];
+		if (parent === void 0) return false;
+		if (isWrapperParent(tsApi, parent, current)) current = parent;
+		else if (tsApi.isAwaitExpression(parent) && parent.expression === current) current = parent;
+		else if (tsApi.isPropertyAccessExpression(parent) && parent.expression === current) {
+			const methodOrPropertyName = getIdentifierText$1(parent.name);
+			const nextParent = ancestors[parentIndex - 1];
+			if (consumerProperties.has(methodOrPropertyName)) return true;
+			if (consumerMethods.has(methodOrPropertyName) && nextParent !== void 0 && tsApi.isCallExpression(nextParent) && nextParent.expression === parent) return true;
+			current = parent;
+		} else if (tsApi.isCallExpression(parent) && parent.expression === current) current = parent;
+		else return false;
+		parentIndex -= 1;
+	}
+};
+const isHandledReference = (tsApi, identifier, ancestors) => isReturnedReference(tsApi, identifier, ancestors) || isExplicitDiscardReference(tsApi, identifier, ancestors) || isConsumedByReceiverChain(tsApi, identifier, ancestors);
+const isIdentifierInsideDiscardedResultExpression = (context, identifier, ancestors) => {
+	let current = identifier;
+	for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+		current = ancestors[index];
+		if (context.tsApi.isExpressionStatement(current)) {
+			if (isExplicitDiscard(context.tsApi, current.expression) || !isCallLikeDiscard(context.tsApi, current.expression)) return false;
+			const type = context.checker.getTypeAtLocation(current.expression);
+			return isResultLikeType(context.tsApi, context.checker, current.expression, type);
+		}
+	}
+	return false;
+};
+const getTrackedResult = (tsApi, checker, trackedResults, identifier) => {
+	const shorthandParent = identifier.parent;
+	const symbol = shorthandParent !== void 0 && tsApi.isShorthandPropertyAssignment(shorthandParent) && shorthandParent.name === identifier ? checker.getShorthandAssignmentValueSymbol(shorthandParent) : checker.getSymbolAtLocation(identifier);
+	return symbol === void 0 ? void 0 : trackedResults.find((tracked) => symbolsEqual(tracked.symbol, symbol));
+};
+const collectTrackedResults = (context) => {
+	const trackedResults = [];
+	const visit = (node) => {
+		if (context.tsApi.isVariableDeclaration(node) && context.tsApi.isIdentifier(node.name) && node.initializer !== void 0 && isCallLikeDiscard(context.tsApi, node.initializer)) {
+			const type = context.checker.getTypeAtLocation(node.initializer);
+			if (isResultLikeType(context.tsApi, context.checker, node.initializer, type)) {
+				const symbol = context.checker.getSymbolAtLocation(node.name);
+				if (symbol !== void 0) trackedResults.push({
+					declaration: node,
+					hasDiscardedResultUse: false,
+					handled: false,
+					identifier: node.name,
+					name: getIdentifierText$1(node.name),
+					symbol,
+					typeName: getTypeName$1(context, node.initializer, type)
+				});
+			}
+		}
+		context.tsApi.forEachChild(node, visit);
+	};
+	visit(context.sourceFile);
+	return trackedResults;
+};
+const markTrackedResultUses = (context, trackedResults) => {
+	const visit = (node, ancestors) => {
+		if (context.tsApi.isIdentifier(node)) {
+			const tracked = getTrackedResult(context.tsApi, context.checker, trackedResults, node);
+			if (tracked !== void 0 && node !== tracked.identifier) {
+				if (isHandledReference(context.tsApi, node, ancestors)) tracked.handled = true;
+				if (isIdentifierInsideDiscardedResultExpression(context, node, ancestors)) tracked.hasDiscardedResultUse = true;
+			}
+		}
+		context.tsApi.forEachChild(node, (child) => visit(child, [...ancestors, node]));
+	};
+	visit(context.sourceFile, []);
+};
+const getDirectFindings = (context) => {
+	const findings = [];
+	const visit = (node) => {
+		if (context.tsApi.isExpressionStatement(node) && !isExplicitDiscard(context.tsApi, node.expression) && isCallLikeDiscard(context.tsApi, node.expression)) {
+			const type = context.checker.getTypeAtLocation(node.expression);
+			if (isResultLikeType(context.tsApi, context.checker, node.expression, type)) findings.push(createIgnoredFinding(context, node.expression, getTypeName$1(context, node.expression, type)));
+		}
+		context.tsApi.forEachChild(node, visit);
+	};
+	visit(context.sourceFile);
+	return findings;
+};
+const getMustUseFindings = (context) => {
+	const trackedResults = collectTrackedResults(context);
+	markTrackedResultUses(context, trackedResults);
+	return trackedResults.filter((tracked) => !tracked.handled && !tracked.hasDiscardedResultUse).map((tracked) => createUnhandledFinding(context, tracked));
+};
+const getSourceFileNoDiscardFindings = (tsApi, checker, sourceFile, options = {}) => {
+	const context = {
+		checker,
+		sourceFile,
+		tsApi
+	};
+	const mode = normalizeNoDiscardMode(options.mode);
+	const directFindings = getDirectFindings(context);
+	return mode === "must-use" ? [...directFindings, ...getMustUseFindings(context)] : directFindings;
+};
+//#endregion
+//#region src/rules-core.ts
+const resultarRuleNames = [
+	"no-discard",
+	"prefer-map-err",
+	"prefer-and-then",
+	"typed-catch-mapper",
+	"no-unsafe-await",
+	"no-try-catch-in-safe-try",
+	"yield-star-in-safe-try",
+	"unsafe-result-type-assertion",
+	"prefer-tagged-error",
+	"tagged-error-name-match",
+	"no-tagged-error-constructor-override",
+	"no-useless-recovery"
+];
+const ruleOptionNameByRule = {
+	"no-discard": "noDiscard",
+	"no-tagged-error-constructor-override": "noTaggedErrorConstructorOverride",
+	"no-try-catch-in-safe-try": "noTryCatchInSafeTry",
+	"no-unsafe-await": "noUnsafeAwait",
+	"no-useless-recovery": "noUselessRecovery",
+	"prefer-and-then": "preferAndThen",
+	"prefer-map-err": "preferMapErr",
+	"prefer-tagged-error": "preferTaggedError",
+	"tagged-error-name-match": "taggedErrorNameMatch",
+	"typed-catch-mapper": "typedCatchMapper",
+	"unsafe-result-type-assertion": "unsafeResultTypeAssertion",
+	"yield-star-in-safe-try": "yieldStarInSafeTry"
+};
+const defaultResultarRulesOptions = {
+	noDiscard: "error",
+	noDiscardMode: "must-use",
+	noTaggedErrorConstructorOverride: "warning",
+	noTryCatchInSafeTry: "warning",
+	noUnsafeAwait: "off",
+	noUnsafeAwaitMode: "resultar-context",
+	noUselessRecovery: "warning",
+	preferAndThen: "warning",
+	preferMapErr: "warning",
+	preferTaggedError: "warning",
+	taggedErrorNameMatch: "warning",
+	typedCatchMapper: "warning",
+	unsafeResultTypeAssertion: "warning",
+	yieldStarInSafeTry: "warning"
+};
+resultarRuleNames.filter((ruleName) => ruleName !== "no-discard");
+const recoveryMethods = new Set([
+	"catchReason",
+	"catchReasons",
+	"catchTag",
+	"catchTags",
+	"mapErr",
+	"orElse",
+	"unwrapReason"
+]);
+const tryMapperCallNames = new Set([
+	"fromThrowable",
+	"fromThrowableAsync",
+	"tryCatch",
+	"tryCatchAsync",
+	"tryResult",
+	"tryResultAsync",
+	"tryAsync"
+]);
+const asyncAwaitBoundaryCallNames = new Set([
+	"fromThrowableAsync",
+	"tryCatchAsync",
+	"tryResultAsync",
+	"tryAsync"
+]);
+const normalizeRuleSeverity = (value, fallback) => value === "error" || value === "message" || value === "off" || value === "suggestion" || value === "warning" ? value : fallback;
+const normalizeNoUnsafeAwaitMode = (value, fallback = defaultResultarRulesOptions.noUnsafeAwaitMode) => value === "all" || value === "resultar-context" ? value : fallback;
+const normalizeResultarRulesOptions = (options = {}) => ({
+	noDiscard: normalizeRuleSeverity(options.noDiscard, defaultResultarRulesOptions.noDiscard),
+	noDiscardMode: normalizeNoDiscardMode(options.noDiscardMode),
+	noTaggedErrorConstructorOverride: normalizeRuleSeverity(options.noTaggedErrorConstructorOverride, defaultResultarRulesOptions.noTaggedErrorConstructorOverride),
+	noTryCatchInSafeTry: normalizeRuleSeverity(options.noTryCatchInSafeTry, defaultResultarRulesOptions.noTryCatchInSafeTry),
+	noUnsafeAwait: normalizeRuleSeverity(options.noUnsafeAwait, defaultResultarRulesOptions.noUnsafeAwait),
+	noUnsafeAwaitMode: normalizeNoUnsafeAwaitMode(options.noUnsafeAwaitMode),
+	noUselessRecovery: normalizeRuleSeverity(options.noUselessRecovery, defaultResultarRulesOptions.noUselessRecovery),
+	preferAndThen: normalizeRuleSeverity(options.preferAndThen, defaultResultarRulesOptions.preferAndThen),
+	preferMapErr: normalizeRuleSeverity(options.preferMapErr, defaultResultarRulesOptions.preferMapErr),
+	preferTaggedError: normalizeRuleSeverity(options.preferTaggedError, defaultResultarRulesOptions.preferTaggedError),
+	taggedErrorNameMatch: normalizeRuleSeverity(options.taggedErrorNameMatch, defaultResultarRulesOptions.taggedErrorNameMatch),
+	typedCatchMapper: normalizeRuleSeverity(options.typedCatchMapper, defaultResultarRulesOptions.typedCatchMapper),
+	unsafeResultTypeAssertion: normalizeRuleSeverity(options.unsafeResultTypeAssertion, defaultResultarRulesOptions.unsafeResultTypeAssertion),
+	yieldStarInSafeTry: normalizeRuleSeverity(options.yieldStarInSafeTry, defaultResultarRulesOptions.yieldStarInSafeTry)
+});
+const getRuleSeverity = (options, rule) => {
+	const severity = options[ruleOptionNameByRule[rule]];
+	return severity === "off" ? void 0 : severity;
+};
+const getTokenPosOfNode = (context, node) => {
+	const getTokenPos = context.tsApi.getTokenPosOfNode;
+	return getTokenPos === void 0 ? node.pos : getTokenPos(node, context.sourceFile);
+};
+const getNodeStart = (context, node) => typeof node.getStart === "function" ? node.getStart(context.sourceFile) : getTokenPosOfNode(context, node);
+const getIdentifierText = (identifier) => {
+	if (typeof identifier.text === "string") return identifier.text;
+	return identifier.escapedText === void 0 ? "" : String(identifier.escapedText);
+};
+const getNodeWidth = (context, node) => {
+	if (typeof node.getWidth === "function") return node.getWidth(context.sourceFile);
+	const start = getNodeStart(context, node);
+	return node.end - start;
+};
+const createFinding = (context, node, rule, severity, message, type) => {
+	const start = getNodeStart(context, node);
+	const position = context.tsApi.getLineAndCharacterOfPosition(context.sourceFile, start);
+	const base = {
+		column: position.character + 1,
+		file: context.sourceFile.fileName,
+		length: getNodeWidth(context, node),
+		line: position.line + 1,
+		message,
+		rule,
+		severity,
+		start
+	};
+	return type === void 0 ? base : {
+		...base,
+		type
+	};
+};
+const visitSourceFile = (context, visitor) => {
+	const visit = (node) => {
+		visitor(node);
+		context.tsApi.forEachChild(node, visit);
+	};
+	visit(context.sourceFile);
+};
+const getPropertyNameText = (tsApi, name) => {
+	if (tsApi.isIdentifier(name)) return getIdentifierText(name);
+	if (tsApi.isStringLiteral(name) || tsApi.isNumericLiteral(name)) return name.text;
+};
+const getExpressionName = (tsApi, expression) => {
+	const unwrapped = unwrapExpression(tsApi, expression);
+	if (tsApi.isIdentifier(unwrapped)) return getIdentifierText(unwrapped);
+	if (tsApi.isPropertyAccessExpression(unwrapped)) return getIdentifierText(unwrapped.name);
+};
+const getMethodCall = (tsApi, node) => {
+	if (!tsApi.isCallExpression(node)) return;
+	const expression = unwrapExpression(tsApi, node.expression);
+	if (!tsApi.isPropertyAccessExpression(expression)) return;
+	if (!tsApi.isIdentifier(expression.name)) return;
+	return {
+		methodName: getIdentifierText(expression.name),
+		nameNode: expression.name,
+		receiver: expression.expression
+	};
+};
+const getTypeName = (context, node, type) => context.checker.typeToString(type, node, context.tsApi.TypeFormatFlags.NoTruncation);
+const getUnionOrIntersectionTypes = (context, type) => (type.flags & (context.tsApi.TypeFlags.Union | context.tsApi.TypeFlags.Intersection)) === 0 ? void 0 : type.types ?? [];
+const getTypeArguments = (context, type) => {
+	const { aliasTypeArguments } = type;
+	if (aliasTypeArguments !== void 0 && aliasTypeArguments.length > 0) return aliasTypeArguments;
+	const reference = type;
+	return reference.target === void 0 ? [] : context.checker.getTypeArguments(reference);
+};
+const getResultTypeParts = (context, node, type) => {
+	const unionOrIntersectionTypes = getUnionOrIntersectionTypes(context, type);
+	if (unionOrIntersectionTypes !== void 0) return unionOrIntersectionTypes.flatMap((innerType) => getResultTypeParts(context, node, innerType));
+	if (!isResultLikeType(context.tsApi, context.checker, node, type)) return [];
+	const [okType, errorType] = getTypeArguments(context, type);
+	return [{
+		error: errorType,
+		ok: okType
+	}];
+};
+const isResultAsyncLikeType = (context, node, type) => {
+	const unionOrIntersectionTypes = getUnionOrIntersectionTypes(context, type);
+	if (unionOrIntersectionTypes !== void 0) return unionOrIntersectionTypes.some((innerType) => isResultAsyncLikeType(context, node, innerType));
+	return /\b(?:DisposableResultAsync|ResultAsync|StrictResultAsync)\b/.test(getTypeName(context, node, type));
+};
+const isResultLikeExpression = (context, expression) => {
+	const type = context.checker.getTypeAtLocation(expression);
+	return isResultLikeType(context.tsApi, context.checker, expression, type);
+};
+const getUnionTypes = (context, type) => (type.flags & context.tsApi.TypeFlags.Union) === 0 ? void 0 : type.types ?? [];
+const everyUnionPart = (context, type, predicate) => {
+	const unionTypes = getUnionTypes(context, type);
+	return unionTypes === void 0 ? predicate(type) : unionTypes.every((innerType) => predicate(innerType));
+};
+const isResultAsyncLikeAwaitType = (context, node, type) => everyUnionPart(context, type, (innerType) => isResultAsyncLikeType(context, node, innerType));
+const isResultLikeAwaitedType = (context, node, type) => everyUnionPart(context, type, (innerType) => isResultLikeType(context.tsApi, context.checker, node, innerType));
+const getPromisedTypeOfPromise = (context, node, type) => {
+	return context.checker.getPromisedTypeOfPromise?.(type, node);
+};
+const isSafeAwaitExpression = (context, expression) => {
+	const expressionType = context.checker.getTypeAtLocation(expression);
+	if (isResultAsyncLikeAwaitType(context, expression, expressionType)) return true;
+	const promisedType = getPromisedTypeOfPromise(context, expression, expressionType);
+	if (promisedType === void 0) return true;
+	return isResultLikeAwaitedType(context, expression, context.checker.getAwaitedType(expressionType) ?? promisedType);
+};
+const isPromiseOfResultLikeType = (context, node, type) => {
+	const unionOrIntersectionTypes = getUnionOrIntersectionTypes(context, type);
+	if (unionOrIntersectionTypes !== void 0) return unionOrIntersectionTypes.some((innerType) => isPromiseOfResultLikeType(context, node, innerType));
+	const promisedType = getPromisedTypeOfPromise(context, node, type);
+	if (promisedType === void 0) return false;
+	return isResultLikeAwaitedType(context, node, context.checker.getAwaitedType(type) ?? promisedType);
+};
+const isResultarAsyncContextReturnType = (context, node, type) => isResultAsyncLikeType(context, node, type) || isPromiseOfResultLikeType(context, node, type);
+const getFunctionLikeReturnType = (context, node) => {
+	const signature = context.checker.getSignatureFromDeclaration(node);
+	if (signature !== void 0) return signature.getReturnType();
+	const [callSignature] = context.checker.getTypeAtLocation(node).getCallSignatures();
+	return callSignature?.getReturnType();
+};
+const isResultarAsyncFunctionContext = (context, node) => {
+	if (!isFunctionLike(context.tsApi, node)) return false;
+	const returnType = getFunctionLikeReturnType(context, node);
+	return returnType !== void 0 && isResultarAsyncContextReturnType(context, node, returnType);
+};
+const isUnknownOrAnyType = (tsApi, type) => type !== void 0 && (Boolean(type.flags & tsApi.TypeFlags.Unknown) || Boolean(type.flags & tsApi.TypeFlags.Any));
+const isNeverType = (tsApi, type) => type !== void 0 && Boolean(type.flags & tsApi.TypeFlags.Never);
+const getReturnedExpressions = (tsApi, callback) => {
+	const expressions = [];
+	if (!tsApi.isArrowFunction(callback) && !tsApi.isFunctionExpression(callback)) return expressions;
+	if (tsApi.isArrowFunction(callback) && !tsApi.isBlock(callback.body)) return [callback.body];
+	const { body } = callback;
+	const visit = (node) => {
+		if (node !== body && isFunctionLike(tsApi, node)) return;
+		if (tsApi.isReturnStatement(node) && node.expression !== void 0) {
+			expressions.push(node.expression);
+			return;
+		}
+		tsApi.forEachChild(node, visit);
+	};
+	visit(body);
+	return expressions;
+};
+const isFunctionLike = (tsApi, node) => tsApi.isArrowFunction(node) || tsApi.isFunctionDeclaration(node) || tsApi.isFunctionExpression(node) || tsApi.isMethodDeclaration(node);
+const isErrConstructorCall = (tsApi, expression) => {
+	const unwrapped = unwrapExpression(tsApi, expression);
+	if (!tsApi.isCallExpression(unwrapped)) return false;
+	return getExpressionName(tsApi, unwrapped.expression) === "err";
+};
+const hasObjectCatchProperty = (tsApi, expression) => {
+	const unwrapped = unwrapExpression(tsApi, expression);
+	if (!tsApi.isObjectLiteralExpression(unwrapped)) return false;
+	return unwrapped.properties.some((property) => {
+		if (tsApi.isPropertyAssignment(property) || tsApi.isMethodDeclaration(property)) return getPropertyNameText(tsApi, property.name) === "catch";
+		return false;
+	});
+};
+const hasMapperArgument = (tsApi, call) => {
+	const [firstArgument, secondArgument] = call.arguments;
+	return secondArgument !== void 0 || firstArgument !== void 0 && hasObjectCatchProperty(tsApi, firstArgument);
+};
+const getObjectTryBody = (tsApi, objectLiteral) => {
+	for (const property of objectLiteral.properties) {
+		if (tsApi.isMethodDeclaration(property) && getPropertyNameText(tsApi, property.name) === "try") return property;
+		if (tsApi.isPropertyAssignment(property) && getPropertyNameText(tsApi, property.name) === "try" && (tsApi.isArrowFunction(property.initializer) || tsApi.isFunctionExpression(property.initializer))) return property.initializer;
+	}
+};
+const getSafeTryBody = (tsApi, call) => {
+	if (getExpressionName(tsApi, call.expression) !== "safeTry") return;
+	const [firstArgument] = call.arguments;
+	if (firstArgument === void 0) return;
+	const unwrapped = unwrapExpression(tsApi, firstArgument);
+	if (tsApi.isArrowFunction(unwrapped) || tsApi.isFunctionExpression(unwrapped)) return unwrapped;
+	if (!tsApi.isObjectLiteralExpression(unwrapped)) return;
+	return getObjectTryBody(tsApi, unwrapped);
+};
+const getResultarAwaitBoundaryBody = (tsApi, call) => {
+	const callName = getExpressionName(tsApi, call.expression);
+	if (callName === void 0 || !asyncAwaitBoundaryCallNames.has(callName)) return;
+	const [firstArgument] = call.arguments;
+	if (firstArgument === void 0) return;
+	const unwrapped = unwrapExpression(tsApi, firstArgument);
+	if (tsApi.isArrowFunction(unwrapped) || tsApi.isFunctionExpression(unwrapped)) return unwrapped;
+	if (tsApi.isObjectLiteralExpression(unwrapped)) return getObjectTryBody(tsApi, unwrapped);
+};
+const getResultarAwaitContextBody = (tsApi, call) => getSafeTryBody(tsApi, call) ?? getResultarAwaitBoundaryBody(tsApi, call);
+const visitSafeTryBody = (tsApi, body, visitor) => {
+	const root = body.body;
+	if (root === void 0) return;
+	const visit = (node) => {
+		if (node !== root && isFunctionLike(tsApi, node)) return;
+		visitor(node);
+		tsApi.forEachChild(node, visit);
+	};
+	visit(root);
+};
+const getCreateTaggedErrorOptions = (tsApi, node) => {
+	for (const heritageClause of node.heritageClauses ?? []) {
+		if (heritageClause.token !== tsApi.SyntaxKind.ExtendsKeyword) continue;
+		for (const heritageType of heritageClause.types) {
+			const { expression } = heritageType;
+			if (tsApi.isCallExpression(expression) && getExpressionName(tsApi, expression.expression) === "createTaggedError") {
+				const [options] = expression.arguments;
+				return options !== void 0 && tsApi.isObjectLiteralExpression(options) ? options : void 0;
+			}
+		}
+	}
+};
+const getTaggedErrorName = (tsApi, options) => {
+	for (const property of options.properties) if (tsApi.isPropertyAssignment(property) && getPropertyNameText(tsApi, property.name) === "name" && (tsApi.isStringLiteral(property.initializer) || tsApi.isNoSubstitutionTemplateLiteral(property.initializer))) return property.initializer;
+};
+const classExtendsNativeError = (tsApi, node) => (node.heritageClauses ?? []).some((heritageClause) => heritageClause.token === tsApi.SyntaxKind.ExtendsKeyword && heritageClause.types.some((heritageType) => getExpressionName(tsApi, heritageType.expression) === "Error"));
+const getFirstResultErrorTypes = (context, node, type) => getResultTypeParts(context, node, type).map((part) => part.error).filter((errorType) => errorType !== void 0);
+const getPreferMapErrFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		const call = context.tsApi.isCallExpression(node) ? node : void 0;
+		const methodCall = getMethodCall(context.tsApi, node);
+		if (call === void 0 || methodCall?.methodName !== "orElse") return;
+		if (!isResultLikeExpression(context, methodCall.receiver)) return;
+		const [callback] = call.arguments;
+		const returnedExpressions = callback === void 0 ? [] : getReturnedExpressions(context.tsApi, callback);
+		if (returnedExpressions.length === 0 || !returnedExpressions.every((expression) => isErrConstructorCall(context.tsApi, expression) && isResultLikeExpression(context, expression))) return;
+		findings.push(createFinding(context, methodCall.nameNode, "prefer-map-err", severity, "`orElse` only replaces the failure with another Err. Use `mapErr` when the Ok value cannot recover."));
+	});
+	return findings;
+};
+const getPreferAndThenFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		const call = context.tsApi.isCallExpression(node) ? node : void 0;
+		const methodCall = getMethodCall(context.tsApi, node);
+		if (call === void 0 || methodCall?.methodName !== "map") return;
+		const receiverType = context.checker.getTypeAtLocation(methodCall.receiver);
+		if (!isResultLikeType(context.tsApi, context.checker, methodCall.receiver, receiverType)) return;
+		const [callback] = call.arguments;
+		const returnedResult = (callback === void 0 ? [] : getReturnedExpressions(context.tsApi, callback)).find((expression) => isResultLikeExpression(context, expression));
+		if (returnedResult === void 0) return;
+		const returnedType = context.checker.getTypeAtLocation(returnedResult);
+		const methodName = !isResultAsyncLikeType(context, methodCall.receiver, receiverType) && isResultAsyncLikeType(context, returnedResult, returnedType) ? "asyncAndThen" : "andThen";
+		findings.push(createFinding(context, methodCall.nameNode, "prefer-and-then", severity, `\`map\` creates a nested Result when its callback returns ${getTypeName(context, returnedResult, returnedType)}. Use \`${methodName}\` for fallible composition.`));
+	});
+	return findings;
+};
+const getTypedCatchMapperFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isCallExpression(node)) return;
+		const callName = getExpressionName(context.tsApi, node.expression);
+		if (callName === void 0 || !tryMapperCallNames.has(callName) || hasMapperArgument(context.tsApi, node)) return;
+		if (callName !== "fromThrowable" && callName !== "fromThrowableAsync") {
+			const errorTypes = getFirstResultErrorTypes(context, node, context.checker.getTypeAtLocation(node));
+			if (errorTypes.length > 0 && errorTypes.every((errorType) => !isUnknownOrAnyType(context.tsApi, errorType))) return;
+		}
+		findings.push(createFinding(context, node.expression, "typed-catch-mapper", severity, `\`${callName}\` without a catch mapper leaves the error channel as \`unknown\`. Map the caught value to a specific Resultar error.`));
+	});
+	return findings;
+};
+const collectResultarAwaitBoundaryBodies = (context) => {
+	const bodies = /* @__PURE__ */ new Set();
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isCallExpression(node)) return;
+		const body = getResultarAwaitBoundaryBody(context.tsApi, node);
+		if (body !== void 0) bodies.add(body);
+	});
+	return bodies;
+};
+const collectResultarAwaitContextBodies = (context) => {
+	const bodies = /* @__PURE__ */ new Set();
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isCallExpression(node)) return;
+		const body = getResultarAwaitContextBody(context.tsApi, node);
+		if (body !== void 0) bodies.add(body);
+	});
+	return bodies;
+};
+const getNoUnsafeAwaitFindings = (context, severity, mode) => {
+	const findings = [];
+	const boundaryBodies = collectResultarAwaitBoundaryBodies(context);
+	const contextBodies = collectResultarAwaitContextBodies(context);
+	const visit = (node, insideResultarBoundary, insideResultarContext) => {
+		const startsResultarBoundary = boundaryBodies.has(node);
+		const currentInsideBoundary = insideResultarBoundary || startsResultarBoundary;
+		const startsResultarContext = contextBodies.has(node) || isResultarAsyncFunctionContext(context, node);
+		const currentInsideContext = insideResultarContext || startsResultarContext;
+		if ((mode === "all" || currentInsideContext) && context.tsApi.isAwaitExpression(node) && !currentInsideBoundary && !isSafeAwaitExpression(context, node.expression)) findings.push(createFinding(context, node, "no-unsafe-await", severity, "Wrap this awaited Promise in tryAsync, tryResultAsync, tryCatchAsync, or fromThrowableAsync so rejections stay in the Resultar error channel."));
+		if (node !== context.sourceFile && isFunctionLike(context.tsApi, node)) {
+			context.tsApi.forEachChild(node, (child) => visit(child, startsResultarBoundary, startsResultarContext));
+			return;
+		}
+		context.tsApi.forEachChild(node, (child) => visit(child, currentInsideBoundary, currentInsideContext));
+	};
+	visit(context.sourceFile, false, false);
+	return findings;
+};
+const getNoTryCatchInSafeTryFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isCallExpression(node)) return;
+		const safeTryBody = getSafeTryBody(context.tsApi, node);
+		if (safeTryBody === void 0) return;
+		visitSafeTryBody(context.tsApi, safeTryBody, (bodyNode) => {
+			if (context.tsApi.isTryStatement(bodyNode)) findings.push(createFinding(context, bodyNode, "no-try-catch-in-safe-try", severity, "Avoid raw try/catch inside `safeTry`. Use `safeTry({ try, catch })`, `tryResult`, or `tryResultAsync` to keep failures typed."));
+		});
+	});
+	return findings;
+};
+const getYieldStarInSafeTryFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isCallExpression(node)) return;
+		const safeTryBody = getSafeTryBody(context.tsApi, node);
+		if (safeTryBody === void 0) return;
+		visitSafeTryBody(context.tsApi, safeTryBody, (bodyNode) => {
+			if (context.tsApi.isYieldExpression(bodyNode) && bodyNode.asteriskToken === void 0 && bodyNode.expression !== void 0 && isResultLikeExpression(context, bodyNode.expression)) findings.push(createFinding(context, bodyNode, "yield-star-in-safe-try", severity, "Use `yield*` when unwrapping Resultar values inside `safeTry`."));
+		});
+	});
+	return findings;
+};
+const getUnsafeResultTypeAssertionFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isAsExpression(node) && !context.tsApi.isTypeAssertionExpression(node)) return;
+		const { expression } = node;
+		const originalType = context.checker.getTypeAtLocation(expression);
+		const assertedType = context.checker.getTypeAtLocation(node);
+		const originalParts = getResultTypeParts(context, expression, originalType);
+		const assertedParts = getResultTypeParts(context, node, assertedType);
+		if (originalParts.length === 0 || assertedParts.length === 0) return;
+		const narrowedErrors = originalParts.flatMap((originalPart) => assertedParts.filter((assertedPart) => originalPart.error !== void 0 && assertedPart.error !== void 0 && !isUnknownOrAnyType(context.tsApi, originalPart.error) && !context.checker.isTypeAssignableTo(originalPart.error, assertedPart.error)).map((assertedPart) => ({
+			asserted: assertedPart.error,
+			original: originalPart.error
+		})));
+		if (narrowedErrors.length === 0) return;
+		const details = narrowedErrors.map(({ asserted, original }) => `\`${getTypeName(context, expression, original)}\` to \`${getTypeName(context, node, asserted)}\``).join(", ");
+		findings.push(createFinding(context, node, "unsafe-result-type-assertion", severity, `This assertion narrows the Resultar error channel unsafely (${details}). Prefer a real recovery or mapping step.`));
+	});
+	return findings;
+};
+const getPreferTaggedErrorFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (context.tsApi.isClassDeclaration(node) && classExtendsNativeError(context.tsApi, node)) {
+			findings.push(createFinding(context, node.name ?? node, "prefer-tagged-error", severity, "Prefer `createTaggedError` for Resultar domain errors so failures keep a stable tag and typed metadata."));
+			return;
+		}
+		if (!context.tsApi.isCallExpression(node) || getExpressionName(context.tsApi, node.expression) !== "err") return;
+		const [errorArgument] = node.arguments;
+		if (errorArgument === void 0) return;
+		const unwrappedErrorArgument = unwrapExpression(context.tsApi, errorArgument);
+		if (context.tsApi.isNewExpression(unwrappedErrorArgument) && getExpressionName(context.tsApi, unwrappedErrorArgument.expression) === "Error") findings.push(createFinding(context, errorArgument, "prefer-tagged-error", severity, "Prefer a `createTaggedError` instance over `new Error(...)` in Resultar error channels."));
+	});
+	return findings;
+};
+const getTaggedErrorNameMatchFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isClassDeclaration(node) || node.name === void 0) return;
+		const options = getCreateTaggedErrorOptions(context.tsApi, node);
+		const nameInitializer = options === void 0 ? void 0 : getTaggedErrorName(context.tsApi, options);
+		const className = getIdentifierText(node.name);
+		if (nameInitializer === void 0 || nameInitializer.text === className) return;
+		findings.push(createFinding(context, nameInitializer, "tagged-error-name-match", severity, `Tagged error name \`${nameInitializer.text}\` should match class name \`${className}\`.`));
+	});
+	return findings;
+};
+const getNoTaggedErrorConstructorOverrideFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		if (!context.tsApi.isClassDeclaration(node) || getCreateTaggedErrorOptions(context.tsApi, node) === void 0) return;
+		for (const member of node.members) if (context.tsApi.isConstructorDeclaration(member)) findings.push(createFinding(context, member, "no-tagged-error-constructor-override", severity, "Do not override the constructor generated by `createTaggedError`; it owns template props, cause, and serialization behavior."));
+	});
+	return findings;
+};
+const getNoUselessRecoveryFindings = (context, severity) => {
+	const findings = [];
+	visitSourceFile(context, (node) => {
+		const methodCall = getMethodCall(context.tsApi, node);
+		if (methodCall === void 0 || !recoveryMethods.has(methodCall.methodName)) return;
+		const receiverType = context.checker.getTypeAtLocation(methodCall.receiver);
+		const errorTypes = getFirstResultErrorTypes(context, methodCall.receiver, receiverType);
+		if (errorTypes.length === 0 || !errorTypes.every((errorType) => isNeverType(context.tsApi, errorType))) return;
+		findings.push(createFinding(context, methodCall.nameNode, "no-useless-recovery", severity, `\`${methodCall.methodName}\` cannot run because this Resultar value has \`never\` in the error channel.`));
+	});
+	return findings;
+};
+const getSourceFileResultarFindings = (tsApi, checker, sourceFile, options = {}) => {
+	const normalizedOptions = normalizeResultarRulesOptions(options);
+	const context = {
+		checker,
+		sourceFile,
+		tsApi
+	};
+	const findings = [];
+	const noDiscardSeverity = getRuleSeverity(normalizedOptions, "no-discard");
+	if (noDiscardSeverity !== void 0) findings.push(...getSourceFileNoDiscardFindings(tsApi, checker, sourceFile, { mode: normalizedOptions.noDiscardMode }).map((finding) => ({
+		...finding,
+		severity: noDiscardSeverity
+	})));
+	const noUnsafeAwaitSeverity = getRuleSeverity(normalizedOptions, "no-unsafe-await");
+	if (noUnsafeAwaitSeverity !== void 0) findings.push(...getNoUnsafeAwaitFindings(context, noUnsafeAwaitSeverity, normalizedOptions.noUnsafeAwaitMode));
+	const ruleFns = [
+		["prefer-map-err", getPreferMapErrFindings],
+		["prefer-and-then", getPreferAndThenFindings],
+		["typed-catch-mapper", getTypedCatchMapperFindings],
+		["no-try-catch-in-safe-try", getNoTryCatchInSafeTryFindings],
+		["yield-star-in-safe-try", getYieldStarInSafeTryFindings],
+		["unsafe-result-type-assertion", getUnsafeResultTypeAssertionFindings],
+		["prefer-tagged-error", getPreferTaggedErrorFindings],
+		["tagged-error-name-match", getTaggedErrorNameMatchFindings],
+		["no-tagged-error-constructor-override", getNoTaggedErrorConstructorOverrideFindings],
+		["no-useless-recovery", getNoUselessRecoveryFindings]
+	];
+	for (const [ruleName, ruleFn] of ruleFns) {
+		const severity = getRuleSeverity(normalizedOptions, ruleName);
+		if (severity !== void 0) findings.push(...ruleFn(context, severity));
+	}
+	return findings.toSorted((left, right) => left.start - right.start || left.rule.localeCompare(right.rule));
+};
+const getProgramResultarFindings = (tsApi, program, options = {}) => {
+	const checker = program.getTypeChecker();
+	const findings = [];
+	for (const sourceFile of program.getSourceFiles()) if (!sourceFile.isDeclarationFile && !sourceFile.fileName.includes("/node_modules/") && !sourceFile.fileName.includes("\\node_modules\\")) findings.push(...getSourceFileResultarFindings(tsApi, checker, sourceFile, options));
+	return findings;
+};
+//#endregion
+//#region src/plugin-options.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const isResultarPluginName = (value) => value === "resultar-check" || value === "resultar-lint";
+const parsePluginOptions = (config) => {
+	if (!isRecord$1(config)) return defaultResultarRulesOptions;
+	return {
+		noDiscard: normalizeRuleSeverity(config.noDiscard, defaultResultarRulesOptions.noDiscard),
+		noDiscardMode: normalizeNoDiscardMode(config.noDiscardMode),
+		noTaggedErrorConstructorOverride: normalizeRuleSeverity(config.noTaggedErrorConstructorOverride, defaultResultarRulesOptions.noTaggedErrorConstructorOverride),
+		noTryCatchInSafeTry: normalizeRuleSeverity(config.noTryCatchInSafeTry, defaultResultarRulesOptions.noTryCatchInSafeTry),
+		noUnsafeAwait: normalizeRuleSeverity(config.noUnsafeAwait, defaultResultarRulesOptions.noUnsafeAwait),
+		noUnsafeAwaitMode: normalizeNoUnsafeAwaitMode(config.noUnsafeAwaitMode),
+		noUselessRecovery: normalizeRuleSeverity(config.noUselessRecovery, defaultResultarRulesOptions.noUselessRecovery),
+		preferAndThen: normalizeRuleSeverity(config.preferAndThen, defaultResultarRulesOptions.preferAndThen),
+		preferMapErr: normalizeRuleSeverity(config.preferMapErr, defaultResultarRulesOptions.preferMapErr),
+		preferTaggedError: normalizeRuleSeverity(config.preferTaggedError, defaultResultarRulesOptions.preferTaggedError),
+		taggedErrorNameMatch: normalizeRuleSeverity(config.taggedErrorNameMatch, defaultResultarRulesOptions.taggedErrorNameMatch),
+		typedCatchMapper: normalizeRuleSeverity(config.typedCatchMapper, defaultResultarRulesOptions.typedCatchMapper),
+		unsafeResultTypeAssertion: normalizeRuleSeverity(config.unsafeResultTypeAssertion, defaultResultarRulesOptions.unsafeResultTypeAssertion),
+		yieldStarInSafeTry: normalizeRuleSeverity(config.yieldStarInSafeTry, defaultResultarRulesOptions.yieldStarInSafeTry)
+	};
+};
+const findResultarPluginConfig = (plugins) => {
+	const plugin = plugins?.find((entry) => isRecord$1(entry) && isResultarPluginName(entry.name));
+	return plugin === void 0 ? void 0 : parsePluginOptions(plugin);
+};
+//#endregion
+//#region src/lint.ts
+const usage = `Usage: resultar-check -p tsconfig.json --noEmit
+
+Flags:
+  --mode <direct|must-use>  Check mode. Defaults to tsconfig plugin noDiscardMode or must-use.
+  -p, --project <path>  TypeScript project file to inspect. Defaults to tsconfig.json.
+  -h, --help            Show this help message.
+
+Runs TypeScript 7 first, then all enabled Resultar rules from tsconfig plugin options.
+`;
+const failure = (error) => ({
+	error,
+	ok: false
+});
+const success = (findings) => ({
+	findings,
+	ok: true
+});
+const cliError = (message) => failure(new Error(message));
+const requireFromPackage = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const isTypeScript7Version = (version) => version.startsWith("7.");
+const resolvePackageFromRoot = (rootDir, specifier) => {
+	const requireFromRoot = (0, node_module.createRequire)((0, node_path.resolve)(rootDir, "package.json"));
+	try {
+		return requireFromRoot.resolve(specifier);
+	} catch {
+		return requireFromPackage.resolve(specifier);
+	}
+};
+const readPackageVersion = (packageJson) => {
+	const parsed = JSON.parse((0, node_fs.readFileSync)(packageJson, "utf8"));
+	if (!isRecord(parsed) || typeof parsed.version !== "string") throw new TypeError(`Unable to read package version from ${packageJson}`);
+	return parsed.version;
+};
+const resolveOptionalPackage = (rootDir, specifier) => {
+	try {
+		return resolvePackageFromRoot(rootDir, specifier);
+	} catch {
+		return;
+	}
+};
+const resolveTypeScript7PackageJson = (rootDir) => {
+	for (const candidate of ["typescript/package.json", "typescript-7/package.json"]) {
+		const packageJson = resolveOptionalPackage(rootDir, candidate);
+		if (packageJson !== void 0 && isTypeScript7Version(readPackageVersion(packageJson))) return {
+			ok: true,
+			packageJson
+		};
+	}
+	return failure(/* @__PURE__ */ new Error("Unable to resolve TypeScript 7. Install typescript@rc or typescript-7@npm:typescript@rc in this project."));
+};
+const parseCheckArgs = (args) => {
+	let mode = void 0;
+	let project = void 0;
+	let help = false;
+	const tscArgs = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === void 0 || arg === "") continue;
+		if (arg === "--help" || arg === "-h") {
+			help = true;
+			continue;
+		}
+		if (arg === "--mode") {
+			const nextArg = args[index + 1];
+			if (nextArg === void 0 || nextArg === "") return cliError("--mode requires direct or must-use");
+			if (nextArg !== "direct" && nextArg !== "must-use") return cliError(`Unknown --mode value: ${nextArg}`);
+			mode = nextArg;
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--mode=")) {
+			const nextMode = arg.slice(7);
+			if (nextMode !== "direct" && nextMode !== "must-use") return cliError(`Unknown --mode value: ${nextMode}`);
+			mode = nextMode;
+			continue;
+		}
+		if (arg === "--project" || arg === "-p") {
+			const nextArg = args[index + 1];
+			if (nextArg === void 0 || nextArg === "") return cliError(`${arg} requires a path`);
+			project = nextArg;
+			tscArgs.push(arg, nextArg);
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--project=")) project = arg.slice(10);
+		tscArgs.push(arg);
+	}
+	if (project === "") return cliError("--project requires a path");
+	if (project === void 0) return {
+		ok: true,
+		options: mode === void 0 ? {
+			help,
+			tscArgs
+		} : {
+			help,
+			mode,
+			tscArgs
+		}
+	};
+	return {
+		ok: true,
+		options: mode === void 0 ? {
+			help,
+			project,
+			tscArgs
+		} : {
+			help,
+			mode,
+			project,
+			tscArgs
+		}
+	};
+};
+const readProject = (tsApi, projectPath) => {
+	const formatHost = {
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => process.cwd(),
+		getNewLine: () => "\n"
+	};
+	const config = tsApi.readConfigFile(projectPath, (fileName) => tsApi.sys.readFile(fileName));
+	if (config.error) return failure(new Error(tsApi.formatDiagnosticsWithColorAndContext([config.error], formatHost)));
+	const parsed = tsApi.parseJsonConfigFileContent(config.config, tsApi.sys, (0, node_path.resolve)(projectPath, ".."), void 0, projectPath);
+	if (parsed.errors.length > 0) return failure(new Error(tsApi.formatDiagnosticsWithColorAndContext(parsed.errors, formatHost)));
+	return {
+		config: config.config,
+		ok: true,
+		parsed
+	};
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const getProjectRuleOptions = (config) => {
+	if (!isRecord(config) || !isRecord(config.compilerOptions)) return;
+	const { plugins } = config.compilerOptions;
+	if (!Array.isArray(plugins)) return;
+	return findResultarPluginConfig(plugins);
+};
+const resolveTypeScriptApi = (_rootDir) => {
+	try {
+		return {
+			ok: true,
+			tsApi: requireFromPackage("typescript")
+		};
+	} catch {
+		return failure(/* @__PURE__ */ new Error("Unable to resolve the internal TypeScript diagnostics API bundled with resultar-check."));
+	}
+};
+const findResultarLintFindings = (options = {}) => {
+	const rootDir = (0, node_path.resolve)(options.rootDir ?? process.cwd());
+	const projectPath = (0, node_path.resolve)(rootDir, options.project ?? "tsconfig.json");
+	const resolvedTypeScript = resolveTypeScriptApi(rootDir);
+	if (!resolvedTypeScript.ok) return resolvedTypeScript;
+	const { tsApi } = resolvedTypeScript;
+	const project = readProject(tsApi, projectPath);
+	if (!project.ok) return project;
+	const projectRuleOptions = getProjectRuleOptions(project.config);
+	return success(getProgramResultarFindings(tsApi, tsApi.createProgram(project.parsed.fileNames, project.parsed.options), {
+		...projectRuleOptions,
+		...options.rules,
+		noDiscardMode: normalizeNoDiscardMode(options.mode ?? options.rules?.noDiscardMode ?? projectRuleOptions?.noDiscardMode)
+	}));
+};
+const formatFinding = (finding, rootDir) => {
+	return [`${(0, node_path.relative)(rootDir, finding.file)}:${finding.line}:${finding.column} resultar/${finding.rule}`, finding.message].join(" - ");
+};
+const passthroughArgs = new Set(["--version", "-v"]);
+const shouldSkipResultarDiagnostics = (args) => args.some((arg) => passthroughArgs.has(arg));
+const runNode = (script, args) => {
+	const result = (0, node_child_process.spawnSync)(process.execPath, [script, ...args], { stdio: "inherit" });
+	if (result.error !== void 0) throw result.error;
+	return result.status ?? 1;
+};
+const runResultarCheckCli = (args = process.argv.slice(2)) => {
+	const rootDir = process.cwd();
+	const parsedArgs = parseCheckArgs(args);
+	if (!parsedArgs.ok) {
+		process.stderr.write(`${parsedArgs.error.message}\n`);
+		return 1;
+	}
+	if (parsedArgs.options.help) {
+		process.stdout.write(usage);
+		return 0;
+	}
+	const resolvedTypeScript = resolveTypeScript7PackageJson(rootDir);
+	if (!resolvedTypeScript.ok) {
+		process.stderr.write(`${resolvedTypeScript.error.message}\n`);
+		return 1;
+	}
+	const tscStatus = runNode((0, node_path.join)((0, node_path.dirname)(resolvedTypeScript.packageJson), "bin/tsc"), [...parsedArgs.options.tscArgs]);
+	if (tscStatus !== 0 || shouldSkipResultarDiagnostics(args)) return tscStatus;
+	const result = parsedArgs.options.project === void 0 ? findResultarLintFindings({
+		mode: parsedArgs.options.mode,
+		rootDir
+	}) : findResultarLintFindings({
+		mode: parsedArgs.options.mode,
+		project: parsedArgs.options.project,
+		rootDir
+	});
+	if (!result.ok) {
+		process.stderr.write(`${result.error.message}\n`);
+		return 1;
+	}
+	if (result.findings.length === 0) return 0;
+	process.stderr.write(`${result.findings.map((finding) => formatFinding(finding, rootDir)).join("\n")}\n`);
+	return 1;
+};
+//#endregion
+Object.defineProperty(exports, "findResultarLintFindings", {
+	enumerable: true,
+	get: function() {
+		return findResultarLintFindings;
+	}
+});
+Object.defineProperty(exports, "getSourceFileResultarFindings", {
+	enumerable: true,
+	get: function() {
+		return getSourceFileResultarFindings;
+	}
+});
+Object.defineProperty(exports, "normalizeResultarRulesOptions", {
+	enumerable: true,
+	get: function() {
+		return normalizeResultarRulesOptions;
+	}
+});
+Object.defineProperty(exports, "parsePluginOptions", {
+	enumerable: true,
+	get: function() {
+		return parsePluginOptions;
+	}
+});
+Object.defineProperty(exports, "runResultarCheckCli", {
+	enumerable: true,
+	get: function() {
+		return runResultarCheckCli;
+	}
+});
+
+//# sourceMappingURL=lint-D-D2dmLi.cjs.map