You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: dns.go
    path of file: ./repos/jaeles/core
    
    the code of the file until where you have to start completion: package core

import (
	"fmt"
	"github.com/jaeles-project/jaeles/dns"
	"github.com/jaeles-project/jaeles/libs"
	"github.com/jaeles-project/jaeles/utils"
	"github.com/robertkrimen/otto"
	"regexp"
	"strings"
)

// InitDNSRunner init task
func InitDNSRunner(url string, sign libs.Signature, opt libs.Options) (Runner, error) {
	var runner Runner
	runner.In
    
func (r *Record) DnsDetector() bool {
	record := *r
	var extra string
	vm := otto.New()

	// Only for dns detection
	vm.Set("DnsString", func(call otto.FunctionCall) otto.Value {
		args := call.ArgumentList
		recordName := "ANY"
		searchString := args[0].String()
		if len(args) > 1 {
			searchString = args[1].String()
			recordName = args[0].String()
		}
		content := GetDnsComponent(record, recordName)
		record.Response.Beautify = content
		result, _ := vm.ToValue(StringSearch(content, searchString))
		return result
	})

	vm.Set("DnsRegex", func(call otto.FunctionCall) otto.Value {
		args := call.ArgumentList
		recordName := "ANY"
		searchString := args[0].String()
		if len(args) > 1 {
			searchString = args[1].String()
			recordName = args[0].String()
		}
		content := GetDnsComponent(record, recordName)
		record.Response.Beautify = content

		matches, validate := RegexSearch(content, searchString)
		result, err := vm.ToValue(validate)
		if err != nil {
			utils.ErrorF("Error Regex: %v", searchString)
			result, _ = vm.ToValue(false)
		}
		if matches != "" {
			extra = matches
		}
		return result
	})

	// really run detection here
	for _, analyze := range record.Dns.Detections {
		// pass detection here
		result, _ := vm.Run(analyze)
		analyzeResult, err := result.Export()
		// in case vm panic
		if err != nil || analyzeResult == nil {
			r.DetectString = analyze
			r.IsVulnerable = false
			r.DetectResult = ""
			r.ExtraOutput = ""
			continue
		}
		r.DetectString = analyze
		r.IsVulnerable = analyzeResult.(bool)
		r.DetectResult = extra
		r.ExtraOutput = extra

		// add extra things for standard output
		r.Request.URL = r.Dns.Domain
		r.Request.Beautify = fmt.Sprintf("dig %s %s @%s", r.Dns.RecordType, r.Dns.Domain, r.Dns.Resolver)
		r.Response.Beautify = record.Response.Beautify

		utils.DebugF("[Detection] %v -- %v", analyze, r.IsVulnerable)
		// deal with vulnerable one here
		next := r.Output()
		if next == "stop" {
			return true
		}
	}

	return false
}