@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-move-config-worker-child.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semantic_move_config_worker_1 = require("./semantic-move-config-worker");
+process.once("message", (raw) => {
+    const request = readRequest(raw);
+    if (!request) {
+        send({
+            type: "semanticMoveConfigResult",
+            id: "invalid",
+            ok: false,
+            configFilePath: "",
+            rootFiles: [],
+            containsSource: false,
+            edits: [],
+            beforeHashes: {},
+            configHash: "",
+            pid: process.pid,
+            rssMiB: process.memoryUsage().rss / 1024 / 1024,
+            error: "Invalid semantic move config worker request."
+        });
+        return;
+    }
+    send((0, semantic_move_config_worker_1.runSemanticMoveConfigJob)(request));
+});
+function readRequest(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const value = raw;
+    return value.type === "semanticMoveConfig" && typeof value.id === "string" &&
+        typeof value.workspaceRoot === "string" && typeof value.configFilePath === "string" &&
+        typeof value.sourceFile === "string" && typeof value.sourceText === "string" &&
+        typeof value.targetFile === "string" && isSelection(value.selection) && isPreferences(value.preferences) &&
+        isProgramRootFiles(value.programRootFiles) && isImportRules(value.unusedImportCleanupRules)
+        ? value
+        : null;
+}
+function isImportRules(value) {
+    return value === undefined || Array.isArray(value) && value.every((rule) => Boolean(rule) &&
+        typeof rule === "object" && !Array.isArray(rule) &&
+        typeof rule.scope === "string" &&
+        typeof rule.scopePath === "string" &&
+        [undefined, "preserve", "remove"].includes(rule.unusedImports));
+}
+function isProgramRootFiles(value) {
+    return value === undefined || Array.isArray(value) && value.every((file) => typeof file === "string");
+}
+function isSelection(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const selection = value;
+    return Number.isSafeInteger(selection.pos) && Number.isSafeInteger(selection.end) &&
+        selection.pos >= 0 && selection.end > selection.pos;
+}
+function isPreferences(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function send(message) {
+    const sender = process.send;
+    if (sender)
+        sender.call(process, message, () => process.disconnect?.());
+}

package/dist/mutation/semantic-move-config-worker.js

@@ -0,0 +1,449 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemanticMoveConfigJob = runSemanticMoveConfigJob;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const import_rules_1 = require("../config/import-rules");
+const semantic_move_provider_diagnostics_1 = require("./semantic-move-provider-diagnostics");
+const semantic_unused_import_cleanup_1 = require("./semantic-unused-import-cleanup");
+const defaultDependencies = {
+    getEditsForRefactor(languageService, request) {
+        return languageService.getEditsForRefactor(request.sourceFile, defaultFormatOptions(), request.selection, "Move to file", "Move to file", {
+            allowTextChangesInNewFiles: true,
+            provideRefactorNotApplicableReason: true,
+            quotePreference: request.preferences.quotePreference ?? "auto",
+            ...(request.preferences.importModuleSpecifierPreference
+                ? { importModuleSpecifierPreference: request.preferences.importModuleSpecifierPreference }
+                : {}),
+            ...(request.preferences.importModuleSpecifierEnding
+                ? { importModuleSpecifierEnding: request.preferences.importModuleSpecifierEnding }
+                : {})
+        }, { targetFile: request.targetFile });
+    }
+};
+function runSemanticMoveConfigJob(request, dependencies = defaultDependencies) {
+    let languageService = null;
+    const metrics = request.metricsEnabled === true ? createWorkerMetrics() : undefined;
+    try {
+        const configStartedAt = startMetric(metrics);
+        const parsed = parseConfig(request.configFilePath);
+        endMetric(metrics, "config", configStartedAt);
+        const overrides = new Map([
+            [pathKey(request.sourceFile), request.sourceText],
+            [pathKey(request.targetFile), request.targetText]
+        ]);
+        const programStartedAt = startMetric(metrics);
+        const service = createLanguageService(request.configFilePath, parsed, overrides, request.programRootFiles);
+        languageService = service.languageService;
+        const program = languageService.getProgram();
+        if (!program)
+            throw new Error("TypeScript LanguageService did not provide a Program.");
+        const containsSource = program.getSourceFiles().some((file) => samePath(file.fileName, request.sourceFile));
+        if (metrics)
+            metrics.programFiles = summarizeProgramFiles(program, request.workspaceRoot);
+        endMetric(metrics, "program", programStartedAt);
+        const refactorStartedAt = startMetric(metrics);
+        let editInfo;
+        try {
+            editInfo = dependencies.getEditsForRefactor(languageService, request);
+        }
+        catch (error) {
+            endMetric(metrics, "refactor", refactorStartedAt);
+            const diagnostic = (0, semantic_move_provider_diagnostics_1.classifySemanticMoveProviderException)(error);
+            return withWorkerMetrics({
+                ...failed(request, program.getRootFileNames(), containsSource, diagnostic.error, diagnostic.failureKind),
+                providerCode: diagnostic.code
+            }, metrics);
+        }
+        endMetric(metrics, "refactor", refactorStartedAt);
+        if (!editInfo || editInfo.notApplicableReason) {
+            return withWorkerMetrics(failed(request, program.getRootFileNames(), containsSource, editInfo?.notApplicableReason ?? "TypeScript API returned no move edits.", "provider-unsupported"), metrics);
+        }
+        const serializeStartedAt = startMetric(metrics);
+        let edits = normalizeFileEdits(editInfo.edits);
+        const exportStarProofs = collectExportStarProofs(program, request);
+        if (request.unusedImportCleanupRules?.some((rule) => rule.unusedImports === "remove")) {
+            const snapshots = edits.map((edit) => materializeSnapshot(request, edit));
+            const cleanup = (0, semantic_unused_import_cleanup_1.runSemanticUnusedImportCleanup)({
+                languageService,
+                snapshots,
+                updateSnapshots: service.updateSnapshots,
+                formatOptions: defaultFormatOptions(),
+                preferences: request.preferences
+            });
+            edits = applyCleanedSnapshots(request, edits, cleanup.texts);
+            if (metrics) {
+                metrics.phasesMs.cleanupScan = cleanup.metrics.scanMs;
+                metrics.phasesMs.cleanupRefresh = cleanup.metrics.refreshMs;
+                metrics.phasesMs.cleanupOracle = cleanup.metrics.oracleMs;
+                metrics.phasesMs.cleanupRender = cleanup.metrics.renderMs;
+                metrics.unusedImportCleanup = {
+                    candidateFiles: cleanup.metrics.candidateFiles,
+                    candidateBindings: cleanup.metrics.candidateBindings,
+                    oracleFiles: cleanup.metrics.oracleFiles,
+                    removedBindings: cleanup.metrics.removedBindings
+                };
+                metrics.peakRssMiB = Math.max(metrics.peakRssMiB, process.memoryUsage().rss / 1024 / 1024);
+            }
+        }
+        const beforeHashes = {};
+        for (const edit of edits) {
+            if (!edit.isNewFile && fs.existsSync(edit.fileName))
+                beforeHashes[edit.fileName] = hashFile(edit.fileName);
+        }
+        for (const proof of exportStarProofs) {
+            if (fs.existsSync(proof.barrelFile))
+                beforeHashes[proof.barrelFile] = hashFile(proof.barrelFile);
+        }
+        const result = {
+            type: "semanticMoveConfigResult",
+            id: request.id,
+            ok: containsSource && edits.length > 0,
+            configFilePath: path.normalize(request.configFilePath),
+            rootFiles: program.getRootFileNames().map(path.normalize),
+            containsSource,
+            edits,
+            beforeHashes,
+            ...(exportStarProofs.length > 0 ? { exportStarProofs } : {}),
+            configHash: hashFile(request.configFilePath),
+            pid: process.pid,
+            rssMiB: process.memoryUsage().rss / 1024 / 1024,
+            ...(!containsSource
+                ? {
+                    failureKind: "owner-incomplete",
+                    error: "Selected owner projection does not contain the move source."
+                }
+                : edits.length === 0
+                    ? {
+                        failureKind: "provider-unsupported",
+                        error: "TypeScript API returned an empty move edit set."
+                    }
+                    : {})
+        };
+        endMetric(metrics, "serialize", serializeStartedAt);
+        return withWorkerMetrics(result, metrics);
+    }
+    catch (error) {
+        return withWorkerMetrics(failed(request, [], false, error instanceof Error ? error.message : String(error), "worker-error"), metrics);
+    }
+    finally {
+        languageService?.dispose();
+    }
+}
+function collectExportStarProofs(program, request) {
+    const candidates = request.exportStarCandidates ?? [];
+    if (candidates.length === 0)
+        return [];
+    const checker = program.getTypeChecker();
+    const source = program.getSourceFiles().find((file) => samePath(file.fileName, request.sourceFile));
+    const sourceModule = source ? checker.getSymbolAtLocation(source) : undefined;
+    const sourceExports = sourceModule ? new Map(checker.getExportsOfModule(sourceModule).map((symbol) => [symbol.name, symbol])) : new Map();
+    const proofs = [];
+    for (const candidate of candidates) {
+        const barrel = program.getSourceFiles().find((file) => samePath(file.fileName, candidate.barrelFile));
+        const barrelModule = barrel ? checker.getSymbolAtLocation(barrel) : undefined;
+        const declaration = barrel?.statements.find((statement) => typescript_1.default.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier !== undefined &&
+            typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) && statement.moduleSpecifier.text === candidate.moduleSpecifier &&
+            statement.moduleSpecifier.getStart(barrel) + 1 === candidate.specifierStart);
+        const barrelExports = barrelModule
+            ? new Map(checker.getExportsOfModule(barrelModule).map((symbol) => [symbol.name, symbol]))
+            : new Map();
+        for (const entity of candidate.entities) {
+            const sourceExport = sourceExports.get(entity.name);
+            const barrelExport = barrelExports.get(entity.name);
+            const canonicalSource = sourceExport ? canonicalSymbol(checker, sourceExport) : null;
+            const canonicalBarrel = barrelExport ? canonicalSymbol(checker, barrelExport) : null;
+            const conflictingStar = declaration && barrel
+                ? hasConflictingExportStar(checker, barrel, declaration, entity.name)
+                : false;
+            proofs.push({
+                barrelFile: path.normalize(candidate.barrelFile),
+                moduleSpecifier: candidate.moduleSpecifier,
+                specifierStart: candidate.specifierStart,
+                entity: entity.name,
+                checked: Boolean(declaration && sourceModule && barrelModule && sourceExport),
+                matchesSourceSymbol: Boolean(declaration && canonicalSource && canonicalBarrel &&
+                    canonicalSource === canonicalBarrel && !conflictingStar),
+                typeOnly: Boolean(declaration?.isTypeOnly || canonicalSource && (canonicalSource.flags & typescript_1.default.SymbolFlags.Value) === 0)
+            });
+        }
+    }
+    return proofs;
+}
+function canonicalSymbol(checker, symbol) {
+    return (symbol.flags & typescript_1.default.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function hasConflictingExportStar(checker, barrel, candidate, entity) {
+    return barrel.statements.some((statement) => {
+        if (statement === candidate || !typescript_1.default.isExportDeclaration(statement) || statement.exportClause ||
+            !statement.moduleSpecifier || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)) {
+            return false;
+        }
+        const moduleSymbol = checker.getSymbolAtLocation(statement.moduleSpecifier);
+        return Boolean(moduleSymbol && checker.getExportsOfModule(canonicalSymbol(checker, moduleSymbol))
+            .some((symbol) => symbol.name === entity));
+    });
+}
+function createWorkerMetrics() {
+    const rssMiB = process.memoryUsage().rss / 1024 / 1024;
+    return { phasesMs: {}, peakRssMiB: rssMiB };
+}
+function startMetric(metrics) {
+    return metrics ? Date.now() : 0;
+}
+function endMetric(metrics, phase, startedAt) {
+    if (!metrics)
+        return;
+    metrics.phasesMs[phase] = Date.now() - startedAt;
+    metrics.peakRssMiB = Math.max(metrics.peakRssMiB, process.memoryUsage().rss / 1024 / 1024);
+}
+function withWorkerMetrics(result, metrics) {
+    if (!metrics)
+        return result;
+    const serializationStartedAt = Date.now();
+    try {
+        JSON.stringify(result);
+    }
+    catch {
+        // Metrics-only serialization measurement cannot affect the worker result.
+    }
+    metrics.phasesMs.serialize = (metrics.phasesMs.serialize ?? 0) + (Date.now() - serializationStartedAt);
+    const endingRssMiB = process.memoryUsage().rss / 1024 / 1024;
+    return {
+        ...result,
+        metrics: {
+            phasesMs: metrics.phasesMs,
+            ...(metrics.programFiles ? { programFiles: metrics.programFiles } : {}),
+            ...(metrics.unusedImportCleanup ? { unusedImportCleanup: metrics.unusedImportCleanup } : {}),
+            peakRssMiB: Math.max(metrics.peakRssMiB, endingRssMiB),
+            endingRssMiB
+        }
+    };
+}
+function summarizeProgramFiles(program, workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    const files = program.getSourceFiles();
+    return {
+        root: program.getRootFileNames().length,
+        total: files.length,
+        workspace: files.filter((file) => isInside(root, file.fileName)).length,
+        declaration: files.filter((file) => file.isDeclarationFile).length,
+        externalLibrary: files.filter((file) => program.isSourceFileFromExternalLibrary(file)).length
+    };
+}
+function failed(request, rootFiles, containsSource, error, failureKind) {
+    return {
+        type: "semanticMoveConfigResult",
+        id: request.id,
+        ok: false,
+        configFilePath: path.normalize(request.configFilePath),
+        rootFiles: rootFiles.map(path.normalize),
+        containsSource,
+        edits: [],
+        beforeHashes: {},
+        configHash: safeHashFile(request.configFilePath),
+        pid: process.pid,
+        rssMiB: process.memoryUsage().rss / 1024 / 1024,
+        failureKind,
+        error
+    };
+}
+function normalizeFileEdits(edits) {
+    return edits.map((edit) => ({
+        fileName: path.normalize(edit.fileName),
+        isNewFile: edit.isNewFile === true,
+        textChanges: normalizeTextChanges(edit.textChanges)
+    })).sort((left, right) => left.fileName.localeCompare(right.fileName));
+}
+function normalizeTextChanges(changes) {
+    return changes.map((change) => ({
+        span: { start: change.span.start, length: change.span.length },
+        newText: change.newText
+    })).sort((left, right) => left.span.start - right.span.start || left.span.length - right.span.length || left.newText.localeCompare(right.newText));
+}
+function parseConfig(configFilePath) {
+    const source = typescript_1.default.readConfigFile(configFilePath, typescript_1.default.sys.readFile);
+    if (source.error)
+        throw new Error(typescript_1.default.flattenDiagnosticMessageText(source.error.messageText, "\n"));
+    const parsed = typescript_1.default.parseJsonConfigFileContent(source.config, typescript_1.default.sys, path.dirname(configFilePath), undefined, configFilePath);
+    if (parsed.errors.length > 0) {
+        throw new Error(parsed.errors.map((error) => typescript_1.default.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n"));
+    }
+    return parsed;
+}
+function createLanguageService(configFilePath, parsed, overrides, programRootFiles) {
+    const versions = new Map();
+    const overrideFiles = [...overrides.keys()];
+    const configuredRoots = programRootFiles
+        ? programRootFiles.map((file) => path.resolve(file))
+        : parsed.fileNames;
+    const host = {
+        getScriptFileNames: () => uniqueFileNames([...configuredRoots, ...overrideFiles]),
+        getScriptVersion: (file) => overrides.has(pathKey(file))
+            ? `snapshot-${versions.get(pathKey(file)) ?? 0}`
+            : safeMtime(file),
+        getScriptSnapshot: (file) => {
+            const override = overrides.get(pathKey(file));
+            if (override !== undefined)
+                return typescript_1.default.ScriptSnapshot.fromString(override);
+            const text = typescript_1.default.sys.readFile(file);
+            return text === undefined ? undefined : typescript_1.default.ScriptSnapshot.fromString(text);
+        },
+        getCurrentDirectory: () => path.dirname(configFilePath),
+        getCompilationSettings: () => parsed.options,
+        getDefaultLibFileName: typescript_1.default.getDefaultLibFilePath,
+        fileExists: typescript_1.default.sys.fileExists,
+        readFile: typescript_1.default.sys.readFile,
+        readDirectory: typescript_1.default.sys.readDirectory,
+        directoryExists: typescript_1.default.sys.directoryExists,
+        getDirectories: typescript_1.default.sys.getDirectories,
+        ...(typescript_1.default.sys.realpath ? { realpath: typescript_1.default.sys.realpath } : {}),
+        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
+        getNewLine: () => typescript_1.default.sys.newLine
+    };
+    return {
+        languageService: typescript_1.default.createLanguageService(host, typescript_1.default.createDocumentRegistry()),
+        updateSnapshots(snapshots) {
+            for (const snapshot of snapshots) {
+                const key = pathKey(snapshot.fileName);
+                overrides.set(key, snapshot.text);
+                versions.set(key, (versions.get(key) ?? 0) + 1);
+            }
+        }
+    };
+}
+function materializeSnapshot(request, edit) {
+    const expectedText = expectedTextForEdit(request, edit);
+    return {
+        fileName: edit.fileName,
+        text: applyTextChanges(expectedText, edit.textChanges),
+        cleanup: (0, import_rules_1.resolveImportRuleForFile)(edit.fileName, request.unusedImportCleanupRules ?? [])?.unusedImports === "remove"
+    };
+}
+function applyCleanedSnapshots(request, edits, cleanedTexts) {
+    return edits.map((edit) => {
+        const cleanedText = cleanedTexts.get(pathKey(edit.fileName));
+        if (cleanedText === undefined)
+            return edit;
+        const expectedText = expectedTextForEdit(request, edit);
+        return {
+            ...edit,
+            textChanges: [{ span: { start: 0, length: expectedText.length }, newText: cleanedText }]
+        };
+    });
+}
+function expectedTextForEdit(request, edit) {
+    if (samePath(edit.fileName, request.sourceFile))
+        return request.sourceText;
+    if (samePath(edit.fileName, request.targetFile))
+        return request.targetText;
+    return edit.isNewFile ? "" : fs.readFileSync(edit.fileName, "utf8");
+}
+function applyTextChanges(text, changes) {
+    let output = text;
+    for (const change of [...changes].sort((left, right) => right.span.start - left.span.start)) {
+        output = `${output.slice(0, change.span.start)}${change.newText}${output.slice(change.span.start + change.span.length)}`;
+    }
+    return output;
+}
+function uniqueFileNames(files) {
+    const seen = new Set();
+    return files.filter((file) => {
+        const key = pathKey(file);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function defaultFormatOptions() {
+    return {
+        indentSize: 2,
+        tabSize: 2,
+        convertTabsToSpaces: true,
+        newLineCharacter: "\n",
+        insertSpaceAfterCommaDelimiter: true,
+        insertSpaceAfterSemicolonInForStatements: true,
+        insertSpaceBeforeAndAfterBinaryOperators: true,
+        insertSpaceAfterKeywordsInControlFlowStatements: true,
+        insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
+        insertSpaceBeforeFunctionParenthesis: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+        insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: false,
+        insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+        insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+        insertSpaceAfterTypeAssertion: false,
+        placeOpenBraceOnNewLineForFunctions: false,
+        placeOpenBraceOnNewLineForControlBlocks: false
+    };
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function safeHashFile(file) {
+    try {
+        return hashFile(file);
+    }
+    catch {
+        return "";
+    }
+}
+function safeMtime(file) {
+    try {
+        return String(fs.statSync(file).mtimeMs);
+    }
+    catch {
+        return "0";
+    }
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function isInside(root, file) {
+    const relative = path.relative(root, path.resolve(file));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/mutation/semantic-move-declarations.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSemanticMoveDeclarations = collectSemanticMoveDeclarations;
+exports.countSemanticMoveDeclarations = countSemanticMoveDeclarations;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function collectSemanticMoveDeclarations(fileName, text) {
+    const source = typescript_1.default.createSourceFile(fileName, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(fileName));
+    const output = [];
+    source.statements.forEach((statement, statementIndex) => {
+        for (const declaration of declarationNames(statement)) {
+            output.push({
+                name: declaration.name.text,
+                kind: declaration.kind,
+                statementIndex,
+                statementStart: statement.getStart(source),
+                statementEnd: statement.getEnd(),
+                nameStart: declaration.name.getStart(source),
+                nameEnd: declaration.name.getEnd()
+            });
+        }
+    });
+    return output;
+}
+function countSemanticMoveDeclarations(fileName, text, name, kind) {
+    return collectSemanticMoveDeclarations(fileName, text)
+        .filter((candidate) => candidate.name === name && (!kind || candidate.kind === kind)).length;
+}
+function declarationNames(statement) {
+    if (typescript_1.default.isFunctionDeclaration(statement) && statement.name)
+        return [{ name: statement.name, kind: "function" }];
+    if (typescript_1.default.isClassDeclaration(statement) && statement.name)
+        return [{ name: statement.name, kind: "class" }];
+    if (typescript_1.default.isInterfaceDeclaration(statement))
+        return [{ name: statement.name, kind: "interface" }];
+    if (typescript_1.default.isTypeAliasDeclaration(statement))
+        return [{ name: statement.name, kind: "type" }];
+    if (typescript_1.default.isEnumDeclaration(statement))
+        return [{ name: statement.name, kind: "enum" }];
+    if (typescript_1.default.isModuleDeclaration(statement) && typescript_1.default.isIdentifier(statement.name))
+        return [{ name: statement.name, kind: "namespace" }];
+    if (typescript_1.default.isVariableStatement(statement)) {
+        return statement.declarationList.declarations
+            .map((declaration) => typescript_1.default.isIdentifier(declaration.name) ? { name: declaration.name, kind: "variable" } : null)
+            .filter((item) => item !== null);
+    }
+    return [];
+}
+function scriptKindForFile(file) {
+    const extension = path.extname(file).toLowerCase();
+    if (extension === ".tsx")
+        return typescript_1.default.ScriptKind.TSX;
+    if (extension === ".jsx")
+        return typescript_1.default.ScriptKind.JSX;
+    if ([".js", ".mjs", ".cjs"].includes(extension))
+        return typescript_1.default.ScriptKind.JS;
+    return typescript_1.default.ScriptKind.TS;
+}