@alint-js/core 0.1.3 → 0.1.5

package/dist/languages-js.d.mts

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

package/dist/languages-js.mjs

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

package/dist/structured-output.d.mts

@@ -1,4 +1,4 @@
-import { b as RuleContext, z as ResolvedModel } from "./types-DKylUrAn.mjs";
+import { b as RuleContext, z as ResolvedModel } from "./types-deBCDA4_.mjs";
 import { GenericSchema, InferOutput } from "valibot";
 import { JsonSchema } from "@valibot/to-json-schema";
 import { Message } from "@xsai/shared-chat";

package/dist/types-DM4idR4w.d.mts

@@ -0,0 +1,179 @@
+//#region src/core/source/types.d.ts
+interface BaseSourceFile {
+  contentHash: string;
+  language: string;
+  path: string;
+}
+/**
+ * Carried on a file target under `metadata.calls`, in source order.
+ *
+ * Every call in the file, including those outside any function: a consumer counting how often a
+ * name is used has to see the uses, not just the definitions.
+ */
+interface CallSite extends SourceMetadataObject {
+  /** The last segment only: `a.b.helper()` and `helper()` both yield `helper`. */
+  name: string;
+  /** Absolute, into the file's text. */
+  range: SourceRange;
+}
+type ClassTarget = PlannedSourceTargetOfKind<'class'>;
+type FileTarget = PlannedSourceTargetOfKind<'file'>;
+/**
+ * Carried under `metadata.function`, so a consumer can fingerprint, count and classify a function
+ * without reaching for a parser of its own.
+ *
+ * Every producer of function targets should fill it in; a consumer still validates the expected
+ * domain fields when reading the recursive JSON metadata contract.
+ *
+ * Ranges are relative to the target's own `text`, not to the file, so a consumer can slice that
+ * text directly and never has to rebase.
+ */
+interface FunctionInfo extends SourceMetadataObject {
+  /**
+   * Stricter than one statement: a body that is one `if` and its two returns is one statement and
+   * not one expression.
+   */
+  bodyIsSingleExpression: boolean;
+  /** Statements in the body, not counting comments. */
+  bodyStatements: number;
+  commentRanges: readonly SourceRange[];
+  /**
+   * The names the function declares: its own name, its parameters and its locals.
+   *
+   * A copy can rename what it declares and stay a copy, so this is the set an α-renaming
+   * fingerprint may replace. Everything else — callees, globals, types, properties — stays
+   * verbatim and is what tells two same-shaped functions apart.
+   */
+  declaredNames: readonly string[];
+  /** Reachable from outside its file, however the language spells it. */
+  exported: boolean;
+  /**
+   * Identifiers that MAY be renamed away, which is narrower than "every identifier token".
+   *
+   * Property, field and type names must not be here: replacing them collapses `entry.name` and
+   * `entry.size` into the same fingerprint, which is the mistake this set exists to avoid.
+   */
+  identifierRanges: readonly SourceRange[];
+}
+type FunctionTarget = PlannedSourceTargetOfKind<'function'>;
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface PlannedSourceTarget {
+  file: BaseSourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: SourceTargetMetadata;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+}
+type PlannedSourceTargetOfKind<Kind extends SourceTargetKind> = Omit<PlannedSourceTarget, 'kind'> & {
+  kind: Kind;
+};
+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 SourceExtractOptions {
+  /**
+   * Overrides the file's configured `language:` pin.
+   *
+   * For a caller walking a mixed tree, where the file's own config cannot know what each file is.
+   */
+  language?: string;
+}
+interface SourceFile extends BaseSourceFile {
+  lines: string[];
+  text: string;
+}
+interface SourceLocation {
+  end: SourcePosition;
+  start: SourcePosition;
+}
+interface SourceMetadataObject {
+  readonly [key: string]: SourceMetadataValue;
+}
+type SourceMetadataValue = boolean | null | number | readonly SourceMetadataValue[] | SourceMetadataObject | SourceRange | string;
+interface SourcePosition {
+  column: number;
+  line: number;
+}
+interface SourceRange {
+  end: number;
+  start: number;
+}
+interface SourceRuntime {
+  /**
+   * Targets for any file, linted or not.
+   *
+   * Resolves the file's own config the way linting does, resolves its language from that config,
+   * and runs that language's extract. A rule handed `ProjectTarget.files`, or an index builder
+   * sweeping files outside the lint set, has no other way to parse them.
+   *
+   * An ignored file extracts to `[]` rather than throwing: sweeping broadly and skipping what the
+   * config excluded is the normal case, not an error.
+   *
+   * Only wired inside a run. A runtime built by `createSourceRuntime()` with no extractor throws,
+   * because there is no config to resolve the file against.
+   */
+  extract: (filePath: string, options?: SourceExtractOptions) => Promise<SourceTarget[]>;
+  getText: (file: SourceFile) => string;
+  readFile: (file: BaseSourceFile | 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?: SourceTargetMetadata;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+  text: string;
+}
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+type SourceTargetMetadata = Readonly<Record<string, SourceMetadataValue>>;
+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 { SourceTarget as C, SourceTargetOrigin as D, SourceTargetOfKind as E, SourceText as O, SourceRuntime as S, SourceTargetMetadata as T, SourceLocation as _, FunctionInfo as a, SourcePosition as b, LineRange as c, ProcessedSource as d, ProcessedSourceOrigin as f, SourceFile as g, SourceExtractOptions as h, FileTarget as i, PlannedSourceTarget as l, ProcessorPostprocessContext as m, CallSite as n, FunctionTarget as o, ProcessorContext as p, ClassTarget as r, LanguageContext as s, BaseSourceFile as t, PlannedSourceTargetOfKind as u, SourceMetadataObject as v, SourceTargetKind as w, SourceRange as x, SourceMetadataValue as y };

package/dist/{types-DKylUrAn.d.mts → types-deBCDA4_.d.mts}

@@ -1,4 +1,4 @@
-import { c as ProcessorContext, h as SourceTarget, i as LanguageContext, l as ProcessorPostprocessContext, m as SourceRuntime, n as FileTarget, o as ProcessedSource, p as SourceRange, r as FunctionTarget, t as ClassTarget, u as SourceFile } from "./types-DSvXUVZ7.mjs";
+import { C as SourceTarget, S as SourceRuntime, d as ProcessedSource, g as SourceFile, i as FileTarget, l as PlannedSourceTarget, m as ProcessorPostprocessContext, o as FunctionTarget, p as ProcessorContext, r as ClassTarget, s as LanguageContext, t as BaseSourceFile, x as SourceRange } from "./types-DM4idR4w.mjs";
 import { GenericSchema, InferInput, InferOutput } from "valibot";
 //#region src/config/types.d.ts
 type ModelSize = 'large' | 'medium' | 'small';
@@ -121,6 +121,12 @@ interface AlintConfigItem {
 }
 interface AlintLinterOptions {
   noInlineConfig?: boolean;
+  /**
+   * How the run reports files it lints that no language claimed, so they were handled as plain
+   * text. Defaults to `'warn'`. An explicit `language: 'plaintext'` pin means plain text was the
+   * intent, so pinned files are never reported.
+   */
+  reportUnregisteredLanguages?: RuleSeverity;
   reportUnusedDisableDirectives?: RuleSeverity;
 }
 type Awaitable<T> = Promise<T> | T;
@@ -157,6 +163,20 @@ interface IgnoreConfig {
 interface LanguageDefinition {
   extensions?: readonly string[];
   extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
+  /**
+   * The language's id: what a config pins through `language:`, what a rule's `languages` lists, and
+   * what every target it extracts reports. The registry is keyed by it, so two packs cannot claim
+   * the same one.
+   *
+   * Use the identifier editors already use — `go`, `python`, `rust`, `typescript`, `plaintext` —
+   * rather than inventing a spelling. Anyone can register a language, so the set is open by
+   * definition and only a shared convention keeps one language from arriving under three names.
+   *
+   * NOTICE: the list is VS Code's. The Language Server Protocol shares it for the languages it
+   * covers, but its table has no entry for plain text, so `plaintext` comes from VS Code alone.
+   * https://code.visualstudio.com/docs/languages/identifiers
+   * https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentItem
+   */
   name: string;
 }
 interface PluginDefinition<Rules extends Record<string, RuleDefinition<any>> = Record<string, RuleDefinition<any>>> {
@@ -169,10 +189,7 @@ interface ProcessorDefinition {
   postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
   preprocess: (file: SourceFile, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
 }
-interface ProjectFileEntry {
-  contentHash: string;
-  language: string;
-  path: string;
+interface ProjectFileEntry extends BaseSourceFile {
   targetCount: number;
 }
 interface ProjectTarget {
@@ -222,6 +239,15 @@ interface RuleDefinition<OptionsSchema extends RuleOptionsSchema = []> {
   /** Additional stable rule inputs, such as imported prompts, that invalidate cached results when changed. */
   cacheKey?: unknown;
   create: (context: RuleContext<RuleOptionsOutput<OptionsSchema>>) => RuleHandlers;
+  /**
+   * Which languages this rule reads. Omitting it opts out of extraction: the rule still receives
+   * file targets, but never the function and class targets a language produces.
+   *
+   * It does not choose how a file is parsed. A config's `language:` pin, or the extension, settles
+   * that before any rule is consulted. Directory and project targets ignore it too: they index a
+   * tree rather than come from a language.
+   */
+  languages?: RuleLanguages;
   model?: ModelRequirement;
   options?: OptionsSchema;
 }
@@ -236,6 +262,23 @@ interface RuleInferenceUsageRecord {
   ruleId?: string;
   totalTokens?: number;
 }
+/**
+ * - `'any'` — every registered language, and never a failure. A rule that works from `FunctionInfo`
+ *   alone wants this: a language pack the user installs later is covered without a new release.
+ * - A list of language ids — `LanguageDefinition.name` values such as `go` or `typescript`, never
+ *   file extensions. The rule handles exactly these. Files of other languages are skipped
+ *   rather than failed, so one plugin can carry rules for several languages behind one `files:`
+ *   glob. If a listed language is not registered at all the run fails, because a rule scoped to a
+ *   language nothing provides would otherwise skip every file in silence.
+ * - `{ ids: string[], skipMissing?: boolean }` — the same scoping, but an unregistered id can be
+ *   skipped instead of failing. For a plugin whose rules span languages a given user may not have installed.
+ */
+type RuleLanguages = 'any' | readonly string[] | {
+  /** Language ids this rule applies to. */
+  ids: readonly string[];
+  /** Whether to skip unregistered languages instead of failing. */
+  skipMissing?: boolean;
+};
 type RuleOptionsInput<OptionsSchema extends RuleOptionsSchema> = { readonly [Index in keyof OptionsSchema]: InferInput<OptionsSchema[Index]>; };
 type RuleOptionsOutput<OptionsSchema extends RuleOptionsSchema> = { readonly [Index in keyof OptionsSchema]: InferOutput<OptionsSchema[Index]>; };
 type RuleOptionsSchema = readonly GenericSchema[];
@@ -260,6 +303,6 @@ interface RuleWithHandler {
   onTargetProject?: never;
   onTargetWith: (target: Target) => Awaitable<void>;
 }
-type Target = DirectoryTarget | ProjectTarget | SourceTarget;
+type Target = DirectoryTarget | PlannedSourceTarget | ProjectTarget;
 //#endregion
 export { RuleWithHandler as A, ResolvedProvider as B, RuleInferenceUsageRecord as C, RuleRegistry as D, RuleOptionsSchema as E, AgentTool as F, RunnerStatsConfig as G, ProviderDefinition as H, AgentUsage as I, SetupConfig as K, ModelRequirement as L, AgentAdapter as M, AgentRequest as N, RuleSeverity as O, AgentResult as P, ResolveModelOptions as R, RuleHandlers as S, RuleOptionsOutput as T, ProviderType as U, ModelSize as V, RunnerConfig as W, ProjectTargetEntry as _, AlintLinterOptions as a, RuleContext as b, DiagnosticLocation as c, IgnoreConfig as d, LanguageDefinition as f, ProjectTarget as g, ProjectFileEntry as h, AlintConfigItem as i, Target as j, RuleSpecializedHandlers as k, DirectoryTarget as l, ProcessorDefinition as m, AlintConfigExtends as n, Awaitable as o, PluginDefinition as p, SetupModelDefinition as q, AlintConfigInput as r, DiagnosticDescriptor as s, AlintConfig as t, EnabledRule as u, RuleCacheConfig as v, RuleOptionsInput as w, RuleDefinition as x, RuleConfigEntry as y, ResolvedModel as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -33,6 +33,7 @@
     "@valibot/to-json-schema": "^1.7.1",
     "@xsai/generate-text": "^0.5.0-beta.7",
     "@xsai/shared-chat": "^0.5.0-beta.7",
+    "@xsai/stream-text": "^0.5.0-beta.7",
     "@xsai/tool": "^0.5.0-beta.7",
     "es-toolkit": "^1.49.0",
     "minimatch": "^10.2.5",

package/dist/extract-CIWssxNK.mjs

@@ -1,358 +0,0 @@
-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 };