prepare_Rd: invalid non-character version specification 'x' (type: double)
Calls:
 1: tools:::.check_package_parseRd(".", minlevel = -1)
 2: tryCatch(suppressMessages(checkRd(f, encoding = enc, def_enc = def_enc, macros = macros, stages = c("build", "install", "render"))), error = identity)
 3: tryCatchList(expr, classes, parentenv, handlers)
 4: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 5: doTryCatch(return(expr), name, parentenv, handler)
 6: suppressMessages(checkRd(f, encoding = enc, def_enc = def_enc, macros = macros, stages = c("build", "install", "render")))
 7: withCallingHandlers(expr, message = function(c) if (inherits(c, classes)) tryInvokeRestart("muffleMessage"))
 8: checkRd(f, encoding = enc, def_enc = def_enc, macros = macros, stages = c("build", "install", "render"))
 9: withCallingHandlers({
        prepare_Rd(Rd, defines = defines, stages = stages, warningCalls = FALSE, ..., msglevel = 1)
    }, warning = .whandler)
10: prepare_Rd(Rd, defines = defines, stages = stages, warningCalls = FALSE, ..., msglevel = 1)
11: processRdSexprs(Rd, "build", options, macros = attr(Rd, "macros"))
12: expandDynamicFlags(recurse(block), options)
13: recurse(block)
14: getDynamicFlags(block)
15: recurse(block)
16: recurse(block[[i]])
17: recurse(block[[i]])
18: processRdChunk(block, stage, options, env, macros = macros)
19: evalWithOpt(ce, options, env)
20: tryCatch(withVisible(eval(expr, env)), error = function(e) e)
21: tryCatchList(expr, classes, parentenv, handlers)
22: tryCatchOne(expr, names, parentenv, handlers[[1L]])
23: doTryCatch(return(expr), name, parentenv, handler)
24: withVisible(eval(expr, env))
25: eval(expr, env)
26: eval(expr, env)
27: Rdpack::insert_ref(key = "johnson:2012", package = "visvow")
28: .toRd_styled(item, package)
29: requireNamespace(package)
30: tryCatch(loadNamespace(package, ...), error = function(e) e)
31: tryCatchList(expr, classes, parentenv, handlers)
32: tryCatchOne(expr, names, parentenv, handlers[[1L]])
33: doTryCatch(return(expr), name, parentenv, handler)
34: loadNamespace(package, ...)
35: namespaceImport(ns, loadNamespace(i, c(lib.loc, .libPaths()), versionCheck = vI[[i]]), from = package)
36: loadNamespace(i, c(lib.loc, .libPaths()), versionCheck = vI[[i]])
37: namespaceImportFrom(ns, loadNamespace(j <- i[[1L]], c(lib.loc, .libPaths()), versionCheck = vI[[j]]), i[[2L]], from = package)
38: asNamespace(ns)
39: loadNamespace(j <- i[[1L]], c(lib.loc, .libPaths()), versionCheck = vI[[j]])
40: runUserHook(package, pkgpath)
41: try(fun(pkgname, pkgpath))
42: tryCatch(expr, error = function(e) {
        call <- conditionCall(e)
        if (!is.null(call)) {
            if (identical(call[[1L]], quote(doTryCatch))) 
                call <- sys.call(-4L)
            dcall <- deparse(call, nlines = 1L)
            prefix <- paste("Error in", dcall, ": ")
            LONG <- 75L
            sm <- strsplit(conditionMessage(e), "\n")[[1L]]
            w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
            if (is.na(w)) 
                w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b")
            if (w > LONG) 
                prefix <- paste0(prefix, "\n  ")
        }
        else prefix <- "Error : "
        msg <- paste0(prefix, conditionMessage(e), "\n")
        .Internal(seterrmessage(msg[1L]))
        if (!silent && isTRUE(getOption("show.error.messages"))) {
            cat(msg, file = outFile)
            .Internal(printDeferredWarnings())
        }
        invisible(structure(msg, class = "try-error", condition = e))
    })
43: tryCatchList(expr, classes, parentenv, handlers)
44: tryCatchOne(expr, names, parentenv, handlers[[1L]])
45: doTryCatch(return(expr), name, parentenv, handler)
46: fun(pkgname, pkgpath)
47: is_installed(pkg, version)
48: isTRUE(get_package_version(pkg) >= version)
49: Ops.numeric_version(get_package_version(pkg), version)
50: as.numeric_version(e2)
51: numeric_version(x)
52: .make_numeric_version(x, strict, .standard_regexps()$valid_numeric_version)