docs: function getDefinitionAtPosition(fileName, position) {
              synchronizeHostData();
              var sourceFile = getValidSourceFile(fileName);
              /// Triple slash reference comments
              var comment = findReferenceInPosition(sourceFile.referencedFiles, position);
              if (comment) {
                  var referenceFile = ts.tryResolveScriptReference(program, sourceFile, comment);
                  if (referenceFile) {
                      return [getDefinitionInfoForFileReference(comment.fileName, referenceFile.fileName)];
                  }
                  return undefined;
              }
              // Type reference directives
              var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
              if (typeReferenceDirective) {
                  var referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
                  if (referenceFile && referenceFile.resolvedFileName) {
                      return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
                  }
                  return undefined;
              }
              var node = ts.getTouchingPropertyName(sourceFile, position);
              if (node === sourceFile) {
                  return undefined;
              }
              // Labels
              if (isJumpStatementTarget(node)) {
                  var labelName = node.text;
                  var label = getTargetLabel(node.parent, node.text);
                  return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, /*containerName*/ undefined)] : undefined;
              }
              var typeChecker = program.getTypeChecker();
              var symbol = typeChecker.getSymbolAtLocation(node);
              // Could not find a symbol e.g. node is string or number keyword,
              // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
              if (!symbol) {
                  return undefined;
              }
              // If this is an alias, and the request came at the declaration location
              // get the aliased symbol instead. This allows for goto def on an import e.g.
              //   import {A, B} from "mod";
              // to jump to the implementation directly.
              if (symbol.flags & 8388608 /* Alias */) {
                  var declaration = symbol.declarations[0];
                  // Go to the original declaration for cases:
                  //
                  //   (1) when the aliased symbol was declared in the location(parent).
                  //   (2) when the aliased symbol is originating from a named import.
                  //
                  if (node.kind === 69 /* Identifier */ &&
                      (node.parent === declaration ||
                          (declaration.kind === 234 /* ImportSpecifier */ && declaration.parent && declaration.parent.kind === 233 /* NamedImports */))) {
                      symbol = typeChecker.getAliasedSymbol(symbol);
                  }
              }
              // Because name in short-hand property assignment has two different meanings: property name and property value,
              // using go-to-definition at such position should go to the variable declaration of the property value rather than
              // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
              // is performed at the location of property access, we would like to go to definition of the property in the short-hand
              // assignment. This case and others are handled by the following code.
              if (node.parent.kind === 254 /* ShorthandPropertyAssignment */) {
                  var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
                  if (!shorthandSymbol) {
                      return [];
                  }
                  var shorthandDeclarations = shorthandSymbol.getDeclarations();
                  var shorthandSymbolKind_1 = getSymbolKind(shorthandSymbol, node);
                  var shorthandSymbolName_1 = typeChecker.symbolToString(shorthandSymbol);
                  var shorthandContainerName_1 = typeChecker.symbolToString(symbol.parent, node);
                  return ts.map(shorthandDeclarations, function (declaration) { return createDefinitionInfo(declaration, shorthandSymbolKind_1, shorthandSymbolName_1, shorthandContainerName_1); });
              }
              return getDefinitionFromSymbol(symbol, node);
          }