tidewave 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,906 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/core.ts
-function isError(result) {
-  return result != null && "success" in result && result.success === false;
-}
-function isResolveError(result) {
-  return result != null && "success" in result && result.success === false;
-}
-function isExtractError(result) {
-  return result != null && "error" in result;
-}
-function resolveError(specifier, source) {
-  return {
-    success: false,
-    error: {
-      code: "MODULE_NOT_FOUND",
-      message: `Cannot resolve module '${specifier}' from '${source}'`
-    }
-  };
-}
-function createExtractError(code, message, details) {
-  return {
-    error: {
-      code,
-      message,
-      details
-    }
-  };
-}
-
-// src/resolution/module-resolver.ts
-import ts from "typescript";
-import path from "node:path";
-function loadTsConfig(prefix) {
-  const projectPath = prefix || process.cwd();
-  const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, "tsconfig.json");
-  let compilerOptions = {
-    target: ts.ScriptTarget.ES2020,
-    module: ts.ModuleKind.CommonJS,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true,
-    skipLibCheck: true,
-    allowJs: true,
-    declaration: true,
-    typeRoots: ["./node_modules/@types"],
-    baseUrl: "."
-  };
-  let rootNames = [];
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (configFile.config) {
-      const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
-      compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-      rootNames = parsedConfig.fileNames;
-    }
-  }
-  return {
-    fileNames: rootNames,
-    options: compilerOptions
-  };
-}
-function resolveModule(moduleName, compilerOptions) {
-  if (moduleName.startsWith("./") || moduleName.startsWith("../") || moduleName.includes(".") && !moduleName.includes("/")) {
-    const absolutePath = path.resolve(moduleName);
-    if (ts.sys.fileExists(absolutePath)) {
-      const dedicatedProgram = ts.createProgram([absolutePath], compilerOptions);
-      const sourceFile = dedicatedProgram.getSourceFile(absolutePath);
-      if (sourceFile) {
-        return { sourceFile, program: dedicatedProgram };
-      }
-    }
-  }
-  const moduleResolver = ts.resolveModuleName(moduleName, path.resolve("./index.ts"), compilerOptions, ts.sys);
-  if (moduleResolver.resolvedModule) {
-    const { resolvedFileName } = moduleResolver.resolvedModule;
-    const dedicatedProgram = ts.createProgram([resolvedFileName], compilerOptions);
-    const sourceFile = dedicatedProgram.getSourceFile(resolvedFileName);
-    if (sourceFile) {
-      return { sourceFile, program: dedicatedProgram };
-    }
-  }
-  return resolveError(moduleName, process.cwd());
-}
-function resolveNodeBuiltin(moduleName, compilerOptions) {
-  if (!moduleName.startsWith("node:")) {
-    return resolveError(moduleName, process.cwd());
-  }
-  const symbolName = moduleName.slice(5);
-  const globalBuiltins = [
-    "Math",
-    "Date",
-    "JSON",
-    "Object",
-    "Array",
-    "String",
-    "Number",
-    "Boolean",
-    "RegExp",
-    "Function",
-    "Promise",
-    "Map",
-    "Set",
-    "WeakMap",
-    "WeakSet",
-    "Symbol",
-    "Error",
-    "console",
-    "process",
-    "Buffer",
-    "global",
-    "__dirname",
-    "__filename"
-  ];
-  if (globalBuiltins.includes(symbolName)) {
-    const syntheticContent = `declare const ${symbolName}: typeof globalThis.${symbolName};`;
-    const syntheticFileName = `synthetic-global-${symbolName}.d.ts`;
-    const host = ts.createCompilerHost(compilerOptions);
-    const originalGetSourceFile = host.getSourceFile;
-    host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-      if (fileName === syntheticFileName) {
-        return ts.createSourceFile(fileName, syntheticContent, ts.ScriptTarget.Latest, true);
-      }
-      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-    };
-    const dedicatedProgram = ts.createProgram([syntheticFileName], compilerOptions, host);
-    const sourceFile = dedicatedProgram.getSourceFile(syntheticFileName);
-    if (sourceFile) {
-      return { sourceFile, program: dedicatedProgram };
-    }
-  }
-  return resolveError(moduleName, process.cwd());
-}
-
-// src/resolution/utils.ts
-import ts2 from "typescript";
-import path2 from "node:path";
-function getLocation(symbol) {
-  if (symbol.valueDeclaration) {
-    const sourceFile = symbol.valueDeclaration.getSourceFile();
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(symbol.valueDeclaration.getStart());
-    let { fileName } = sourceFile;
-    const cwd = process.cwd();
-    if (fileName.startsWith(cwd)) {
-      fileName = path2.relative(cwd, fileName);
-    }
-    return `${fileName}:${line + 1}:${character + 1}`;
-  }
-  if (symbol.declarations && symbol.declarations.length > 0) {
-    const [firstDeclaration] = symbol.declarations;
-    const sourceFile = firstDeclaration?.getSourceFile();
-    if (sourceFile === undefined || firstDeclaration === undefined)
-      return "unknown";
-    const { line, character } = sourceFile.getLineAndCharacterOfPosition(firstDeclaration.getStart());
-    let fileName = sourceFile?.fileName;
-    const cwd = process.cwd();
-    if (fileName?.startsWith(cwd)) {
-      fileName = path2.relative(cwd, fileName);
-    }
-    return `${fileName}:${line + 1}:${character + 1}`;
-  }
-  return "unknown";
-}
-function getDocumentation(checker, symbol) {
-  return ts2.displayPartsToString(symbol.getDocumentationComment(checker));
-}
-function getJSDoc(checker, symbol) {
-  const jsDocTags = symbol.getJsDocTags(checker);
-  return jsDocTags.map((tag) => {
-    const tagName = tag.name;
-    const tagText = tag.text ? ts2.displayPartsToString(tag.text) : "";
-    return `@${tagName}${tagText ? " " + tagText : ""}`;
-  }).join(`
-`);
-}
-function getSymbolKind(symbol) {
-  const flags = symbol.getFlags();
-  if (flags & ts2.SymbolFlags.Function)
-    return "function";
-  if (flags & ts2.SymbolFlags.Class)
-    return "class";
-  if (flags & ts2.SymbolFlags.Interface)
-    return "interface";
-  if (flags & ts2.SymbolFlags.TypeAlias)
-    return "type";
-  if (flags & ts2.SymbolFlags.Variable)
-    return "variable";
-  if (flags & ts2.SymbolFlags.Property)
-    return "property";
-  if (flags & ts2.SymbolFlags.Method)
-    return "method";
-  if (flags & ts2.SymbolFlags.Enum)
-    return "enum";
-  if (flags & ts2.SymbolFlags.Module)
-    return "module";
-  if (symbol.valueDeclaration) {
-    if (ts2.isFunctionDeclaration(symbol.valueDeclaration)) {
-      return "function";
-    }
-    if (ts2.isClassDeclaration(symbol.valueDeclaration)) {
-      return "class";
-    }
-    if (ts2.isVariableDeclaration(symbol.valueDeclaration)) {
-      return "variable";
-    }
-    if (ts2.isMethodDeclaration(symbol.valueDeclaration)) {
-      return "method";
-    }
-  }
-  return "unknown";
-}
-
-// src/resolution/formatters.ts
-import ts3 from "typescript";
-function getSignature(checker, symbol, type) {
-  const signatures = checker.getSignaturesOfType(type, ts3.SignatureKind.Call);
-  if (signatures.length > 0) {
-    return signatures.map((sig) => {
-      const sigString = checker.signatureToString(sig);
-      return `${symbol.getName()}${sigString}`;
-    }).join(`
-`);
-  }
-  const constructSignatures = checker.getSignaturesOfType(type, ts3.SignatureKind.Construct);
-  if (constructSignatures.length > 0) {
-    return constructSignatures.map((sig) => "new " + checker.signatureToString(sig)).join(`
-`);
-  }
-  if (symbol.valueDeclaration || symbol.declarations && symbol.declarations.length > 0) {
-    const declaration = symbol.valueDeclaration || symbol.declarations[0];
-    if (!declaration)
-      return checker.typeToString(type);
-    const sourceFile = declaration.getSourceFile();
-    if (ts3.isFunctionDeclaration(declaration) && declaration.name) {
-      const functionType = checker.getTypeOfSymbolAtLocation(symbol, declaration);
-      const functionSignatures = checker.getSignaturesOfType(functionType, ts3.SignatureKind.Call);
-      if (functionSignatures.length > 0) {
-        return functionSignatures.map((sig) => checker.signatureToString(sig)).join(`
-`);
-      }
-    }
-    if (ts3.isInterfaceDeclaration(declaration) || ts3.isTypeAliasDeclaration(declaration)) {
-      const start2 = declaration.getStart();
-      const end2 = declaration.getEnd();
-      const text2 = sourceFile.text.substring(start2, end2);
-      const lines = text2.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
-      if (ts3.isInterfaceDeclaration(declaration)) {
-        const bodyStart = text2.indexOf("{");
-        const bodyEnd = text2.lastIndexOf("}");
-        if (bodyStart !== -1 && bodyEnd !== -1) {
-          const body = text2.substring(bodyStart, bodyEnd + 1);
-          const interfaceName = `interface ${declaration.name.text}`;
-          const compactBody = body.replace(/\s*\n\s*/g, " ").replace(/\s+/g, " ");
-          return `${interfaceName} ${compactBody}`;
-        }
-      }
-      return lines.join(" ").replace(/\s+/g, " ");
-    }
-    if (ts3.isClassDeclaration(declaration)) {
-      const classType = checker.getTypeOfSymbolAtLocation(symbol, declaration);
-      const classConstructSignatures = checker.getSignaturesOfType(classType, ts3.SignatureKind.Construct);
-      if (classConstructSignatures.length > 0) {
-        return classConstructSignatures.map((sig) => "new " + checker.signatureToString(sig)).join(`
-`);
-      } else {
-        const start2 = declaration.getStart();
-        const end2 = Math.min(declaration.getStart() + 100, declaration.getEnd());
-        const text2 = sourceFile.text.substring(start2, end2);
-        return text2.split(`
-`)[0]?.trim() + (text2.includes(`
-`) ? "..." : "") || "";
-      }
-    }
-    const start = declaration.getStart();
-    const end = Math.min(declaration.getStart() + 100, declaration.getEnd());
-    const text = sourceFile.text.substring(start, end);
-    return text.split(`
-`)[0]?.trim() + (text.includes(`
-`) ? "..." : "") || "";
-  }
-  return checker.typeToString(type);
-}
-function getTypeString(checker, symbol, type) {
-  if (symbol.flags & (ts3.SymbolFlags.Interface | ts3.SymbolFlags.TypeAlias)) {
-    const declaration = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
-    if (declaration && ts3.isInterfaceDeclaration(declaration)) {
-      const properties = type.getProperties();
-      if (properties.length > 0) {
-        const propertyStrings = properties.map((prop) => {
-          const propDeclaration = prop.valueDeclaration || prop.declarations && prop.declarations[0];
-          const propType = propDeclaration ? checker.getTypeOfSymbolAtLocation(prop, propDeclaration) : checker.getTypeAtLocation(prop.declarations[0]);
-          const propTypeString = checker.typeToString(propType);
-          const isOptional = prop.flags & ts3.SymbolFlags.Optional;
-          return `${prop.getName()}${isOptional ? "?" : ""}: ${propTypeString}`;
-        });
-        return `{ ${propertyStrings.join("; ")} }`;
-      }
-    }
-  }
-  const defaultTypeString = checker.typeToString(type);
-  if (defaultTypeString === "any" && symbol.flags & ts3.SymbolFlags.Interface) {
-    return `interface ${symbol.getName()}`;
-  }
-  return defaultTypeString;
-}
-function formatOutput(info) {
-  const output = [];
-  output.push(`
-${info.name}`);
-  output.push(`Kind: ${info.kind}`);
-  output.push(`Location: ${info.location}`);
-  output.push("");
-  if (info.signature) {
-    output.push("Signature:");
-    output.push(info.signature);
-    output.push("");
-  }
-  if (info.documentation) {
-    output.push("Documentation:");
-    output.push(info.documentation);
-    output.push("");
-  }
-  if (info.jsDoc) {
-    output.push("JSDoc Tags:");
-    output.push(info.jsDoc);
-    output.push("");
-  }
-  output.push("Type:");
-  output.push(info.type);
-  return output.join(`
-`);
-}
-
-// src/resolution/symbol-finder.ts
-import ts4 from "typescript";
-function findSymbolInJavaScriptFile(sourceFile, checker, symbolName) {
-  for (const statement of sourceFile.statements) {
-    if (ts4.isFunctionDeclaration(statement) && statement.name?.text === symbolName) {
-      return checker.getSymbolAtLocation(statement.name);
-    }
-    if (ts4.isClassDeclaration(statement) && statement.name?.text === symbolName) {
-      return checker.getSymbolAtLocation(statement.name);
-    }
-    if (ts4.isVariableStatement(statement)) {
-      for (const declaration of statement.declarationList.declarations) {
-        if (ts4.isIdentifier(declaration.name) && declaration.name.text === symbolName) {
-          return checker.getSymbolAtLocation(declaration.name);
-        }
-      }
-    }
-    if (ts4.isExpressionStatement(statement)) {
-      const { expression } = statement;
-      if (ts4.isBinaryExpression(expression) && expression.operatorToken.kind === ts4.SyntaxKind.EqualsToken) {
-        const { left, right } = expression;
-        if (ts4.isPropertyAccessExpression(left) && ts4.isIdentifier(left.expression) && left.expression.text === "module" && ts4.isIdentifier(left.name) && left.name.text === "exports" && ts4.isObjectLiteralExpression(right)) {
-          for (const prop of right.properties) {
-            if (ts4.isPropertyAssignment(prop) || ts4.isShorthandPropertyAssignment(prop)) {
-              const propName = ts4.isIdentifier(prop.name) ? prop.name.text : undefined;
-              if (propName === symbolName) {
-                let targetIdentifier;
-                if (ts4.isShorthandPropertyAssignment(prop)) {
-                  targetIdentifier = prop.name;
-                } else if (ts4.isPropertyAssignment(prop) && ts4.isIdentifier(prop.initializer)) {
-                  targetIdentifier = prop.initializer;
-                }
-                if (targetIdentifier) {
-                  for (const statement2 of sourceFile.statements) {
-                    if (ts4.isFunctionDeclaration(statement2) && statement2.name?.text === targetIdentifier.text) {
-                      const originalSymbol = checker.getSymbolAtLocation(statement2.name);
-                      if (originalSymbol) {
-                        return originalSymbol;
-                      }
-                    }
-                    if (ts4.isClassDeclaration(statement2) && statement2.name?.text === targetIdentifier.text) {
-                      const originalSymbol = checker.getSymbolAtLocation(statement2.name);
-                      if (originalSymbol) {
-                        return originalSymbol;
-                      }
-                    }
-                    if (ts4.isVariableStatement(statement2)) {
-                      for (const declaration of statement2.declarationList.declarations) {
-                        if (ts4.isIdentifier(declaration.name) && declaration.name.text === targetIdentifier.text) {
-                          const originalSymbol = checker.getSymbolAtLocation(declaration.name);
-                          if (originalSymbol) {
-                            return originalSymbol;
-                          }
-                        }
-                      }
-                    }
-                  }
-                  const exportSymbol = checker.getSymbolAtLocation(targetIdentifier);
-                  return exportSymbol;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return;
-}
-function getSymbolInfo(checker, symbol, member, isStatic) {
-  const declaration = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
-  if (!declaration && (!symbol.declarations || symbol.declarations.length === 0)) {
-    return createExtractError("TYPE_ERROR", `Symbol '${symbol.getName()}' has no declarations`);
-  }
-  const targetDeclaration = declaration || symbol.declarations[0];
-  const type = checker.getTypeOfSymbolAtLocation(symbol, targetDeclaration);
-  const symbolName = symbol.getName();
-  let targetSymbol = symbol;
-  let targetType = type;
-  let name = symbolName;
-  if (member) {
-    if (isStatic) {
-      const staticMembers = checker.getPropertiesOfType(type);
-      const staticMember = staticMembers.find((s) => s.getName() === member);
-      if (staticMember) {
-        targetSymbol = staticMember;
-        targetType = checker.getTypeOfSymbolAtLocation(staticMember, staticMember.valueDeclaration);
-        name = `${symbolName}.${member}`;
-      } else {
-        return createExtractError("MEMBER_NOT_FOUND", `Static member '${member}' not found on '${symbolName}'`);
-      }
-    } else {
-      let instanceType;
-      if (symbol.flags & ts4.SymbolFlags.Class) {
-        instanceType = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
-        const constructSignatures = instanceType.getConstructSignatures();
-        if (constructSignatures.length > 0) {
-          const [constructSignature] = constructSignatures;
-          if (constructSignature) {
-            const instanceTypeFromConstruct = checker.getReturnTypeOfSignature(constructSignature);
-            const instanceMembers = checker.getPropertiesOfType(instanceTypeFromConstruct);
-            const instanceMember = instanceMembers.find((s) => s.getName() === member);
-            if (instanceMember) {
-              targetSymbol = instanceMember;
-              targetType = checker.getTypeOfSymbolAtLocation(instanceMember, instanceMember.valueDeclaration);
-              name = `${symbolName}#${member}`;
-            } else {
-              return createExtractError("MEMBER_NOT_FOUND", `Instance member '${member}' not found on '${symbolName}'. Available: ${instanceMembers.map((m) => m.getName()).join(", ")}`);
-            }
-          }
-        } else {
-          const instanceMembers = checker.getPropertiesOfType(instanceType);
-          const instanceMember = instanceMembers.find((s) => s.getName() === member);
-          if (instanceMember) {
-            targetSymbol = instanceMember;
-            targetType = checker.getTypeOfSymbolAtLocation(instanceMember, instanceMember.valueDeclaration);
-            name = `${symbolName}#${member}`;
-          } else {
-            return createExtractError("MEMBER_NOT_FOUND", `Instance member '${member}' not found on '${symbolName}'. Available: ${instanceMembers.map((m) => m.getName()).join(", ")}`);
-          }
-        }
-      } else {
-        const callSignatures = type.getCallSignatures();
-        const constructSignatures = type.getConstructSignatures();
-        if (constructSignatures.length > 0) {
-          const [constructSignature] = constructSignatures;
-          if (constructSignature) {
-            instanceType = checker.getReturnTypeOfSignature(constructSignature);
-          }
-        } else if (callSignatures.length > 0) {
-          const [callSignature] = callSignatures;
-          if (callSignature) {
-            instanceType = checker.getReturnTypeOfSignature(callSignature);
-          }
-        }
-        if (instanceType) {
-          const instanceMembers = checker.getPropertiesOfType(instanceType);
-          const instanceMember = instanceMembers.find((s) => s.getName() === member);
-          if (instanceMember) {
-            targetSymbol = instanceMember;
-            targetType = checker.getTypeOfSymbolAtLocation(instanceMember, instanceMember.valueDeclaration);
-            name = `${symbolName}#${member}`;
-          } else {
-            return createExtractError("MEMBER_NOT_FOUND", `Instance member '${member}' not found on '${symbolName}'`);
-          }
-        } else {
-          return createExtractError("TYPE_ERROR", `'${symbolName}' is not a constructor or class`);
-        }
-      }
-    }
-  }
-  const typeString = getTypeString(checker, targetSymbol, targetType);
-  const signature = getSignature(checker, targetSymbol, targetType);
-  const documentation = getDocumentation(checker, targetSymbol);
-  const jsDoc = getJSDoc(checker, targetSymbol);
-  const kind = getSymbolKind(targetSymbol);
-  const location = getLocation(targetSymbol);
-  return {
-    name,
-    kind,
-    type: typeString,
-    documentation,
-    jsDoc,
-    signature,
-    location
-  };
-}
-
-// src/resolution/index.ts
-import ts5 from "typescript";
-import path3 from "node:path";
-function parseModulePath(modulePath) {
-  let module;
-  let symbolPath;
-  if (modulePath.startsWith("node:")) {
-    const nodeSymbol = modulePath.slice(5);
-    const [baseSymbol] = nodeSymbol.split(".");
-    module = `node:${baseSymbol}`;
-    symbolPath = nodeSymbol;
-  } else {
-    const [mod, symPath] = modulePath.split(":");
-    if (!mod || !symPath) {
-      return createExtractError("INVALID_REQUEST", `Invalid format. Expected 'module:symbol', got '${modulePath}'`);
-    }
-    module = mod;
-    symbolPath = symPath;
-  }
-  if (symbolPath.includes("#")) {
-    const [symbol, member] = symbolPath.split("#");
-    if (!symbol || !member) {
-      return createExtractError("INVALID_REQUEST", `Invalid format. Expected 'symbol#instance-member', got '${symbolPath}'`);
-    }
-    return { module, symbol, member, isStatic: false };
-  }
-  if (symbolPath.includes(".")) {
-    const [symbol, member] = symbolPath.split(".");
-    if (!symbol || !member) {
-      return createExtractError("INVALID_REQUEST", `Invalid format. Expected 'symbol.static-member', got '${symbolPath}'`);
-    }
-    return { module, symbol, member, isStatic: true };
-  }
-  return { module, symbol: symbolPath, member: undefined, isStatic: false };
-}
-async function extractDocs(modulePath) {
-  const options = { prefix: process.cwd() };
-  const parseResult = parseModulePath(modulePath);
-  if ("error" in parseResult) {
-    return parseResult;
-  }
-  const { module, symbol, member, isStatic } = parseResult;
-  const config = loadTsConfig(options.prefix);
-  let resolvedModule = resolveModule(module, config.options);
-  let isGlobalModule = false;
-  if (isResolveError(resolvedModule)) {
-    const nodeBuiltinResolution = resolveNodeBuiltin(module, config.options);
-    if (!isResolveError(nodeBuiltinResolution)) {
-      resolvedModule = nodeBuiltinResolution;
-      isGlobalModule = true;
-    }
-  }
-  if (isResolveError(resolvedModule)) {
-    return createExtractError("MODULE_NOT_FOUND", `Module '${module}' not found`);
-  }
-  const { sourceFile, program } = resolvedModule;
-  const checker = program.getTypeChecker();
-  let targetSymbol;
-  if (isGlobalModule) {
-    const actualSymbolName = module.startsWith("node:") ? module.slice(5) : module;
-    const globalSymbols = checker.getSymbolsInScope(sourceFile, ts5.SymbolFlags.Value);
-    targetSymbol = globalSymbols.find((s) => s.getName() === actualSymbolName);
-    if (!targetSymbol) {
-      const [identifierNode] = sourceFile.statements;
-      if (identifierNode && ts5.isVariableStatement(identifierNode)) {
-        const [declaration] = identifierNode.declarationList.declarations;
-        if (declaration && ts5.isVariableDeclaration(declaration) && declaration.initializer) {
-          targetSymbol = checker.getSymbolAtLocation(declaration.initializer);
-        }
-      }
-    }
-  } else {
-    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-    if (moduleSymbol) {
-      const exports = checker.getExportsOfModule(moduleSymbol);
-      const exportSymbol = exports.find((exp) => exp.getName() === symbol);
-      if (exportSymbol) {
-        if (exportSymbol.valueDeclaration && (ts5.isFunctionDeclaration(exportSymbol.valueDeclaration) || ts5.isClassDeclaration(exportSymbol.valueDeclaration) || ts5.isVariableDeclaration(exportSymbol.valueDeclaration))) {
-          targetSymbol = exportSymbol;
-        } else if (exportSymbol.flags & (ts5.SymbolFlags.Interface | ts5.SymbolFlags.TypeAlias)) {
-          targetSymbol = exportSymbol;
-        } else {
-          targetSymbol = findSymbolInJavaScriptFile(sourceFile, checker, symbol);
-        }
-      } else {
-        return createExtractError("SYMBOL_NOT_FOUND", `Symbol '${symbol}' not found in module '${module}'. Available exports: ${exports.map((e) => e.getName()).join(", ")}`);
-      }
-    } else {
-      targetSymbol = findSymbolInJavaScriptFile(sourceFile, checker, symbol);
-      if (!targetSymbol) {
-        return createExtractError("SYMBOL_NOT_FOUND", `Symbol '${symbol}' not found in JavaScript module '${module}'`);
-      }
-    }
-  }
-  if (!targetSymbol) {
-    let symbolToShow;
-    if (isGlobalModule) {
-      symbolToShow = module.startsWith("node:") ? module.slice(5) : module;
-    } else {
-      symbolToShow = symbol;
-    }
-    return createExtractError("SYMBOL_NOT_FOUND", `Symbol '${symbolToShow}' not found`);
-  }
-  const result = getSymbolInfo(checker, targetSymbol, member, isStatic);
-  return result;
-}
-async function getSourceLocation(reference) {
-  const options = { prefix: process.cwd() };
-  if (reference.includes(":")) {
-    const parseResult = parseModulePath(reference);
-    if ("error" in parseResult) {
-      return {
-        success: false,
-        error: {
-          code: "MODULE_NOT_FOUND",
-          message: parseResult.error.message
-        }
-      };
-    }
-    const { module, symbol, member, isStatic } = parseResult;
-    const config2 = loadTsConfig(options.prefix);
-    let resolvedModule = resolveModule(module, config2.options);
-    let isGlobalModule = false;
-    if (isResolveError(resolvedModule)) {
-      const nodeBuiltinResolution = resolveNodeBuiltin(module, config2.options);
-      if (!isResolveError(nodeBuiltinResolution)) {
-        resolvedModule = nodeBuiltinResolution;
-        isGlobalModule = true;
-      }
-    }
-    if (isResolveError(resolvedModule)) {
-      return {
-        success: false,
-        error: {
-          code: "MODULE_NOT_FOUND",
-          message: `Module '${module}' not found`
-        }
-      };
-    }
-    const { sourceFile, program } = resolvedModule;
-    const checker = program.getTypeChecker();
-    let targetSymbol;
-    if (isGlobalModule) {
-      const actualSymbolName = module.startsWith("node:") ? module.slice(5) : module;
-      const globalSymbols = checker.getSymbolsInScope(sourceFile, ts5.SymbolFlags.Value);
-      targetSymbol = globalSymbols.find((s) => s.getName() === actualSymbolName);
-      if (!targetSymbol) {
-        const [identifierNode] = sourceFile.statements;
-        if (identifierNode && ts5.isVariableStatement(identifierNode)) {
-          const [declaration] = identifierNode.declarationList.declarations;
-          if (declaration && ts5.isVariableDeclaration(declaration) && declaration.initializer) {
-            targetSymbol = checker.getSymbolAtLocation(declaration.initializer);
-          }
-        }
-      }
-    } else {
-      const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-      if (moduleSymbol) {
-        const exports = checker.getExportsOfModule(moduleSymbol);
-        const exportSymbol = exports.find((exp) => exp.getName() === symbol);
-        if (exportSymbol) {
-          targetSymbol = exportSymbol;
-        } else {
-          return {
-            success: false,
-            error: {
-              code: "MODULE_NOT_FOUND",
-              message: `Symbol '${symbol}' not found in module '${module}'`
-            }
-          };
-        }
-      } else {
-        targetSymbol = findSymbolInJavaScriptFile(sourceFile, checker, symbol);
-        if (!targetSymbol) {
-          return {
-            success: false,
-            error: {
-              code: "MODULE_NOT_FOUND",
-              message: `Symbol '${symbol}' not found in JavaScript module '${module}'`
-            }
-          };
-        }
-      }
-    }
-    if (!targetSymbol) {
-      return {
-        success: false,
-        error: {
-          code: "MODULE_NOT_FOUND",
-          message: `Symbol '${symbol}' not found`
-        }
-      };
-    }
-    const symbolInfo = getSymbolInfo(checker, targetSymbol, member, isStatic);
-    if (isExtractError(symbolInfo)) {
-      return {
-        success: false,
-        error: {
-          code: "MODULE_NOT_FOUND",
-          message: symbolInfo.error.message
-        }
-      };
-    }
-    return { path: symbolInfo.location, format: "typescript" };
-  }
-  const moduleName = reference;
-  if (moduleName.startsWith("./") || moduleName.startsWith("../")) {
-    const absolutePath = path3.resolve(moduleName);
-    if (ts5.sys.fileExists(absolutePath)) {
-      const cwd = process.cwd();
-      let finalPath;
-      if (absolutePath.startsWith(cwd)) {
-        const relativePath = path3.relative(cwd, absolutePath);
-        finalPath = relativePath.startsWith("..") ? absolutePath : relativePath;
-      } else {
-        finalPath = absolutePath;
-      }
-      return { path: finalPath, format: "typescript" };
-    }
-  }
-  const config = loadTsConfig(options.prefix);
-  const moduleResolver = ts5.resolveModuleName(moduleName, path3.resolve("./index.ts"), config.options, ts5.sys);
-  if (moduleResolver.resolvedModule) {
-    const { resolvedFileName } = moduleResolver.resolvedModule;
-    const cwd = process.cwd();
-    let finalPath;
-    if (resolvedFileName.startsWith(cwd)) {
-      const relativePath = path3.relative(cwd, resolvedFileName);
-      finalPath = relativePath.startsWith("..") ? resolvedFileName : relativePath;
-    } else {
-      finalPath = resolvedFileName;
-    }
-    return { path: finalPath, format: "typescript" };
-  }
-  return resolveError(moduleName, process.cwd());
-}
-async function extractSymbol(request, options = {}) {
-  try {
-    if (!request.symbol) {
-      return {
-        error: {
-          code: "INVALID_REQUEST",
-          message: "Symbol name is required"
-        }
-      };
-    }
-    const config = loadTsConfig(options.prefix);
-    const resolvedModule = resolveModule(request.module, config.options);
-    if (isResolveError(resolvedModule)) {
-      return {
-        error: {
-          code: "MODULE_NOT_FOUND",
-          message: `Module '${request.module}' not found`
-        }
-      };
-    }
-    const { sourceFile, program } = resolvedModule;
-    const checker = program.getTypeChecker();
-    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-    let targetSymbol;
-    if (moduleSymbol) {
-      const exports = checker.getExportsOfModule(moduleSymbol);
-      targetSymbol = exports.find((exp) => exp.getName() === request.symbol);
-      if (!targetSymbol) {
-        return {
-          error: {
-            code: "SYMBOL_NOT_FOUND",
-            message: `Symbol '${request.symbol}' not found in module '${request.module}'. Available exports: ${exports.map((e) => e.getName()).join(", ")}`
-          }
-        };
-      }
-    } else {
-      targetSymbol = findSymbolInJavaScriptFile(sourceFile, checker, request.symbol);
-      if (!targetSymbol) {
-        return {
-          error: {
-            code: "SYMBOL_NOT_FOUND",
-            message: `Symbol '${request.symbol}' not found in JavaScript module '${request.module}'`
-          }
-        };
-      }
-    }
-    const result = getSymbolInfo(checker, targetSymbol, request.member, request.isStatic);
-    return result;
-  } catch (error) {
-    return {
-      error: {
-        code: "PARSE_ERROR",
-        message: `Extraction failed: ${error instanceof Error ? error.message : String(error)}`
-      }
-    };
-  }
-}
-// src/evaluation/eval_worker.ts
-process.on("message", async ({ code, args }) => {
-  if (!process.send) {
-    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
-    process.exit(1);
-  }
-  try {
-    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
-    const fn = new AsyncFunction(code);
-    const result = await fn(...args);
-    process.send({
-      type: "result",
-      success: true,
-      data: (result || null) && result
-    });
-  } catch (error) {
-    process.send({
-      type: "result",
-      success: false,
-      data: new String(error)
-    });
-  }
-  process.exit(0);
-});
-
-// src/evaluation/code_executor.ts
-import { fork } from "child_process";
-async function executeIsolated(request) {
-  return new Promise((resolve) => {
-    const workerPath = __require.resolve("./eval_worker");
-    const child = fork(workerPath, { silent: true });
-    const evaluation = {
-      success: false,
-      result: null,
-      stdout: "",
-      stderr: ""
-    };
-    child.stdout?.on("data", (data) => {
-      evaluation.stdout += data.toString();
-    });
-    child.stderr?.on("data", (data) => {
-      evaluation.stderr += data.toString();
-    });
-    child.on("message", (msg) => {
-      if (msg.type === "result") {
-        const { data, success } = msg;
-        evaluation.result = data;
-        evaluation.success = success;
-      }
-    });
-    child.on("exit", (code) => {
-      resolve({
-        success: evaluation.success && code === 0,
-        result: evaluation.result,
-        stdout: evaluation.stdout.trim(),
-        stderr: evaluation.stderr.trim()
-      });
-    });
-    const { timeout } = request;
-    const timeoutId = setTimeout(() => {
-      child.kill("SIGKILL");
-      resolve({
-        success: false,
-        result: `Evaluation timed out after ${timeout} milliseconds`,
-        stdout: evaluation.stdout,
-        stderr: evaluation.stderr
-      });
-    }, timeout);
-    child.on("exit", () => clearTimeout(timeoutId));
-    child.send(request);
-  });
-}
-
-// src/index.ts
-var Tidewave = {
-  extractDocs,
-  getSourceLocation,
-  formatOutput,
-  executeIsolated
-};
-export {
-  Tidewave
-};