@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/inspect/inspect-source-shape.js

@@ -0,0 +1,649 @@
+"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.collectInspectSymbols = collectInspectSymbols;
+exports.collectFunctionOverloadSet = collectFunctionOverloadSet;
+exports.createSourceShapeSymbol = createSourceShapeSymbol;
+exports.getCommonJsExportAssignment = getCommonJsExportAssignment;
+exports.createSymbolForNode = createSymbolForNode;
+exports.createSyntheticSymbol = createSyntheticSymbol;
+exports.isObjectLikeTypeAlias = isObjectLikeTypeAlias;
+exports.getNodeName = getNodeName;
+exports.getNodeKind = getNodeKind;
+exports.isExportedNode = isExportedNode;
+exports.isDefaultExportNode = isDefaultExportNode;
+exports.collectDecoratorNames = collectDecoratorNames;
+exports.getDecoratorName = getDecoratorName;
+exports.createExportDeclarationSymbol = createExportDeclarationSymbol;
+exports.elementFromQuotedModule = elementFromQuotedModule;
+exports.unwrapVoidExpression = unwrapVoidExpression;
+exports.getIifeInfo = getIifeInfo;
+exports.getIifeFunctionName = getIifeFunctionName;
+exports.summarizeTopLevelExpression = summarizeTopLevelExpression;
+exports.summarizeExpressionForDisplay = summarizeExpressionForDisplay;
+exports.summarizeCallExpression = summarizeCallExpression;
+exports.isAssignmentOperator = isAssignmentOperator;
+exports.shortenExpressionText = shortenExpressionText;
+exports.collectStarExportSymbols = collectStarExportSymbols;
+exports.resolveStarExportFilePath = resolveStarExportFilePath;
+exports.buildSignature = buildSignature;
+exports.stripLeadingDecoratorText = stripLeadingDecoratorText;
+exports.getDeclarationHeaderRange = getDeclarationHeaderRange;
+exports.getBodyNode = getBodyNode;
+exports.compactDecoratorCalls = compactDecoratorCalls;
+exports.symbolToPayload = symbolToPayload;
+exports.findCodeSymbol = findCodeSymbol;
+exports.findSymbol = findSymbol;
+exports.flattenSymbols = flattenSymbols;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const standalone_inspect_model_1 = require("./standalone-inspect-model");
+const inspect_source_ranges_1 = require("./inspect-source-ranges");
+function collectInspectSymbols(sourceFilePath, sourceText) {
+    const ts = typescript_1.default;
+    const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true);
+    const symbols = [];
+    const localDeclarations = new Map();
+    let anonymousIifeIndex = 0;
+    for (let statementIndex = 0; statementIndex < sourceFile.statements.length; statementIndex += 1) {
+        const overloadSet = collectFunctionOverloadSet(ts, sourceFile, sourceFile.statements, statementIndex, []);
+        if (overloadSet) {
+            symbols.push(overloadSet.symbol);
+            if (!localDeclarations.has(overloadSet.symbol.name)) {
+                localDeclarations.set(overloadSet.symbol.name, overloadSet.symbol);
+            }
+            statementIndex = overloadSet.endIndex;
+            continue;
+        }
+        const statement = sourceFile.statements[statementIndex];
+        const symbol = createSymbolForNode(ts, sourceFile, statement, []);
+        if (symbol) {
+            symbols.push(symbol);
+            if (!localDeclarations.has(symbol.name)) {
+                localDeclarations.set(symbol.name, symbol);
+            }
+            continue;
+        }
+        const sourceShape = createSourceShapeSymbol(ts, sourceFile, statement, localDeclarations, () => {
+            anonymousIifeIndex += 1;
+            return anonymousIifeIndex;
+        });
+        if (sourceShape) {
+            symbols.push(sourceShape);
+        }
+    }
+    return symbols;
+}
+function collectFunctionOverloadSet(ts, sourceFile, statements, startIndex, parentPath) {
+    const first = statements[startIndex];
+    if (!first || !ts.isFunctionDeclaration(first) || !first.name || first.body) {
+        return null;
+    }
+    const name = first.name.text;
+    const declarations = [first];
+    let implementationCount = 0;
+    let endIndex = startIndex;
+    for (let index = startIndex + 1; index < statements.length; index += 1) {
+        const current = statements[index];
+        if (!current || !ts.isFunctionDeclaration(current) || !current.name || current.name.text !== name) {
+            break;
+        }
+        declarations.push(current);
+        endIndex = index;
+        if (current.body) {
+            implementationCount += 1;
+            break;
+        }
+    }
+    if (declarations.length < 2 || implementationCount > 1 || !declarations.some((declaration) => Boolean(declaration.body))) {
+        return null;
+    }
+    const start = first.getStart(sourceFile);
+    const last = declarations[declarations.length - 1];
+    const end = last.getEnd();
+    const path = [...parentPath, name];
+    const symbol = {
+        name,
+        kind: "function",
+        exported: parentPath.length === 0 && declarations.some((declaration) => isExportedNode(ts, declaration)),
+        path,
+        range: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, start, end),
+        selectionRange: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, (0, inspect_source_ranges_1.getNameStart)(ts, first), (0, inspect_source_ranges_1.getNameEnd)(ts, first)),
+        signature: "",
+        children: [],
+        node: first,
+        decoratorNames: collectDecoratorNames(ts, first),
+        overloadCount: declarations.length,
+        overloadParts: declarations.map((declaration) => ({
+            kind: declaration.body ? "implementation" : "signature",
+            range: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, declaration.getStart(sourceFile), declaration.getEnd()),
+            selectionRange: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, (0, inspect_source_ranges_1.getNameStart)(ts, declaration), (0, inspect_source_ranges_1.getNameEnd)(ts, declaration))
+        }))
+    };
+    return {
+        symbol,
+        endIndex
+    };
+}
+function createSourceShapeSymbol(ts, sourceFile, statement, localDeclarations, nextAnonymousIifeIndex) {
+    if (ts.isImportDeclaration(statement) && !statement.importClause && ts.isStringLiteral(statement.moduleSpecifier)) {
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name: statement.moduleSpecifier.text,
+            kind: "runtime",
+            selector: statement.getText(sourceFile),
+            display: `import ${statement.moduleSpecifier.getText(sourceFile)}`
+        });
+    }
+    if (ts.isExportAssignment(statement)) {
+        const expressionText = statement.expression.getText(sourceFile);
+        const target = ts.isIdentifier(statement.expression) ? localDeclarations.get(statement.expression.text) : undefined;
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name: statement.isExportEquals ? "export=" : "default",
+            kind: "export",
+            selector: statement.isExportEquals ? "export=" : "default",
+            exported: true,
+            exportKind: statement.isExportEquals ? "exportEquals" : "default",
+            exportTarget: target ? { name: target.name, kind: target.kind } : undefined,
+            display: target
+                ? undefined
+                : statement.isExportEquals ? `export = ${shortenExpressionText(expressionText)}` : `export default ${shortenExpressionText(expressionText)}`
+        });
+    }
+    if (ts.isExportDeclaration(statement)) {
+        return createExportDeclarationSymbol(ts, sourceFile, statement, localDeclarations);
+    }
+    if (!ts.isExpressionStatement(statement)) {
+        return null;
+    }
+    const expression = unwrapVoidExpression(ts, statement.expression);
+    const commonJsExport = getCommonJsExportAssignment(ts, sourceFile, expression);
+    if (commonJsExport) {
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name: commonJsExport.name,
+            kind: "export",
+            selector: commonJsExport.name,
+            exported: true,
+            exportKind: "commonjs",
+            display: commonJsExport.display
+        });
+    }
+    const iife = getIifeInfo(ts, expression);
+    if (iife) {
+        const functionName = getIifeFunctionName(ts, iife.functionNode);
+        const anonymous = !functionName;
+        const name = functionName ?? `IIFE#${nextAnonymousIifeIndex()}`;
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name,
+            kind: "function",
+            selector: anonymous ? name : undefined,
+            display: anonymous ? `${name}${iife.async ? " async" : ""}` : undefined,
+            iife: { async: iife.async }
+        });
+    }
+    const display = summarizeTopLevelExpression(ts, sourceFile, expression);
+    return display
+        ? createSyntheticSymbol(ts, sourceFile, statement, {
+            name: display,
+            kind: "runtime",
+            selector: display,
+            display
+        })
+        : null;
+}
+function getCommonJsExportAssignment(ts, sourceFile, expression) {
+    if (!ts.isBinaryExpression(expression) || !isAssignmentOperator(ts, expression.operatorToken.kind)) {
+        return null;
+    }
+    const leftText = expression.left.getText(sourceFile);
+    if (leftText === "module.exports") {
+        return { name: "module.exports", display: "module.exports = ..." };
+    }
+    if (leftText.startsWith("exports.")) {
+        return { name: leftText, display: `${leftText} = ...` };
+    }
+    return null;
+}
+function createSymbolForNode(ts, sourceFile, node, parentPath) {
+    const name = getNodeName(ts, node);
+    const kind = getNodeKind(ts, node);
+    if (!name || !kind) {
+        return null;
+    }
+    const path = [...parentPath, name];
+    const exportKind = parentPath.length === 0 && isDefaultExportNode(ts, node) ? "default" : undefined;
+    const symbol = {
+        name,
+        kind,
+        exported: parentPath.length === 0 && isExportedNode(ts, node),
+        path,
+        range: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, node.getStart(sourceFile), node.getEnd()),
+        selectionRange: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, (0, inspect_source_ranges_1.getNameStart)(ts, node), (0, inspect_source_ranges_1.getNameEnd)(ts, node)),
+        signature: buildSignature(ts, sourceFile, node),
+        children: [],
+        node,
+        ...(exportKind ? { exportKind } : {}),
+        decoratorNames: collectDecoratorNames(ts, node)
+    };
+    if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || isObjectLikeTypeAlias(ts, node)) {
+        const members = ts.isTypeAliasDeclaration(node) && ts.isTypeLiteralNode(node.type)
+            ? node.type.members
+            : ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)
+                ? node.members
+                : [];
+        for (const member of members) {
+            const child = createSymbolForNode(ts, sourceFile, member, path);
+            if (child) {
+                symbol.children.push(child);
+            }
+        }
+    }
+    return symbol;
+}
+function createSyntheticSymbol(ts, sourceFile, node, options) {
+    const start = node.getStart(sourceFile);
+    const end = node.getEnd();
+    const symbol = {
+        name: options.name,
+        kind: options.kind,
+        exported: options.exported === true,
+        path: [options.name],
+        range: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, start, end),
+        selectionRange: (0, inspect_source_ranges_1.toRangeInfo)(sourceFile, start, end),
+        signature: "",
+        children: [],
+        node
+    };
+    if (options.selector !== undefined) {
+        symbol.selector = options.selector;
+    }
+    if (options.display !== undefined) {
+        symbol.display = options.display;
+    }
+    if (options.exportKind !== undefined) {
+        symbol.exportKind = options.exportKind;
+    }
+    if (options.exportTarget !== undefined) {
+        symbol.exportTarget = options.exportTarget;
+    }
+    if (options.sourceModule !== undefined) {
+        symbol.sourceModule = options.sourceModule;
+    }
+    if (options.iife !== undefined) {
+        symbol.iife = options.iife;
+    }
+    return symbol;
+}
+function isObjectLikeTypeAlias(ts, node) {
+    return ts.isTypeAliasDeclaration(node) && ts.isTypeLiteralNode(node.type);
+}
+function getNodeName(ts, node) {
+    if (ts.isConstructorDeclaration(node)) {
+        return "constructor";
+    }
+    if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+        isDefaultExportNode(ts, node) &&
+        !node.name) {
+        return "default";
+    }
+    const maybeNamed = node;
+    if (maybeNamed.name) {
+        return maybeNamed.name.getText();
+    }
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+        return node.name.text;
+    }
+    if (ts.isVariableStatement(node)) {
+        return node.declarationList.declarations[0]?.name.getText() ?? null;
+    }
+    return null;
+}
+function getNodeKind(ts, node) {
+    if (ts.isClassDeclaration(node)) {
+        return "class";
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+        return "interface";
+    }
+    if (ts.isFunctionDeclaration(node)) {
+        return "function";
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+        return "type";
+    }
+    if (ts.isEnumDeclaration(node)) {
+        return "enum";
+    }
+    if (ts.isModuleDeclaration(node)) {
+        return "namespace";
+    }
+    if (ts.isVariableStatement(node)) {
+        return "variable";
+    }
+    if (ts.isConstructorDeclaration(node)) {
+        return "constructor";
+    }
+    if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
+        return "method";
+    }
+    if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node)) {
+        return "property";
+    }
+    return null;
+}
+function isExportedNode(ts, node) {
+    return ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+function isDefaultExportNode(ts, node) {
+    return ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword));
+}
+function collectDecoratorNames(ts, node) {
+    const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+    return decorators
+        .map((decorator) => getDecoratorName(ts, decorator))
+        .filter((name) => Boolean(name));
+}
+function getDecoratorName(ts, decorator) {
+    const expression = decorator.expression;
+    const target = ts.isCallExpression(expression) ? expression.expression : expression;
+    if (ts.isIdentifier(target) || ts.isPropertyAccessExpression(target)) {
+        return `@${target.getText()}`;
+    }
+    return null;
+}
+function createExportDeclarationSymbol(ts, sourceFile, statement, localDeclarations) {
+    const moduleText = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+        ? statement.moduleSpecifier.getText(sourceFile)
+        : "";
+    if (!statement.exportClause) {
+        const display = moduleText ? `export * from ${moduleText}` : "export *";
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name: display,
+            kind: "export",
+            selector: display,
+            display,
+            exported: true
+        });
+    }
+    if (!ts.isNamedExports(statement.exportClause)) {
+        return null;
+    }
+    const elements = statement.exportClause.elements;
+    if (elements.length === 0) {
+        return null;
+    }
+    if (elements.length === 1) {
+        const element = elements[0];
+        const exportedName = element.name.text;
+        const localName = element.propertyName?.text ?? exportedName;
+        const target = localDeclarations.get(localName);
+        if (exportedName === "default") {
+            const display = moduleText
+                ? `export { ${localName === exportedName ? exportedName : `${localName} as ${exportedName}`} } from ${moduleText}`
+                : target
+                    ? undefined
+                    : `export default${localName !== "default" ? ` ${localName}` : ""}`;
+            return createSyntheticSymbol(ts, sourceFile, statement, {
+                name: "default",
+                kind: "export",
+                selector: "default",
+                exported: true,
+                exportKind: "default",
+                exportTarget: target ? { name: target.name, kind: target.kind } : undefined,
+                sourceModule: moduleText ? elementFromQuotedModule(moduleText) : undefined,
+                display
+            });
+        }
+        const display = `export { ${localName === exportedName ? exportedName : `${localName} as ${exportedName}`} }${moduleText ? ` from ${moduleText}` : ""}`;
+        return createSyntheticSymbol(ts, sourceFile, statement, {
+            name: exportedName,
+            kind: "export",
+            selector: display,
+            display,
+            exported: true,
+            sourceModule: moduleText ? elementFromQuotedModule(moduleText) : undefined
+        });
+    }
+    const display = `export { ${elements.map((element) => {
+        const exportedName = element.name.text;
+        const localName = element.propertyName?.text ?? exportedName;
+        return localName === exportedName ? exportedName : `${localName} as ${exportedName}`;
+    }).join(", ")} }${moduleText ? ` from ${moduleText}` : ""}`;
+    return createSyntheticSymbol(ts, sourceFile, statement, {
+        name: display,
+        kind: "export",
+        selector: display,
+        display,
+        exported: true,
+        sourceModule: moduleText ? elementFromQuotedModule(moduleText) : undefined
+    });
+}
+function elementFromQuotedModule(moduleText) {
+    return moduleText.replace(/^["']|["']$/g, "");
+}
+function unwrapVoidExpression(ts, expression) {
+    return ts.isVoidExpression(expression) ? expression.expression : expression;
+}
+function getIifeInfo(ts, expression) {
+    if (!ts.isCallExpression(expression)) {
+        return null;
+    }
+    const callee = ts.isParenthesizedExpression(expression.expression) ? expression.expression.expression : expression.expression;
+    if (!ts.isFunctionExpression(callee) && !ts.isArrowFunction(callee)) {
+        return null;
+    }
+    const isAsync = Boolean(callee.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword));
+    return { functionNode: callee, async: isAsync };
+}
+function getIifeFunctionName(ts, node) {
+    return ts.isFunctionExpression(node) && node.name ? node.name.text : null;
+}
+function summarizeTopLevelExpression(ts, sourceFile, expression) {
+    if (ts.isAwaitExpression(expression)) {
+        return `await ${summarizeExpressionForDisplay(ts, sourceFile, expression.expression)}`;
+    }
+    if (ts.isCallExpression(expression)) {
+        return summarizeCallExpression(ts, sourceFile, expression);
+    }
+    if (ts.isBinaryExpression(expression) && isAssignmentOperator(ts, expression.operatorToken.kind)) {
+        return `${shortenExpressionText(expression.left.getText(sourceFile))} = ...`;
+    }
+    return null;
+}
+function summarizeExpressionForDisplay(ts, sourceFile, expression) {
+    if (ts.isCallExpression(expression)) {
+        return summarizeCallExpression(ts, sourceFile, expression);
+    }
+    return shortenExpressionText(expression.getText(sourceFile));
+}
+function summarizeCallExpression(_ts, sourceFile, expression) {
+    return `${shortenExpressionText(expression.expression.getText(sourceFile))}(...)`;
+}
+function isAssignmentOperator(ts, kind) {
+    return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+function shortenExpressionText(text) {
+    const compact = (0, inspect_source_ranges_1.normalizeWhitespace)(text.trim());
+    return compact.length <= 80 ? compact : `${compact.slice(0, 77)}...`;
+}
+async function collectStarExportSymbols(sourceFilePath, sourceText) {
+    const ts = typescript_1.default;
+    const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true);
+    const resolvedSymbols = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportDeclaration(statement) || statement.exportClause || !statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const moduleSpecifier = statement.moduleSpecifier.text;
+        const resolvedFilePath = resolveStarExportFilePath(sourceFilePath, moduleSpecifier);
+        if (!resolvedFilePath) {
+            continue;
+        }
+        try {
+            const targetSymbols = collectInspectSymbols(resolvedFilePath, fs.readFileSync(resolvedFilePath, "utf8"))
+                .filter((symbol) => symbol.exported)
+                .map((symbol) => ({
+                ...symbol,
+                sourceModule: moduleSpecifier
+            }));
+            resolvedSymbols.push(...targetSymbols);
+        }
+        catch {
+            continue;
+        }
+    }
+    return resolvedSymbols;
+}
+function resolveStarExportFilePath(sourceFilePath, specifier) {
+    if (!specifier.startsWith(".")) {
+        return null;
+    }
+    const documentDir = path.dirname(sourceFilePath);
+    const candidates = [
+        path.resolve(documentDir, specifier),
+        path.resolve(documentDir, specifier.replace(/\.js$/, ".ts")),
+        path.resolve(documentDir, `${specifier}.ts`),
+        path.resolve(documentDir, specifier, "index.ts")
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile()) ?? null;
+}
+function buildSignature(ts, sourceFile, node) {
+    if (ts.isVariableStatement(node) || ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+        return (0, inspect_source_ranges_1.firstLine)(stripLeadingDecoratorText(ts, sourceFile, node).trim());
+    }
+    const headerRange = getDeclarationHeaderRange(ts, sourceFile, node);
+    if (headerRange) {
+        return compactDecoratorCalls((0, inspect_source_ranges_1.normalizeWhitespace)(sourceFile.text.slice(headerRange.start, headerRange.end).trim()));
+    }
+    return (0, inspect_source_ranges_1.normalizeWhitespace)((0, inspect_source_ranges_1.firstLine)(stripLeadingDecoratorText(ts, sourceFile, node).trim()));
+}
+function stripLeadingDecoratorText(ts, sourceFile, node) {
+    const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+    const start = decorators.length > 0 ? decorators[decorators.length - 1].getEnd() : node.getStart(sourceFile);
+    return sourceFile.text.slice(start, node.getEnd());
+}
+function getDeclarationHeaderRange(ts, sourceFile, node) {
+    const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+    const start = decorators.length > 0 ? decorators[decorators.length - 1].getEnd() : node.getStart(sourceFile);
+    const body = getBodyNode(ts, node);
+    if (body) {
+        return { start, end: body.getStart(sourceFile) };
+    }
+    return null;
+}
+function getBodyNode(ts, node) {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)) {
+        return node.body ?? null;
+    }
+    if (ts.isClassDeclaration(node)) {
+        return node.members.length > 0 ? node.members[0] : null;
+    }
+    return null;
+}
+function compactDecoratorCalls(text) {
+    return text
+        .replace(/@([A-Za-z_$][\w$]*)(?:\s*\([^)]*\))?/g, "@$1")
+        .replace(/\(\s+/g, "(")
+        .replace(/\s+\)/g, ")");
+}
+function symbolToPayload(symbol, includeRanges) {
+    const payload = {
+        name: symbol.name,
+        kind: symbol.kind,
+        exported: symbol.exported,
+        path: symbol.path,
+        signature: symbol.signature
+    };
+    if (symbol.sourceModule) {
+        payload.sourceModule = symbol.sourceModule;
+    }
+    if (symbol.selector) {
+        payload.selector = symbol.selector;
+    }
+    if (symbol.display) {
+        payload.display = symbol.display;
+    }
+    if (symbol.exportKind) {
+        payload.exportKind = symbol.exportKind;
+    }
+    if (symbol.exportTarget) {
+        payload.exportTarget = {
+            name: symbol.exportTarget.name,
+            kind: symbol.exportTarget.kind
+        };
+    }
+    if (symbol.decoratorNames && symbol.decoratorNames.length > 0) {
+        payload.decorators = symbol.decoratorNames;
+    }
+    if (symbol.iife) {
+        payload.iife = true;
+        payload.async = symbol.iife.async;
+    }
+    if (symbol.overloadCount && symbol.overloadCount > 1) {
+        payload.overloadCount = symbol.overloadCount;
+        payload.overloadParts = symbol.overloadParts?.map((part) => ({
+            kind: part.kind,
+            range: (0, inspect_source_ranges_1.rangeToPayload)(part.range),
+            selectionRange: (0, inspect_source_ranges_1.rangeToPayload)(part.selectionRange)
+        })) ?? [];
+    }
+    if (includeRanges) {
+        payload.range = (0, inspect_source_ranges_1.rangeToPayload)(symbol.range);
+        payload.selectionRange = (0, inspect_source_ranges_1.rangeToPayload)(symbol.selectionRange);
+    }
+    return payload;
+}
+function findCodeSymbol(symbols, request) {
+    if (request.parentName) {
+        const parent = findSymbol(symbols, request.parentName, request.parentKind);
+        return parent ? findSymbol(parent.children, request.symbolName, request.symbolKind) : null;
+    }
+    return findSymbol(symbols, request.symbolName, request.symbolKind) ?? findSymbol(flattenSymbols(symbols), request.symbolName, request.symbolKind);
+}
+function findSymbol(symbols, name, kind) {
+    if (!name) {
+        return null;
+    }
+    const normalizedKind = kind ? (0, standalone_inspect_model_1.normalizeKind)(kind) : null;
+    const matches = symbols.filter((symbol) => (symbol.name === name || symbol.selector === name || symbol.exportKind === name) &&
+        (!normalizedKind || symbol.kind === normalizedKind));
+    return matches.length === 1 ? matches[0] ?? null : null;
+}
+function flattenSymbols(symbols) {
+    return symbols.flatMap((symbol) => [symbol, ...flattenSymbols(symbol.children)]);
+}