@alint-js/core 0.0.28 → 0.0.29

package/dist/agent.d.mts

@@ -1,4 +1,4 @@
-import { J as AgentResult, K as AgentAdapter, X as AgentUsage, Y as AgentTool, q as AgentRequest, v as RuleContext } from "./types-BM_nUu_Z.mjs";
+import { A as AgentTool, D as AgentAdapter, O as AgentRequest, j as AgentUsage, k as AgentResult, v as RuleContext } from "./types-CMLoj9J9.mjs";
 //#region src/agent/retry.d.ts
 /**
  * Declares that the complete adapter invocation can be safely replayed.

package/dist/extract-CIWssxNK.mjs

@@ -0,0 +1,358 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { clamp } from "es-toolkit";
+import { parseSync } from "oxc-parser";
+//#region src/core/source/runtime.ts
+function createSourceFile(path, text) {
+	return {
+		language: inferLanguage(path),
+		lines: text.split(/\r?\n/),
+		path,
+		text
+	};
+}
+function createSourceRuntime() {
+	return {
+		getText,
+		readFile: async (filePath) => createSourceFile(filePath, await readFile(filePath, "utf8")),
+		sliceLines,
+		sliceRange
+	};
+}
+function getText(target) {
+	return target.text;
+}
+function sliceLines(file, range) {
+	const startLine = clampLine(range.startLine, file.lines.length);
+	const endLine = clampLine(range.endLine, file.lines.length);
+	const orderedStartLine = Math.min(startLine, endLine);
+	const orderedEndLine = Math.max(startLine, endLine);
+	const text = file.lines.slice(orderedStartLine - 1, orderedEndLine).join("\n");
+	return {
+		filePath: file.path,
+		loc: {
+			end: {
+				column: file.lines[orderedEndLine - 1]?.length ?? 0,
+				line: orderedEndLine
+			},
+			start: {
+				column: 0,
+				line: orderedStartLine
+			}
+		},
+		text
+	};
+}
+function sliceRange(file, range) {
+	const start = clampOffset(range.start, file.text.length);
+	const end = clampOffset(range.end, file.text.length);
+	const orderedStart = Math.min(start, end);
+	const orderedEnd = Math.max(start, end);
+	return {
+		filePath: file.path,
+		loc: {
+			end: getPosition(file.text, orderedEnd),
+			start: getPosition(file.text, orderedStart)
+		},
+		text: file.text.slice(orderedStart, orderedEnd)
+	};
+}
+function clampLine(line, lineCount) {
+	if (lineCount === 0) return 1;
+	return clamp(Math.trunc(line), 1, lineCount);
+}
+function clampOffset(offset, textLength) {
+	return clamp(Math.trunc(offset), 0, textLength);
+}
+function getPosition(text, offset) {
+	let line = 1;
+	let column = 0;
+	let index = 0;
+	while (index < offset) {
+		const character = text[index];
+		if (character === "\r") {
+			if (text[index + 1] === "\n" && index + 1 < offset) index += 1;
+			line += 1;
+			column = 0;
+		} else if (character === "\n") {
+			line += 1;
+			column = 0;
+		} else column += 1;
+		index += 1;
+	}
+	return {
+		column,
+		line
+	};
+}
+function inferLanguage(path) {
+	switch (extname(path)) {
+		case ".cjs":
+		case ".js":
+		case ".jsx":
+		case ".mjs": return "javascript";
+		case ".cts":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "typescript";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/core/languages/js/parser.ts
+function parseSync$1(filename, sourceText, options) {
+	return parseSync(filename, sourceText, options);
+}
+//#endregion
+//#region src/core/languages/js/extract.ts
+function extractJsSourceTargets(file) {
+	const result = parseSync$1(file.path, file.text, { sourceType: "module" });
+	const state = {
+		bindingNodes: /* @__PURE__ */ new Map(),
+		exportedNodes: /* @__PURE__ */ new Set(),
+		file,
+		inferredNames: /* @__PURE__ */ new Map(),
+		seenClasses: /* @__PURE__ */ new Set(),
+		seenFunctions: /* @__PURE__ */ new Set(),
+		targets: [],
+		visited: /* @__PURE__ */ new Set()
+	};
+	collectModuleBindings(result.program, state);
+	collectExportedBindings(result.program, state);
+	visit(result.program, state);
+	const sortedTargets = [...state.targets].sort((left, right) => (left.range?.start ?? 0) - (right.range?.start ?? 0));
+	return [createFileTarget(file), ...withStableIdentities(sortedTargets)];
+}
+function addClassTarget(node, state) {
+	if (state.seenClasses.has(node)) return;
+	const target = createClassTarget(node, state);
+	if (!target) return;
+	state.seenClasses.add(node);
+	state.targets.push(target);
+}
+function addFunctionTarget(node, state) {
+	if (state.seenFunctions.has(node)) return;
+	const target = createFunctionTarget(node, state);
+	if (!target) return;
+	state.seenFunctions.add(node);
+	state.targets.push(target);
+}
+function asAstNode(value) {
+	return isAstNode(value) ? value : void 0;
+}
+function collectDeclarationBindings(node, state) {
+	const name = getNodeName(node);
+	if (name && (isClassNode(node) || isFunctionNode(node))) {
+		state.bindingNodes.set(name, node);
+		return;
+	}
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const id = asAstNode(declarator.id);
+		const initializer = asAstNode(declarator.init);
+		if (typeof id?.name === "string" && initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.bindingNodes.set(id.name, initializer);
+	}
+}
+function collectExportedBindings(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectExportedBindings(child, state);
+		return;
+	}
+	if (node.type === "ExportNamedDeclaration" && !node.source && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+		if (!isAstNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+		const local = asAstNode(specifier.local);
+		if (typeof local?.name === "string") markExportedBinding(local.name, state);
+	}
+	else if (node.type === "ExportDefaultDeclaration") {
+		const declaration = asAstNode(node.declaration);
+		if (typeof declaration?.name === "string") markExportedBinding(declaration.name, state);
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) collectExportedBindings(value.filter(isAstNode), state);
+	else if (isAstNode(value)) collectExportedBindings(value, state);
+}
+function collectModuleBindings(program, state) {
+	if (!Array.isArray(program.body)) return;
+	for (const statement of program.body) {
+		if (!isAstNode(statement)) continue;
+		const declaration = isExportDeclaration(statement) ? asAstNode(statement.declaration) : statement;
+		if (declaration) collectDeclarationBindings(declaration, state);
+	}
+}
+function createClassTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const name = getNodeName(node) ?? state.inferredNames.get(node);
+	return {
+		file: state.file,
+		identity: createRangeIdentity("class", name, range),
+		kind: "class",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: { exported: isExportedTarget(node, state) },
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function createFileTarget(file) {
+	return {
+		file,
+		identity: "file",
+		kind: "file",
+		language: file.language,
+		origin: { physicalPath: file.path },
+		text: file.text
+	};
+}
+function createFunctionTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
+	const name = getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node);
+	return {
+		file: state.file,
+		identity: createRangeIdentity("function", name, range),
+		kind: "function",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: {
+			async: functionNode?.async === true,
+			exported: isExportedTarget(node, state)
+		},
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function createRangeIdentity(kind, name, range) {
+	return `${kind}:${name ?? "anonymous"}:${range.start}:${range.end}`;
+}
+function createSemanticIdentity(target) {
+	if (target.kind !== "class" && target.kind !== "function" || !target.name) return;
+	return `${target.kind}:${target.name}`;
+}
+function getNodeName(node) {
+	if (!node) return;
+	if (typeof node.name === "string") return node.name;
+	const id = asAstNode(node.id);
+	if (typeof id?.name === "string") return id.name;
+	const key = asAstNode(node.key);
+	if (typeof key?.name === "string") return key.name;
+	if (typeof key?.value === "string" || typeof key?.value === "number") return String(key.value);
+}
+function getRange(node) {
+	if (typeof node.start === "number" && typeof node.end === "number") return {
+		end: node.end,
+		start: node.start
+	};
+	if (Array.isArray(node.range) && node.range.length === 2) return {
+		end: node.range[1],
+		start: node.range[0]
+	};
+}
+function inferChildName(parent, key, child, state) {
+	if (state.inferredNames.has(child)) return;
+	if (parent.type === "VariableDeclarator" && key === "init") {
+		const id = asAstNode(parent.id);
+		if (typeof id?.name === "string") state.inferredNames.set(child, id.name);
+	}
+	if (parent.type === "Property" && key === "value") {
+		const name = getNodeName(parent);
+		if (name) state.inferredNames.set(child, name);
+	}
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isClassNode(node) {
+	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+function isExportDeclaration(node) {
+	return node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
+}
+function isExportedTarget(node, state) {
+	return state.exportedNodes.has(node);
+}
+function isFunctionNode(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function markExportedBinding(name, state) {
+	const bindingNode = state.bindingNodes.get(name);
+	if (bindingNode) state.exportedNodes.add(bindingNode);
+}
+function markExportedDeclaration(node, state) {
+	state.exportedNodes.add(node);
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const initializer = asAstNode(declarator.init);
+		if (initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.exportedNodes.add(initializer);
+	}
+}
+function visit(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) visit(child, state);
+		return;
+	}
+	if (state.visited.has(node)) return;
+	state.visited.add(node);
+	if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			markExportedDeclaration(node.declaration, state);
+			visit(node.declaration, state);
+		}
+		visitChildren(node, state, /* @__PURE__ */ new Set(["declaration"]));
+		return;
+	}
+	if (isClassNode(node)) addClassTarget(node, state);
+	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
+		addFunctionTarget(node, state);
+		const methodValue = node.type === "MethodDefinition" ? asAstNode(node.value) : void 0;
+		if (methodValue) state.seenFunctions.add(methodValue);
+	}
+	visitChildren(node, state);
+}
+function visitChildren(node, state, skippedKeys = /* @__PURE__ */ new Set()) {
+	for (const [key, value] of Object.entries(node)) {
+		if (skippedKeys.has(key) || key === "type" || key === "start" || key === "end" || key === "range") continue;
+		if (Array.isArray(value)) {
+			for (const child of value) if (isAstNode(child)) {
+				inferChildName(node, key, child, state);
+				visit(child, state);
+			}
+		} else if (isAstNode(value)) {
+			inferChildName(node, key, value, state);
+			visit(value, state);
+		}
+	}
+}
+function withStableIdentities(targets) {
+	const semanticIdentityCounts = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		const semanticIdentity = createSemanticIdentity(target);
+		if (semanticIdentity) semanticIdentityCounts.set(semanticIdentity, (semanticIdentityCounts.get(semanticIdentity) ?? 0) + 1);
+	}
+	return targets.map((target) => {
+		const semanticIdentity = createSemanticIdentity(target);
+		if (!semanticIdentity || semanticIdentityCounts.get(semanticIdentity) !== 1) return target;
+		return {
+			...target,
+			identity: semanticIdentity
+		};
+	});
+}
+//#endregion
+export { sliceRange as a, sliceLines as i, createSourceFile as n, createSourceRuntime as r, extractJsSourceTargets as t };

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { $ as ResolvedModel, A as LanguageContext, B as SourceRuntime, C as RuleSeverity, D as ClassTarget, E as Target, F as ProcessorPostprocessContext, G as SourceText, H as SourceTargetKind, I as SourceFile, L as SourceLocation, M as ProcessedSource, N as ProcessedSourceOrigin, O as FileTarget, P as ProcessorContext, Q as ResolveModelOptions, R as SourcePosition, S as RuleRegistry, T as RuleWithHandler, U as SourceTargetOfKind, V as SourceTarget, W as SourceTargetOrigin, Z as ModelRequirement, _ as RuleConfigEntry, a as AlintLinterOptions, at as RunnerStatsConfig, b as RuleHandlers, c as DiagnosticLocation, d as IgnoreConfig, et as ResolvedProvider, f as LanguageDefinition, g as RuleCacheConfig, h as ProjectTarget, i as AlintConfigItem, it as RunnerConfig, j as LineRange, k as FunctionTarget, l as DirectoryTarget, m as ProcessorDefinition, n as AlintConfigExtends, nt as ProviderDefinition, o as Awaitable, ot as SetupConfig, p as PluginDefinition, r as AlintConfigInput, rt as ProviderType, s as DiagnosticDescriptor, st as SetupModelDefinition, t as AlintConfig, tt as ModelSize, u as EnabledRule, v as RuleContext, w as RuleSpecializedHandlers, x as RuleInferenceUsageRecord, y as RuleDefinition, z as SourceRange } from "./types-BM_nUu_Z.mjs";
+import { B as RunnerStatsConfig, C as RuleSeverity, E as Target, F as ResolvedProvider, H as SetupModelDefinition, I as ModelSize, L as ProviderDefinition, M as ModelRequirement, N as ResolveModelOptions, P as ResolvedModel, R as ProviderType, S as RuleRegistry, T as RuleWithHandler, V as SetupConfig, _ as RuleConfigEntry, a as AlintLinterOptions, b as RuleHandlers, c as DiagnosticLocation, d as IgnoreConfig, f as LanguageDefinition, g as RuleCacheConfig, h as ProjectTarget, i as AlintConfigItem, l as DirectoryTarget, m as ProcessorDefinition, n as AlintConfigExtends, o as Awaitable, p as PluginDefinition, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as EnabledRule, v as RuleContext, w as RuleSpecializedHandlers, x as RuleInferenceUsageRecord, y as RuleDefinition, z as RunnerConfig } from "./types-CMLoj9J9.mjs";
+import { _ as SourceTargetOfKind, a as LineRange, c as ProcessorContext, d as SourceLocation, f as SourcePosition, g as SourceTargetKind, h as SourceTarget, i as LanguageContext, l as ProcessorPostprocessContext, m as SourceRuntime, n as FileTarget, o as ProcessedSource, p as SourceRange, r as FunctionTarget, s as ProcessedSourceOrigin, t as ClassTarget, u as SourceFile, v as SourceTargetOrigin, y as SourceText } from "./types-DSvXUVZ7.mjs";
 //#region src/config/config-array.d.ts
 interface EffectiveAlintConfig {
   agent?: AlintConfigItem['agent'];
@@ -47,9 +48,6 @@ declare function resolveLanguage(file: SourceFile, registry: LanguageRegistry, o
 //#region src/core/languages/index.d.ts
 declare function createBuiltInLanguageRegistry(): LanguageRegistry;
 //#endregion
-//#region src/core/languages/js/extract.d.ts
-declare function extractJsSourceTargets(file: SourceFile): SourceTarget[];
-//#endregion
 //#region src/core/types.d.ts
 interface AlintRunFailure {
   filePath?: string;
@@ -251,4 +249,4 @@ declare function buildRuleRegistry(config: Pick<EffectiveAlintConfig, 'plugins'
 //#region src/models/resolve.d.ts
 declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
 //#endregion
-export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type AlintRunFailure, type Awaitable, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type FileTarget, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProjectTarget, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleStartPayload, type RuleWithHandler, type RunEndPayload, type RunExecution, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type AlintRunFailure, type Awaitable, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type FileTarget, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProjectTarget, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleStartPayload, type RuleWithHandler, type RunEndPayload, type RunExecution, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };

package/dist/index.mjs

@@ -1,10 +1,9 @@
 import { r as withAgentRetry } from "./retry-C4sGjSE5.mjs";
+import { a as sliceRange, i as sliceLines, n as createSourceFile, r as createSourceRuntime, t as extractJsSourceTargets } from "./extract-CIWssxNK.mjs";
 import { minimatch } from "minimatch";
 import { isAbsolute, relative, resolve } from "pathe";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, extname, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
-import { clamp } from "es-toolkit";
-import { parseSync } from "oxc-parser";
 import { AsyncLocalStorage } from "node:async_hooks";
 import process, { cwd } from "node:process";
 import { errorCauseFrom, errorMessageFrom } from "@moeru/std/error";
@@ -233,359 +232,6 @@ function withExpansionMetadata(item, inheritedMatcherScopes, effectiveBasePath)
 	return item;
 }
 //#endregion
-//#region src/core/source/runtime.ts
-function createSourceFile(path, text) {
-	return {
-		language: inferLanguage(path),
-		lines: text.split(/\r?\n/),
-		path,
-		text
-	};
-}
-function createSourceRuntime() {
-	return {
-		getText,
-		readFile: async (filePath) => createSourceFile(filePath, await readFile(filePath, "utf8")),
-		sliceLines,
-		sliceRange
-	};
-}
-function getText(target) {
-	return target.text;
-}
-function sliceLines(file, range) {
-	const startLine = clampLine(range.startLine, file.lines.length);
-	const endLine = clampLine(range.endLine, file.lines.length);
-	const orderedStartLine = Math.min(startLine, endLine);
-	const orderedEndLine = Math.max(startLine, endLine);
-	const text = file.lines.slice(orderedStartLine - 1, orderedEndLine).join("\n");
-	return {
-		filePath: file.path,
-		loc: {
-			end: {
-				column: file.lines[orderedEndLine - 1]?.length ?? 0,
-				line: orderedEndLine
-			},
-			start: {
-				column: 0,
-				line: orderedStartLine
-			}
-		},
-		text
-	};
-}
-function sliceRange(file, range) {
-	const start = clampOffset(range.start, file.text.length);
-	const end = clampOffset(range.end, file.text.length);
-	const orderedStart = Math.min(start, end);
-	const orderedEnd = Math.max(start, end);
-	return {
-		filePath: file.path,
-		loc: {
-			end: getPosition(file.text, orderedEnd),
-			start: getPosition(file.text, orderedStart)
-		},
-		text: file.text.slice(orderedStart, orderedEnd)
-	};
-}
-function clampLine(line, lineCount) {
-	if (lineCount === 0) return 1;
-	return clamp(Math.trunc(line), 1, lineCount);
-}
-function clampOffset(offset, textLength) {
-	return clamp(Math.trunc(offset), 0, textLength);
-}
-function getPosition(text, offset) {
-	let line = 1;
-	let column = 0;
-	let index = 0;
-	while (index < offset) {
-		const character = text[index];
-		if (character === "\r") {
-			if (text[index + 1] === "\n" && index + 1 < offset) index += 1;
-			line += 1;
-			column = 0;
-		} else if (character === "\n") {
-			line += 1;
-			column = 0;
-		} else column += 1;
-		index += 1;
-	}
-	return {
-		column,
-		line
-	};
-}
-function inferLanguage(path) {
-	switch (extname(path)) {
-		case ".cjs":
-		case ".js":
-		case ".jsx":
-		case ".mjs": return "javascript";
-		case ".cts":
-		case ".mts":
-		case ".ts":
-		case ".tsx": return "typescript";
-		default: return "unknown";
-	}
-}
-//#endregion
-//#region src/core/languages/js/parser.ts
-function parseSync$1(filename, sourceText, options) {
-	return parseSync(filename, sourceText, options);
-}
-//#endregion
-//#region src/core/languages/js/extract.ts
-function extractJsSourceTargets(file) {
-	const result = parseSync$1(file.path, file.text, { sourceType: "module" });
-	const state = {
-		bindingNodes: /* @__PURE__ */ new Map(),
-		exportedNodes: /* @__PURE__ */ new Set(),
-		file,
-		inferredNames: /* @__PURE__ */ new Map(),
-		seenClasses: /* @__PURE__ */ new Set(),
-		seenFunctions: /* @__PURE__ */ new Set(),
-		targets: [],
-		visited: /* @__PURE__ */ new Set()
-	};
-	collectModuleBindings(result.program, state);
-	collectExportedBindings(result.program, state);
-	visit(result.program, state);
-	const sortedTargets = [...state.targets].sort((left, right) => (left.range?.start ?? 0) - (right.range?.start ?? 0));
-	return [createFileTarget(file), ...withStableIdentities(sortedTargets)];
-}
-function addClassTarget(node, state) {
-	if (state.seenClasses.has(node)) return;
-	const target = createClassTarget(node, state);
-	if (!target) return;
-	state.seenClasses.add(node);
-	state.targets.push(target);
-}
-function addFunctionTarget(node, state) {
-	if (state.seenFunctions.has(node)) return;
-	const target = createFunctionTarget(node, state);
-	if (!target) return;
-	state.seenFunctions.add(node);
-	state.targets.push(target);
-}
-function asAstNode(value) {
-	return isAstNode(value) ? value : void 0;
-}
-function collectDeclarationBindings(node, state) {
-	const name = getNodeName(node);
-	if (name && (isClassNode(node) || isFunctionNode(node))) {
-		state.bindingNodes.set(name, node);
-		return;
-	}
-	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
-	for (const declarator of node.declarations) {
-		if (!isAstNode(declarator)) continue;
-		const id = asAstNode(declarator.id);
-		const initializer = asAstNode(declarator.init);
-		if (typeof id?.name === "string" && initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.bindingNodes.set(id.name, initializer);
-	}
-}
-function collectExportedBindings(node, state) {
-	if (!node) return;
-	if (Array.isArray(node)) {
-		for (const child of node) collectExportedBindings(child, state);
-		return;
-	}
-	if (node.type === "ExportNamedDeclaration" && !node.source && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
-		if (!isAstNode(specifier) || specifier.type !== "ExportSpecifier") continue;
-		const local = asAstNode(specifier.local);
-		if (typeof local?.name === "string") markExportedBinding(local.name, state);
-	}
-	else if (node.type === "ExportDefaultDeclaration") {
-		const declaration = asAstNode(node.declaration);
-		if (typeof declaration?.name === "string") markExportedBinding(declaration.name, state);
-	}
-	for (const value of Object.values(node)) if (Array.isArray(value)) collectExportedBindings(value.filter(isAstNode), state);
-	else if (isAstNode(value)) collectExportedBindings(value, state);
-}
-function collectModuleBindings(program, state) {
-	if (!Array.isArray(program.body)) return;
-	for (const statement of program.body) {
-		if (!isAstNode(statement)) continue;
-		const declaration = isExportDeclaration(statement) ? asAstNode(statement.declaration) : statement;
-		if (declaration) collectDeclarationBindings(declaration, state);
-	}
-}
-function createClassTarget(node, state) {
-	const range = getRange(node);
-	if (!range) return;
-	const source = sliceRange(state.file, range);
-	const name = getNodeName(node) ?? state.inferredNames.get(node);
-	return {
-		file: state.file,
-		identity: createRangeIdentity("class", name, range),
-		kind: "class",
-		language: state.file.language,
-		loc: source.loc,
-		metadata: { exported: isExportedTarget(node, state) },
-		name,
-		origin: {
-			physicalPath: state.file.path,
-			range
-		},
-		range,
-		text: source.text
-	};
-}
-function createFileTarget(file) {
-	return {
-		file,
-		identity: "file",
-		kind: "file",
-		language: file.language,
-		origin: { physicalPath: file.path },
-		text: file.text
-	};
-}
-function createFunctionTarget(node, state) {
-	const range = getRange(node);
-	if (!range) return;
-	const source = sliceRange(state.file, range);
-	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
-	const name = getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node);
-	return {
-		file: state.file,
-		identity: createRangeIdentity("function", name, range),
-		kind: "function",
-		language: state.file.language,
-		loc: source.loc,
-		metadata: {
-			async: functionNode?.async === true,
-			exported: isExportedTarget(node, state)
-		},
-		name,
-		origin: {
-			physicalPath: state.file.path,
-			range
-		},
-		range,
-		text: source.text
-	};
-}
-function createRangeIdentity(kind, name, range) {
-	return `${kind}:${name ?? "anonymous"}:${range.start}:${range.end}`;
-}
-function createSemanticIdentity(target) {
-	if (target.kind !== "class" && target.kind !== "function" || !target.name) return;
-	return `${target.kind}:${target.name}`;
-}
-function getNodeName(node) {
-	if (!node) return;
-	if (typeof node.name === "string") return node.name;
-	const id = asAstNode(node.id);
-	if (typeof id?.name === "string") return id.name;
-	const key = asAstNode(node.key);
-	if (typeof key?.name === "string") return key.name;
-	if (typeof key?.value === "string" || typeof key?.value === "number") return String(key.value);
-}
-function getRange(node) {
-	if (typeof node.start === "number" && typeof node.end === "number") return {
-		end: node.end,
-		start: node.start
-	};
-	if (Array.isArray(node.range) && node.range.length === 2) return {
-		end: node.range[1],
-		start: node.range[0]
-	};
-}
-function inferChildName(parent, key, child, state) {
-	if (state.inferredNames.has(child)) return;
-	if (parent.type === "VariableDeclarator" && key === "init") {
-		const id = asAstNode(parent.id);
-		if (typeof id?.name === "string") state.inferredNames.set(child, id.name);
-	}
-	if (parent.type === "Property" && key === "value") {
-		const name = getNodeName(parent);
-		if (name) state.inferredNames.set(child, name);
-	}
-}
-function isAstNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function isClassNode(node) {
-	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
-}
-function isExportDeclaration(node) {
-	return node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
-}
-function isExportedTarget(node, state) {
-	return state.exportedNodes.has(node);
-}
-function isFunctionNode(node) {
-	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
-}
-function markExportedBinding(name, state) {
-	const bindingNode = state.bindingNodes.get(name);
-	if (bindingNode) state.exportedNodes.add(bindingNode);
-}
-function markExportedDeclaration(node, state) {
-	state.exportedNodes.add(node);
-	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
-	for (const declarator of node.declarations) {
-		if (!isAstNode(declarator)) continue;
-		const initializer = asAstNode(declarator.init);
-		if (initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.exportedNodes.add(initializer);
-	}
-}
-function visit(node, state) {
-	if (!node) return;
-	if (Array.isArray(node)) {
-		for (const child of node) visit(child, state);
-		return;
-	}
-	if (state.visited.has(node)) return;
-	state.visited.add(node);
-	if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
-		if (node.declaration) {
-			markExportedDeclaration(node.declaration, state);
-			visit(node.declaration, state);
-		}
-		visitChildren(node, state, /* @__PURE__ */ new Set(["declaration"]));
-		return;
-	}
-	if (isClassNode(node)) addClassTarget(node, state);
-	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
-		addFunctionTarget(node, state);
-		const methodValue = node.type === "MethodDefinition" ? asAstNode(node.value) : void 0;
-		if (methodValue) state.seenFunctions.add(methodValue);
-	}
-	visitChildren(node, state);
-}
-function visitChildren(node, state, skippedKeys = /* @__PURE__ */ new Set()) {
-	for (const [key, value] of Object.entries(node)) {
-		if (skippedKeys.has(key) || key === "type" || key === "start" || key === "end" || key === "range") continue;
-		if (Array.isArray(value)) {
-			for (const child of value) if (isAstNode(child)) {
-				inferChildName(node, key, child, state);
-				visit(child, state);
-			}
-		} else if (isAstNode(value)) {
-			inferChildName(node, key, value, state);
-			visit(value, state);
-		}
-	}
-}
-function withStableIdentities(targets) {
-	const semanticIdentityCounts = /* @__PURE__ */ new Map();
-	for (const target of targets) {
-		const semanticIdentity = createSemanticIdentity(target);
-		if (semanticIdentity) semanticIdentityCounts.set(semanticIdentity, (semanticIdentityCounts.get(semanticIdentity) ?? 0) + 1);
-	}
-	return targets.map((target) => {
-		const semanticIdentity = createSemanticIdentity(target);
-		if (!semanticIdentity || semanticIdentityCounts.get(semanticIdentity) !== 1) return target;
-		return {
-			...target,
-			identity: semanticIdentity
-		};
-	});
-}
-//#endregion
 //#region src/core/languages/js/index.ts
 const javascriptLanguage = {
 	extensions: [
@@ -968,7 +614,7 @@ function createDirectoryExecutionPlans(directories, fileOffset) {
 }
 //#endregion
 //#region package.json
-var version = "0.0.28";
+var version = "0.0.29";
 //#endregion
 //#region src/core/targets/execution.ts
 var AlintRuleExecutionError = class extends Error {
@@ -1879,4 +1525,4 @@ function defineRule(rule) {
 	return rule;
 }
 //#endregion
-export { AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };

package/dist/languages-js.d.mts

@@ -0,0 +1,5 @@
+import { h as SourceTarget, u as SourceFile } from "./types-DSvXUVZ7.mjs";
+//#region src/core/languages/js/extract.d.ts
+declare function extractJsSourceTargets(file: SourceFile): SourceTarget[];
+//#endregion
+export { extractJsSourceTargets };

package/dist/languages-js.mjs

@@ -0,0 +1,2 @@
+import { t as extractJsSourceTargets } from "./extract-CIWssxNK.mjs";
+export { extractJsSourceTargets };

package/dist/structured-output.d.mts

@@ -1,4 +1,4 @@
-import { $ as ResolvedModel, v as RuleContext } from "./types-BM_nUu_Z.mjs";
+import { P as ResolvedModel, v as RuleContext } from "./types-CMLoj9J9.mjs";
 import { GenericSchema, InferOutput } from "valibot";
 import { JsonSchema } from "@valibot/to-json-schema";
 import { Message } from "@xsai/shared-chat";

package/dist/{types-BM_nUu_Z.d.mts → types-CMLoj9J9.d.mts}

@@ -1,3 +1,4 @@
+import { c as ProcessorContext, h as SourceTarget, i as LanguageContext, l as ProcessorPostprocessContext, m as SourceRuntime, n as FileTarget, o as ProcessedSource, r as FunctionTarget, t as ClassTarget, u as SourceFile } from "./types-DSvXUVZ7.mjs";
 //#region src/config/types.d.ts
 type ModelSize = 'large' | 'medium' | 'small';
 interface ProviderDefinition {
@@ -96,91 +97,6 @@ interface AgentUsage {
   totalTokens?: number;
 }
 //#endregion
-//#region src/core/source/types.d.ts
-type ClassTarget = SourceTargetOfKind<'class'>;
-type FileTarget = SourceTargetOfKind<'file'>;
-type FunctionTarget = SourceTargetOfKind<'function'>;
-interface LanguageContext {
-  cwd: string;
-  languageOptions: Record<string, unknown>;
-  src: SourceRuntime;
-}
-interface LineRange {
-  endLine: number;
-  startLine: number;
-}
-interface ProcessedSource {
-  identity: string;
-  language?: string;
-  origin?: ProcessedSourceOrigin;
-  path: string;
-  text: string;
-}
-interface ProcessedSourceOrigin {
-  physicalPath: string;
-  range?: SourceRange;
-  virtualPath?: string;
-}
-interface ProcessorContext {
-  cwd: string;
-  options: Record<string, unknown>;
-  src: SourceRuntime;
-}
-interface ProcessorPostprocessContext extends ProcessorContext {
-  file: SourceFile;
-  processedSources: ProcessedSource[];
-}
-interface SourceFile {
-  language: string;
-  lines: string[];
-  path: string;
-  text: string;
-}
-interface SourceLocation {
-  end: SourcePosition;
-  start: SourcePosition;
-}
-interface SourcePosition {
-  column: number;
-  line: number;
-}
-interface SourceRange {
-  end: number;
-  start: number;
-}
-interface SourceRuntime {
-  getText: (target: SourceFile | SourceTarget) => string;
-  readFile: (filePath: string) => Promise<SourceFile>;
-  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
-  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
-}
-interface SourceTarget {
-  file: SourceFile;
-  identity: string;
-  kind: SourceTargetKind;
-  language: string;
-  loc?: SourceLocation;
-  metadata?: Record<string, unknown>;
-  name?: string;
-  origin?: SourceTargetOrigin;
-  range?: SourceRange;
-  text: string;
-}
-type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
-type SourceTargetOfKind<Kind extends SourceTargetKind> = Omit<SourceTarget, 'kind'> & {
-  kind: Kind;
-};
-interface SourceTargetOrigin {
-  physicalPath: string;
-  range?: SourceRange;
-  virtualPath?: string;
-}
-interface SourceText {
-  filePath: string;
-  loc: SourceLocation;
-  text: string;
-}
-//#endregion
 //#region src/dsl/types.d.ts
 type AlintConfig = readonly AlintConfigInput[];
 type AlintConfigExtends = AlintConfigInput | string;
@@ -327,4 +243,4 @@ interface RuleWithHandler {
 }
 type Target = DirectoryTarget | ProjectTarget | SourceTarget;
 //#endregion
-export { ResolvedModel as $, LanguageContext as A, SourceRuntime as B, RuleSeverity as C, ClassTarget as D, Target as E, ProcessorPostprocessContext as F, SourceText as G, SourceTargetKind as H, SourceFile as I, AgentResult as J, AgentAdapter as K, SourceLocation as L, ProcessedSource as M, ProcessedSourceOrigin as N, FileTarget as O, ProcessorContext as P, ResolveModelOptions as Q, SourcePosition as R, RuleRegistry as S, RuleWithHandler as T, SourceTargetOfKind as U, SourceTarget as V, SourceTargetOrigin as W, AgentUsage as X, AgentTool as Y, ModelRequirement as Z, RuleConfigEntry as _, AlintLinterOptions as a, RunnerStatsConfig as at, RuleHandlers as b, DiagnosticLocation as c, IgnoreConfig as d, ResolvedProvider as et, LanguageDefinition as f, RuleCacheConfig as g, ProjectTarget as h, AlintConfigItem as i, RunnerConfig as it, LineRange as j, FunctionTarget as k, DirectoryTarget as l, ProcessorDefinition as m, AlintConfigExtends as n, ProviderDefinition as nt, Awaitable as o, SetupConfig as ot, PluginDefinition as p, AgentRequest as q, AlintConfigInput as r, ProviderType as rt, DiagnosticDescriptor as s, SetupModelDefinition as st, AlintConfig as t, ModelSize as tt, EnabledRule as u, RuleContext as v, RuleSpecializedHandlers as w, RuleInferenceUsageRecord as x, RuleDefinition as y, SourceRange as z };
+export { AgentTool as A, RunnerStatsConfig as B, RuleSeverity as C, AgentAdapter as D, Target as E, ResolvedProvider as F, SetupModelDefinition as H, ModelSize as I, ProviderDefinition as L, ModelRequirement as M, ResolveModelOptions as N, AgentRequest as O, ResolvedModel as P, ProviderType as R, RuleRegistry as S, RuleWithHandler as T, SetupConfig as V, RuleConfigEntry as _, AlintLinterOptions as a, RuleHandlers as b, DiagnosticLocation as c, IgnoreConfig as d, LanguageDefinition as f, RuleCacheConfig as g, ProjectTarget as h, AlintConfigItem as i, AgentUsage as j, AgentResult as k, DirectoryTarget as l, ProcessorDefinition as m, AlintConfigExtends as n, Awaitable as o, PluginDefinition as p, AlintConfigInput as r, DiagnosticDescriptor as s, AlintConfig as t, EnabledRule as u, RuleContext as v, RuleSpecializedHandlers as w, RuleInferenceUsageRecord as x, RuleDefinition as y, RunnerConfig as z };

package/dist/types-DSvXUVZ7.d.mts

@@ -0,0 +1,86 @@
+//#region src/core/source/types.d.ts
+type ClassTarget = SourceTargetOfKind<'class'>;
+type FileTarget = SourceTargetOfKind<'file'>;
+type FunctionTarget = SourceTargetOfKind<'function'>;
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface ProcessedSource {
+  identity: string;
+  language?: string;
+  origin?: ProcessedSourceOrigin;
+  path: string;
+  text: string;
+}
+interface ProcessedSourceOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface ProcessorContext {
+  cwd: string;
+  options: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface ProcessorPostprocessContext extends ProcessorContext {
+  file: SourceFile;
+  processedSources: ProcessedSource[];
+}
+interface SourceFile {
+  language: string;
+  lines: string[];
+  path: string;
+  text: string;
+}
+interface SourceLocation {
+  end: SourcePosition;
+  start: SourcePosition;
+}
+interface SourcePosition {
+  column: number;
+  line: number;
+}
+interface SourceRange {
+  end: number;
+  start: number;
+}
+interface SourceRuntime {
+  getText: (target: SourceFile | SourceTarget) => string;
+  readFile: (filePath: string) => Promise<SourceFile>;
+  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
+  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
+}
+interface SourceTarget {
+  file: SourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: Record<string, unknown>;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+  text: string;
+}
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+type SourceTargetOfKind<Kind extends SourceTargetKind> = Omit<SourceTarget, 'kind'> & {
+  kind: Kind;
+};
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+//#endregion
+export { SourceTargetOfKind as _, LineRange as a, ProcessorContext as c, SourceLocation as d, SourcePosition as f, SourceTargetKind as g, SourceTarget as h, LanguageContext as i, ProcessorPostprocessContext as l, SourceRuntime as m, FileTarget as n, ProcessedSource as o, SourceRange as p, FunctionTarget as r, ProcessedSourceOrigin as s, ClassTarget as t, SourceFile as u, SourceTargetOrigin as v, SourceText as y };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -15,6 +15,10 @@
       "types": "./dist/structured-output.d.mts",
       "default": "./dist/structured-output.mjs"
     },
+    "./languages/js": {
+      "types": "./dist/languages-js.d.mts",
+      "default": "./dist/languages-js.mjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [