Psych's reverse.code function producing NAs in R

Here is the relevant line of the source code of reverse.code(), where new is the object holding the reverse-coded data:

new[abs(new) > 999] <- NA

As you can see, setting values larger than 9999 to missing is hard-coded into the routine. You could write a new version of the function that didn't do that. For example, in the function below, we just make a much larger threshold:

my.reverse.code <- function (keys, items, mini = NULL, maxi = NULL) 
{
  if (is.vector(items)) {
    nvar <- 1
  }
  else {
    nvar <- dim(items)[2]
  }
  items <- as.matrix(items)
  if (is.null(maxi)) {
    colMax <- apply(items, 2, max, na.rm = TRUE)
  }
  else {
    colMax <- maxi
  }
  if (is.null(mini)) {
    colMin <- apply(items, 2, min, na.rm = TRUE)
  }
  else {
    colMin <- mini
  }
  colAdj <- colMax + colMin
  if (length(keys) < nvar) {
    temp <- keys
    if (is.character(temp)) 
      temp <- match(temp, colnames(items))
    keys <- rep(1, nvar)
    keys[temp] <- -1
  }
  if (is.list(keys) | is.character(keys)) {
    keys <- make.keys(items, keys)
    keys <- diag(keys)
  }
  keys.d <- diag(keys, nvar, nvar)
  items[is.na(items)] <- -99999999999
  reversed <- items %*% keys.d
  adj <- abs(keys * colAdj)
  adj[keys > 0] <- 0
  new <- t(adj + t(reversed))
  new[abs(new) > 99999999999] <- NA
  colnames(new) <- colnames(items)
  colnames(new)[keys < 0] <- paste(colnames(new)[keys < 0], 
                                   "-", sep = "")
  return(new)
}

The reason they used a numeric value threshold is that for the recoding they do to work, they needed all values to be numeric. So, they set missing values to -999 and then later turn them back into missing values. The same is done above, but with a lot bigger number.

keys <- c(1,-1,-1,-1) #Where column 1 = ID and the rest are my variables to be reversed
rev_dat <- data.frame(
  id = 9998:10002, 
  x = 1:5, 
  y = 5:1, 
  z = 1:5
)
library(psych)
reverse.code(keys, rev_dat)
#      id x- y- z-
# [1,] NA  5  1  5
# [2,] NA  4  2  4
# [3,] NA  3  3  3
# [4,] NA  2  4  2
# [5,] NA  1  5  1
my.reverse.code(keys, rev_dat)
#         id x- y- z-
# [1,]  9998  5  1  5
# [2,]  9999  4  2  4
# [3,] 10000  3  3  3
# [4,] 10001  2  4  2
# [5,] 10002  1  5  1