Template Upload

node_modules/touch/.npmignore

@@ -0,0 +1,4 @@
+node_modules/
+coverage/
+.nyc_output/
+nyc_output/

node_modules/touch/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+  - '0.8'
+  - '0.10'
+  - '0.12'
+  - 'iojs'
+before_install:
+  - npm install -g npm@latest

node_modules/touch/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/touch/README.md

@@ -0,0 +1,39 @@
+# node-touch
+
+For all your node touching needs.
+
+## Installing
+
+```bash
+npm install touch
+```
+
+## CLI Usage:
+
+See `man touch`
+
+## API Usage:
+
+```javascript
+var touch = require("touch")
+```
+
+Gives you the following functions:
+
+* `touch(filename, options, cb)`
+* `touch.sync(filename, options)`
+* `touch.ftouch(fd, options, cb)`
+* `touch.ftouchSync(fd, options)`
+
+## Options
+
+* `force` like `touch -f` Boolean
+* `time` like `touch -t <date>` Can be a Date object, or any parseable
+  Date string, or epoch ms number.
+* `atime` like `touch -a` Can be either a Boolean, or a Date.
+* `mtime` like `touch -m` Can be either a Boolean, or a Date.
+* `ref` like `touch -r <file>` Must be path to a file.
+* `nocreate` like `touch -c` Boolean
+
+If neither `atime` nor `mtime` are set, then both values are set.  If
+one of them is set, then the other is not.

node_modules/touch/bin/touch.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+var touch = require("../touch")
+  , fs = require("fs")
+  , path = require("path")
+  , nopt = require("nopt")
+  , types = { atime: Boolean
+            , mtime: Boolean
+            , time: Date
+            , ref: path
+            , nocreate: Boolean
+            , force: Boolean }
+  , shorthands = { a: "--atime"
+                 , m: "--mtime"
+                 , r: "--ref"
+                 , t: "--time"
+                 , c: "--nocreate"
+                 , f: "--force" }
+
+var options = nopt(types, shorthands)
+
+var files = options.argv.remain
+delete options.argv
+
+files.forEach(function (file) {
+  touch(file, options, function (er) {
+    if (er) {
+      console.error("bad touch!")
+      throw er
+    }
+    console.error(file, fs.statSync(file))
+  })
+})

node_modules/touch/node_modules/.bin/nopt

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=`dirname "$0"`
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../nopt/bin/nopt.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../nopt/bin/nopt.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/touch/node_modules/.bin/nopt.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\nopt\bin\nopt.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\nopt\bin\nopt.js" %*
+)

node_modules/touch/node_modules/nopt/LICENSE

@@ -0,0 +1,23 @@
+Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

node_modules/touch/node_modules/nopt/README.md

@@ -0,0 +1,208 @@
+If you want to write an option parser, and have it be good, there are
+two ways to do it.  The Right Way, and the Wrong Way.
+
+The Wrong Way is to sit down and write an option parser.  We've all done
+that.
+
+The Right Way is to write some complex configurable program with so many
+options that you go half-insane just trying to manage them all, and put
+it off with duct-tape solutions until you see exactly to the core of the
+problem, and finally snap and write an awesome option parser.
+
+If you want to write an option parser, don't write an option parser.
+Write a package manager, or a source control system, or a service
+restarter, or an operating system.  You probably won't end up with a
+good one of those, but if you don't give up, and you are relentless and
+diligent enough in your procrastination, you may just end up with a very
+nice option parser.
+
+## USAGE
+
+    // my-program.js
+    var nopt = require("nopt")
+      , Stream = require("stream").Stream
+      , path = require("path")
+      , knownOpts = { "foo" : [String, null]
+                    , "bar" : [Stream, Number]
+                    , "baz" : path
+                    , "bloo" : [ "big", "medium", "small" ]
+                    , "flag" : Boolean
+                    , "pick" : Boolean
+                    , "many" : [String, Array]
+                    }
+      , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
+                     , "b7" : ["--bar", "7"]
+                     , "m" : ["--bloo", "medium"]
+                     , "p" : ["--pick"]
+                     , "f" : ["--flag"]
+                     }
+                 // everything is optional.
+                 // knownOpts and shorthands default to {}
+                 // arg list defaults to process.argv
+                 // slice defaults to 2
+      , parsed = nopt(knownOpts, shortHands, process.argv, 2)
+    console.log(parsed)
+
+This would give you support for any of the following:
+
+```bash
+$ node my-program.js --foo "blerp" --no-flag
+{ "foo" : "blerp", "flag" : false }
+
+$ node my-program.js ---bar 7 --foo "Mr. Hand" --flag
+{ bar: 7, foo: "Mr. Hand", flag: true }
+
+$ node my-program.js --foo "blerp" -f -----p
+{ foo: "blerp", flag: true, pick: true }
+
+$ node my-program.js -fp --foofoo
+{ foo: "Mr. Foo", flag: true, pick: true }
+
+$ node my-program.js --foofoo -- -fp  # -- stops the flag parsing.
+{ foo: "Mr. Foo", argv: { remain: ["-fp"] } }
+
+$ node my-program.js --blatzk 1000 -fp # unknown opts are ok.
+{ blatzk: 1000, flag: true, pick: true }
+
+$ node my-program.js --blatzk true -fp # but they need a value
+{ blatzk: true, flag: true, pick: true }
+
+$ node my-program.js --no-blatzk -fp # unless they start with "no-"
+{ blatzk: false, flag: true, pick: true }
+
+$ node my-program.js --baz b/a/z # known paths are resolved.
+{ baz: "/Users/isaacs/b/a/z" }
+
+# if Array is one of the types, then it can take many
+# values, and will always be an array.  The other types provided
+# specify what types are allowed in the list.
+
+$ node my-program.js --many 1 --many null --many foo
+{ many: ["1", "null", "foo"] }
+
+$ node my-program.js --many foo
+{ many: ["foo"] }
+```
+
+Read the tests at the bottom of `lib/nopt.js` for more examples of
+what this puppy can do.
+
+## Types
+
+The following types are supported, and defined on `nopt.typeDefs`
+
+* String: A normal string.  No parsing is done.
+* path: A file system path.  Gets resolved against cwd if not absolute.
+* url: A url.  If it doesn't parse, it isn't accepted.
+* Number: Must be numeric.
+* Date: Must parse as a date. If it does, and `Date` is one of the options,
+  then it will return a Date object, not a string.
+* Boolean: Must be either `true` or `false`.  If an option is a boolean,
+  then it does not need a value, and its presence will imply `true` as
+  the value.  To negate boolean flags, do `--no-whatever` or `--whatever
+  false`
+* NaN: Means that the option is strictly not allowed.  Any value will
+  fail.
+* Stream: An object matching the "Stream" class in node.  Valuable
+  for use when validating programmatically.  (npm uses this to let you
+  supply any WriteStream on the `outfd` and `logfd` config options.)
+* Array: If `Array` is specified as one of the types, then the value
+  will be parsed as a list of options.  This means that multiple values
+  can be specified, and that the value will always be an array.
+
+If a type is an array of values not on this list, then those are
+considered valid values.  For instance, in the example above, the
+`--bloo` option can only be one of `"big"`, `"medium"`, or `"small"`,
+and any other value will be rejected.
+
+When parsing unknown fields, `"true"`, `"false"`, and `"null"` will be
+interpreted as their JavaScript equivalents, and numeric values will be
+interpreted as a number.
+
+You can also mix types and values, or multiple types, in a list.  For
+instance `{ blah: [Number, null] }` would allow a value to be set to
+either a Number or null.
+
+To define a new type, add it to `nopt.typeDefs`.  Each item in that
+hash is an object with a `type` member and a `validate` method.  The
+`type` member is an object that matches what goes in the type list.  The
+`validate` method is a function that gets called with `validate(data,
+key, val)`.  Validate methods should assign `data[key]` to the valid
+value of `val` if it can be handled properly, or return boolean
+`false` if it cannot.
+
+You can also call `nopt.clean(data, types, typeDefs)` to clean up a
+config object and remove its invalid properties.
+
+## Error Handling
+
+By default, nopt outputs a warning to standard error when invalid
+options are found.  You can change this behavior by assigning a method
+to `nopt.invalidHandler`.  This method will be called with
+the offending `nopt.invalidHandler(key, val, types)`.
+
+If no `nopt.invalidHandler` is assigned, then it will console.error
+its whining.  If it is assigned to boolean `false` then the warning is
+suppressed.
+
+## Abbreviations
+
+Yes, they are supported.  If you define options like this:
+
+```javascript
+{ "foolhardyelephants" : Boolean
+, "pileofmonkeys" : Boolean }
+```
+
+Then this will work:
+
+```bash
+node program.js --foolhar --pil
+node program.js --no-f --pileofmon
+# etc.
+```
+
+## Shorthands
+
+Shorthands are a hash of shorter option names to a snippet of args that
+they expand to.
+
+If multiple one-character shorthands are all combined, and the
+combination does not unambiguously match any other option or shorthand,
+then they will be broken up into their constituent parts.  For example:
+
+```json
+{ "s" : ["--loglevel", "silent"]
+, "g" : "--global"
+, "f" : "--force"
+, "p" : "--parseable"
+, "l" : "--long"
+}
+```
+
+```bash
+npm ls -sgflp
+# just like doing this:
+npm ls --loglevel silent --global --force --long --parseable
+```
+
+## The Rest of the args
+
+The config object returned by nopt is given a special member called
+`argv`, which is an object with the following fields:
+
+* `remain`: The remaining args after all the parsing has occurred.
+* `original`: The args as they originally appeared.
+* `cooked`: The args after flags and shorthands are expanded.
+
+## Slicing
+
+Node programs are called with more or less the exact argv as it appears
+in C land, after the v8 and node-specific options have been plucked off.
+As such, `argv[0]` is always `node` and `argv[1]` is always the
+JavaScript program being run.
+
+That's usually not very useful to you.  So they're sliced off by
+default.  If you want them, then you can pass in `0` as the last
+argument, or any other number that you'd like to slice off the start of
+the list.

node_modules/touch/node_modules/nopt/bin/nopt.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+var nopt = require("../lib/nopt")
+  , types = { num: Number
+            , bool: Boolean
+            , help: Boolean
+            , list: Array
+            , "num-list": [Number, Array]
+            , "str-list": [String, Array]
+            , "bool-list": [Boolean, Array]
+            , str: String }
+  , shorthands = { s: [ "--str", "astring" ]
+                 , b: [ "--bool" ]
+                 , nb: [ "--no-bool" ]
+                 , tft: [ "--bool-list", "--no-bool-list", "--bool-list", "true" ]
+                 , "?": ["--help"]
+                 , h: ["--help"]
+                 , H: ["--help"]
+                 , n: [ "--num", "125" ] }
+  , parsed = nopt( types
+                 , shorthands
+                 , process.argv
+                 , 2 )
+
+console.log("parsed", parsed)
+
+if (parsed.help) {
+  console.log("")
+  console.log("nopt cli tester")
+  console.log("")
+  console.log("types")
+  console.log(Object.keys(types).map(function M (t) {
+    var type = types[t]
+    if (Array.isArray(type)) {
+      return [t, type.map(function (type) { return type.name })]
+    }
+    return [t, type && type.name]
+  }).reduce(function (s, i) {
+    s[i[0]] = i[1]
+    return s
+  }, {}))
+  console.log("")
+  console.log("shorthands")
+  console.log(shorthands)
+}

node_modules/touch/node_modules/nopt/examples/my-program.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+//process.env.DEBUG_NOPT = 1
+
+// my-program.js
+var nopt = require("../lib/nopt")
+  , Stream = require("stream").Stream
+  , path = require("path")
+  , knownOpts = { "foo" : [String, null]
+                , "bar" : [Stream, Number]
+                , "baz" : path
+                , "bloo" : [ "big", "medium", "small" ]
+                , "flag" : Boolean
+                , "pick" : Boolean
+                }
+  , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
+                 , "b7" : ["--bar", "7"]
+                 , "m" : ["--bloo", "medium"]
+                 , "p" : ["--pick"]
+                 , "f" : ["--flag", "true"]
+                 , "g" : ["--flag"]
+                 , "s" : "--flag"
+                 }
+             // everything is optional.
+             // knownOpts and shorthands default to {}
+             // arg list defaults to process.argv
+             // slice defaults to 2
+  , parsed = nopt(knownOpts, shortHands, process.argv, 2)
+
+console.log("parsed =\n"+ require("util").inspect(parsed))

node_modules/touch/node_modules/nopt/lib/nopt.js

@@ -0,0 +1,552 @@
+// info about each config option.
+
+var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
+  ? function () { console.error.apply(console, arguments) }
+  : function () {}
+
+var url = require("url")
+  , path = require("path")
+  , Stream = require("stream").Stream
+  , abbrev = require("abbrev")
+
+module.exports = exports = nopt
+exports.clean = clean
+
+exports.typeDefs =
+  { String  : { type: String,  validate: validateString  }
+  , Boolean : { type: Boolean, validate: validateBoolean }
+  , url     : { type: url,     validate: validateUrl     }
+  , Number  : { type: Number,  validate: validateNumber  }
+  , path    : { type: path,    validate: validatePath    }
+  , Stream  : { type: Stream,  validate: validateStream  }
+  , Date    : { type: Date,    validate: validateDate    }
+  }
+
+function nopt (types, shorthands, args, slice) {
+  args = args || process.argv
+  types = types || {}
+  shorthands = shorthands || {}
+  if (typeof slice !== "number") slice = 2
+
+  debug(types, shorthands, args, slice)
+
+  args = args.slice(slice)
+  var data = {}
+    , key
+    , remain = []
+    , cooked = args
+    , original = args.slice(0)
+
+  parse(args, data, remain, types, shorthands)
+  // now data is full
+  clean(data, types, exports.typeDefs)
+  data.argv = {remain:remain,cooked:cooked,original:original}
+  data.argv.toString = function () {
+    return this.original.map(JSON.stringify).join(" ")
+  }
+  return data
+}
+
+function clean (data, types, typeDefs) {
+  typeDefs = typeDefs || exports.typeDefs
+  var remove = {}
+    , typeDefault = [false, true, null, String, Number]
+
+  Object.keys(data).forEach(function (k) {
+    if (k === "argv") return
+    var val = data[k]
+      , isArray = Array.isArray(val)
+      , type = types[k]
+    if (!isArray) val = [val]
+    if (!type) type = typeDefault
+    if (type === Array) type = typeDefault.concat(Array)
+    if (!Array.isArray(type)) type = [type]
+
+    debug("val=%j", val)
+    debug("types=", type)
+    val = val.map(function (val) {
+      // if it's an unknown value, then parse false/true/null/numbers/dates
+      if (typeof val === "string") {
+        debug("string %j", val)
+        val = val.trim()
+        if ((val === "null" && ~type.indexOf(null))
+            || (val === "true" &&
+               (~type.indexOf(true) || ~type.indexOf(Boolean)))
+            || (val === "false" &&
+               (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
+          val = JSON.parse(val)
+          debug("jsonable %j", val)
+        } else if (~type.indexOf(Number) && !isNaN(val)) {
+          debug("convert to number", val)
+          val = +val
+        } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
+          debug("convert to date", val)
+          val = new Date(val)
+        }
+      }
+
+      if (!types.hasOwnProperty(k)) {
+        return val
+      }
+
+      // allow `--no-blah` to set 'blah' to null if null is allowed
+      if (val === false && ~type.indexOf(null) &&
+          !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
+        val = null
+      }
+
+      var d = {}
+      d[k] = val
+      debug("prevalidated val", d, val, types[k])
+      if (!validate(d, k, val, types[k], typeDefs)) {
+        if (exports.invalidHandler) {
+          exports.invalidHandler(k, val, types[k], data)
+        } else if (exports.invalidHandler !== false) {
+          debug("invalid: "+k+"="+val, types[k])
+        }
+        return remove
+      }
+      debug("validated val", d, val, types[k])
+      return d[k]
+    }).filter(function (val) { return val !== remove })
+
+    if (!val.length) delete data[k]
+    else if (isArray) {
+      debug(isArray, data[k], val)
+      data[k] = val
+    } else data[k] = val[0]
+
+    debug("k=%s val=%j", k, val, data[k])
+  })
+}
+
+function validateString (data, k, val) {
+  data[k] = String(val)
+}
+
+function validatePath (data, k, val) {
+  data[k] = path.resolve(String(val))
+  return true
+}
+
+function validateNumber (data, k, val) {
+  debug("validate Number %j %j %j", k, val, isNaN(val))
+  if (isNaN(val)) return false
+  data[k] = +val
+}
+
+function validateDate (data, k, val) {
+  debug("validate Date %j %j %j", k, val, Date.parse(val))
+  var s = Date.parse(val)
+  if (isNaN(s)) return false
+  data[k] = new Date(val)
+}
+
+function validateBoolean (data, k, val) {
+  if (val instanceof Boolean) val = val.valueOf()
+  else if (typeof val === "string") {
+    if (!isNaN(val)) val = !!(+val)
+    else if (val === "null" || val === "false") val = false
+    else val = true
+  } else val = !!val
+  data[k] = val
+}
+
+function validateUrl (data, k, val) {
+  val = url.parse(String(val))
+  if (!val.host) return false
+  data[k] = val.href
+}
+
+function validateStream (data, k, val) {
+  if (!(val instanceof Stream)) return false
+  data[k] = val
+}
+
+function validate (data, k, val, type, typeDefs) {
+  // arrays are lists of types.
+  if (Array.isArray(type)) {
+    for (var i = 0, l = type.length; i < l; i ++) {
+      if (type[i] === Array) continue
+      if (validate(data, k, val, type[i], typeDefs)) return true
+    }
+    delete data[k]
+    return false
+  }
+
+  // an array of anything?
+  if (type === Array) return true
+
+  // NaN is poisonous.  Means that something is not allowed.
+  if (type !== type) {
+    debug("Poison NaN", k, val, type)
+    delete data[k]
+    return false
+  }
+
+  // explicit list of values
+  if (val === type) {
+    debug("Explicitly allowed %j", val)
+    // if (isArray) (data[k] = data[k] || []).push(val)
+    // else data[k] = val
+    data[k] = val
+    return true
+  }
+
+  // now go through the list of typeDefs, validate against each one.
+  var ok = false
+    , types = Object.keys(typeDefs)
+  for (var i = 0, l = types.length; i < l; i ++) {
+    debug("test type %j %j %j", k, val, types[i])
+    var t = typeDefs[types[i]]
+    if (t && type === t.type) {
+      var d = {}
+      ok = false !== t.validate(d, k, val)
+      val = d[k]
+      if (ok) {
+        // if (isArray) (data[k] = data[k] || []).push(val)
+        // else data[k] = val
+        data[k] = val
+        break
+      }
+    }
+  }
+  debug("OK? %j (%j %j %j)", ok, k, val, types[i])
+
+  if (!ok) delete data[k]
+  return ok
+}
+
+function parse (args, data, remain, types, shorthands) {
+  debug("parse", args, data, remain)
+
+  var key = null
+    , abbrevs = abbrev(Object.keys(types))
+    , shortAbbr = abbrev(Object.keys(shorthands))
+
+  for (var i = 0; i < args.length; i ++) {
+    var arg = args[i]
+    debug("arg", arg)
+
+    if (arg.match(/^-{2,}$/)) {
+      // done with keys.
+      // the rest are args.
+      remain.push.apply(remain, args.slice(i + 1))
+      args[i] = "--"
+      break
+    }
+    if (arg.charAt(0) === "-") {
+      if (arg.indexOf("=") !== -1) {
+        var v = arg.split("=")
+        arg = v.shift()
+        v = v.join("=")
+        args.splice.apply(args, [i, 1].concat([arg, v]))
+      }
+      // see if it's a shorthand
+      // if so, splice and back up to re-parse it.
+      var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs)
+      debug("arg=%j shRes=%j", arg, shRes)
+      if (shRes) {
+        debug(arg, shRes)
+        args.splice.apply(args, [i, 1].concat(shRes))
+        if (arg !== shRes[0]) {
+          i --
+          continue
+        }
+      }
+      arg = arg.replace(/^-+/, "")
+      var no = false
+      while (arg.toLowerCase().indexOf("no-") === 0) {
+        no = !no
+        arg = arg.substr(3)
+      }
+
+      if (abbrevs[arg]) arg = abbrevs[arg]
+
+      var isArray = types[arg] === Array ||
+        Array.isArray(types[arg]) && types[arg].indexOf(Array) !== -1
+
+      var val
+        , la = args[i + 1]
+
+      var isBool = no ||
+        types[arg] === Boolean ||
+        Array.isArray(types[arg]) && types[arg].indexOf(Boolean) !== -1 ||
+        (la === "false" &&
+         (types[arg] === null ||
+          Array.isArray(types[arg]) && ~types[arg].indexOf(null)))
+
+      if (isBool) {
+        // just set and move along
+        val = !no
+        // however, also support --bool true or --bool false
+        if (la === "true" || la === "false") {
+          val = JSON.parse(la)
+          la = null
+          if (no) val = !val
+          i ++
+        }
+
+        // also support "foo":[Boolean, "bar"] and "--foo bar"
+        if (Array.isArray(types[arg]) && la) {
+          if (~types[arg].indexOf(la)) {
+            // an explicit type
+            val = la
+            i ++
+          } else if ( la === "null" && ~types[arg].indexOf(null) ) {
+            // null allowed
+            val = null
+            i ++
+          } else if ( !la.match(/^-{2,}[^-]/) &&
+                      !isNaN(la) &&
+                      ~types[arg].indexOf(Number) ) {
+            // number
+            val = +la
+            i ++
+          } else if ( !la.match(/^-[^-]/) && ~types[arg].indexOf(String) ) {
+            // string
+            val = la
+            i ++
+          }
+        }
+
+        if (isArray) (data[arg] = data[arg] || []).push(val)
+        else data[arg] = val
+
+        continue
+      }
+
+      if (la && la.match(/^-{2,}$/)) {
+        la = undefined
+        i --
+      }
+
+      val = la === undefined ? true : la
+      if (isArray) (data[arg] = data[arg] || []).push(val)
+      else data[arg] = val
+
+      i ++
+      continue
+    }
+    remain.push(arg)
+  }
+}
+
+function resolveShort (arg, shorthands, shortAbbr, abbrevs) {
+  // handle single-char shorthands glommed together, like
+  // npm ls -glp, but only if there is one dash, and only if
+  // all of the chars are single-char shorthands, and it's
+  // not a match to some other abbrev.
+  arg = arg.replace(/^-+/, '')
+  if (abbrevs[arg] && !shorthands[arg]) {
+    return null
+  }
+  if (shortAbbr[arg]) {
+    arg = shortAbbr[arg]
+  } else {
+    var singles = shorthands.___singles
+    if (!singles) {
+      singles = Object.keys(shorthands).filter(function (s) {
+        return s.length === 1
+      }).reduce(function (l,r) { l[r] = true ; return l }, {})
+      shorthands.___singles = singles
+    }
+    var chrs = arg.split("").filter(function (c) {
+      return singles[c]
+    })
+    if (chrs.join("") === arg) return chrs.map(function (c) {
+      return shorthands[c]
+    }).reduce(function (l, r) {
+      return l.concat(r)
+    }, [])
+  }
+
+  if (shorthands[arg] && !Array.isArray(shorthands[arg])) {
+    shorthands[arg] = shorthands[arg].split(/\s+/)
+  }
+  return shorthands[arg]
+}
+
+if (module === require.main) {
+var assert = require("assert")
+  , util = require("util")
+
+  , shorthands =
+    { s : ["--loglevel", "silent"]
+    , d : ["--loglevel", "info"]
+    , dd : ["--loglevel", "verbose"]
+    , ddd : ["--loglevel", "silly"]
+    , noreg : ["--no-registry"]
+    , reg : ["--registry"]
+    , "no-reg" : ["--no-registry"]
+    , silent : ["--loglevel", "silent"]
+    , verbose : ["--loglevel", "verbose"]
+    , h : ["--usage"]
+    , H : ["--usage"]
+    , "?" : ["--usage"]
+    , help : ["--usage"]
+    , v : ["--version"]
+    , f : ["--force"]
+    , desc : ["--description"]
+    , "no-desc" : ["--no-description"]
+    , "local" : ["--no-global"]
+    , l : ["--long"]
+    , p : ["--parseable"]
+    , porcelain : ["--parseable"]
+    , g : ["--global"]
+    }
+
+  , types =
+    { aoa: Array
+    , nullstream: [null, Stream]
+    , date: Date
+    , str: String
+    , browser : String
+    , cache : path
+    , color : ["always", Boolean]
+    , depth : Number
+    , description : Boolean
+    , dev : Boolean
+    , editor : path
+    , force : Boolean
+    , global : Boolean
+    , globalconfig : path
+    , group : [String, Number]
+    , gzipbin : String
+    , logfd : [Number, Stream]
+    , loglevel : ["silent","win","error","warn","info","verbose","silly"]
+    , long : Boolean
+    , "node-version" : [false, String]
+    , npaturl : url
+    , npat : Boolean
+    , "onload-script" : [false, String]
+    , outfd : [Number, Stream]
+    , parseable : Boolean
+    , pre: Boolean
+    , prefix: path
+    , proxy : url
+    , "rebuild-bundle" : Boolean
+    , registry : url
+    , searchopts : String
+    , searchexclude: [null, String]
+    , shell : path
+    , t: [Array, String]
+    , tag : String
+    , tar : String
+    , tmp : path
+    , "unsafe-perm" : Boolean
+    , usage : Boolean
+    , user : String
+    , username : String
+    , userconfig : path
+    , version : Boolean
+    , viewer: path
+    , _exit : Boolean
+    }
+
+; [["-v", {version:true}, []]
+  ,["---v", {version:true}, []]
+  ,["ls -s --no-reg connect -d",
+    {loglevel:"info",registry:null},["ls","connect"]]
+  ,["ls ---s foo",{loglevel:"silent"},["ls","foo"]]
+  ,["ls --registry blargle", {}, ["ls"]]
+  ,["--no-registry", {registry:null}, []]
+  ,["--no-color true", {color:false}, []]
+  ,["--no-color false", {color:true}, []]
+  ,["--no-color", {color:false}, []]
+  ,["--color false", {color:false}, []]
+  ,["--color --logfd 7", {logfd:7,color:true}, []]
+  ,["--color=true", {color:true}, []]
+  ,["--logfd=10", {logfd:10}, []]
+  ,["--tmp=/tmp -tar=gtar",{tmp:"/tmp",tar:"gtar"},[]]
+  ,["--tmp=tmp -tar=gtar",
+    {tmp:path.resolve(process.cwd(), "tmp"),tar:"gtar"},[]]
+  ,["--logfd x", {}, []]
+  ,["a -true -- -no-false", {true:true},["a","-no-false"]]
+  ,["a -no-false", {false:false},["a"]]
+  ,["a -no-no-true", {true:true}, ["a"]]
+  ,["a -no-no-no-false", {false:false}, ["a"]]
+  ,["---NO-no-No-no-no-no-nO-no-no"+
+    "-No-no-no-no-no-no-no-no-no"+
+    "-no-no-no-no-NO-NO-no-no-no-no-no-no"+
+    "-no-body-can-do-the-boogaloo-like-I-do"
+   ,{"body-can-do-the-boogaloo-like-I-do":false}, []]
+  ,["we are -no-strangers-to-love "+
+    "--you-know the-rules --and so-do-i "+
+    "---im-thinking-of=a-full-commitment "+
+    "--no-you-would-get-this-from-any-other-guy "+
+    "--no-gonna-give-you-up "+
+    "-no-gonna-let-you-down=true "+
+    "--no-no-gonna-run-around false "+
+    "--desert-you=false "+
+    "--make-you-cry false "+
+    "--no-tell-a-lie "+
+    "--no-no-and-hurt-you false"
+   ,{"strangers-to-love":false
+    ,"you-know":"the-rules"
+    ,"and":"so-do-i"
+    ,"you-would-get-this-from-any-other-guy":false
+    ,"gonna-give-you-up":false
+    ,"gonna-let-you-down":false
+    ,"gonna-run-around":false
+    ,"desert-you":false
+    ,"make-you-cry":false
+    ,"tell-a-lie":false
+    ,"and-hurt-you":false
+    },["we", "are"]]
+  ,["-t one -t two -t three"
+   ,{t: ["one", "two", "three"]}
+   ,[]]
+  ,["-t one -t null -t three four five null"
+   ,{t: ["one", "null", "three"]}
+   ,["four", "five", "null"]]
+  ,["-t foo"
+   ,{t:["foo"]}
+   ,[]]
+  ,["--no-t"
+   ,{t:["false"]}
+   ,[]]
+  ,["-no-no-t"
+   ,{t:["true"]}
+   ,[]]
+  ,["-aoa one -aoa null -aoa 100"
+   ,{aoa:["one", null, 100]}
+   ,[]]
+  ,["-str 100"
+   ,{str:"100"}
+   ,[]]
+  ,["--color always"
+   ,{color:"always"}
+   ,[]]
+  ,["--no-nullstream"
+   ,{nullstream:null}
+   ,[]]
+  ,["--nullstream false"
+   ,{nullstream:null}
+   ,[]]
+  ,["--notadate 2011-01-25"
+   ,{notadate: "2011-01-25"}
+   ,[]]
+  ,["--date 2011-01-25"
+   ,{date: new Date("2011-01-25")}
+   ,[]]
+  ].forEach(function (test) {
+    var argv = test[0].split(/\s+/)
+      , opts = test[1]
+      , rem = test[2]
+      , actual = nopt(types, shorthands, argv, 0)
+      , parsed = actual.argv
+    delete actual.argv
+    console.log(util.inspect(actual, false, 2, true), parsed.remain)
+    for (var i in opts) {
+      var e = JSON.stringify(opts[i])
+        , a = JSON.stringify(actual[i] === undefined ? null : actual[i])
+      if (e && typeof e === "object") {
+        assert.deepEqual(e, a)
+      } else {
+        assert.equal(e, a)
+      }
+    }
+    assert.deepEqual(rem, parsed.remain)
+  })
+}

node_modules/touch/node_modules/nopt/package.json

@@ -0,0 +1,80 @@
+{
+  "_args": [
+    [
+      "nopt@~1.0.10",
+      "C:\\Users\\x2mjbyrn\\Source\\Repos\\Skeleton\\node_modules\\touch"
+    ]
+  ],
+  "_defaultsLoaded": true,
+  "_engineSupported": true,
+  "_from": "nopt@>=1.0.10-0 <1.1.0-0",
+  "_id": "nopt@1.0.10",
+  "_inCache": true,
+  "_location": "/touch/nopt",
+  "_nodeVersion": "v0.5.9-pre",
+  "_npmUser": {
+    "email": "i@izs.me",
+    "name": "isaacs"
+  },
+  "_npmVersion": "1.0.93",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "nopt",
+    "raw": "nopt@~1.0.10",
+    "rawSpec": "~1.0.10",
+    "scope": null,
+    "spec": ">=1.0.10-0 <1.1.0-0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/touch"
+  ],
+  "_resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz",
+  "_shasum": "6ddd21bd2a31417b92727dd585f8a6f37608ebee",
+  "_shrinkwrap": null,
+  "_spec": "nopt@~1.0.10",
+  "_where": "C:\\Users\\x2mjbyrn\\Source\\Repos\\Skeleton\\node_modules\\touch",
+  "author": {
+    "email": "i@izs.me",
+    "name": "Isaac Z. Schlueter",
+    "url": "http://blog.izs.me/"
+  },
+  "bin": {
+    "nopt": "./bin/nopt.js"
+  },
+  "dependencies": {
+    "abbrev": "1"
+  },
+  "description": "Option parsing for Node, supporting types, shorthands, etc. Used by npm.",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "shasum": "6ddd21bd2a31417b92727dd585f8a6f37608ebee",
+    "tarball": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "installable": true,
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/isaacs/nopt/raw/master/LICENSE"
+  },
+  "main": "lib/nopt.js",
+  "maintainers": [
+    {
+      "name": "isaacs",
+      "email": "i@izs.me"
+    }
+  ],
+  "name": "nopt",
+  "optionalDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/nopt.git"
+  },
+  "scripts": {
+    "test": "node lib/nopt.js"
+  },
+  "version": "1.0.10"
+}

node_modules/touch/package.json

@@ -0,0 +1,84 @@
+{
+  "_args": [
+    [
+      "touch@^1.0.0",
+      "C:\\Users\\x2mjbyrn\\Source\\Repos\\Skeleton\\node_modules\\typings-core"
+    ]
+  ],
+  "_from": "touch@>=1.0.0-0 <2.0.0-0",
+  "_id": "touch@1.0.0",
+  "_inCache": true,
+  "_location": "/touch",
+  "_nodeVersion": "2.2.1",
+  "_npmUser": {
+    "email": "isaacs@npmjs.com",
+    "name": "isaacs"
+  },
+  "_npmVersion": "3.1.0",
+  "_phantomChildren": {
+    "abbrev": "1.1.0"
+  },
+  "_requested": {
+    "name": "touch",
+    "raw": "touch@^1.0.0",
+    "rawSpec": "^1.0.0",
+    "scope": null,
+    "spec": ">=1.0.0-0 <2.0.0-0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/typings-core"
+  ],
+  "_resolved": "https://registry.npmjs.org/touch/-/touch-1.0.0.tgz",
+  "_shasum": "449cbe2dbae5a8c8038e30d71fa0ff464947c4de",
+  "_shrinkwrap": null,
+  "_spec": "touch@^1.0.0",
+  "_where": "C:\\Users\\x2mjbyrn\\Source\\Repos\\Skeleton\\node_modules\\typings-core",
+  "author": {
+    "email": "i@izs.me",
+    "name": "Isaac Z. Schlueter",
+    "url": "http://blog.izs.me/"
+  },
+  "bin": {
+    "touch": "./bin/touch.js"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/node-touch/issues"
+  },
+  "dependencies": {
+    "nopt": "~1.0.10"
+  },
+  "description": "like touch(1) in node",
+  "devDependencies": {
+    "tap": "^1.3.1"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "449cbe2dbae5a8c8038e30d71fa0ff464947c4de",
+    "tarball": "https://registry.npmjs.org/touch/-/touch-1.0.0.tgz"
+  },
+  "engines": {
+    "node": ">=0.6"
+  },
+  "gitHead": "f73938c01bd10fe70fae5af3f37fc8c6162e9852",
+  "homepage": "https://github.com/isaacs/node-touch#readme",
+  "installable": true,
+  "license": "ISC",
+  "main": "touch.js",
+  "maintainers": [
+    {
+      "name": "isaacs",
+      "email": "i@izs.me"
+    }
+  ],
+  "name": "touch",
+  "optionalDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-touch.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "1.0.0"
+}

node_modules/touch/test/basic.js

@@ -0,0 +1,221 @@
+var fs = require("fs")
+var touch = require("../touch.js")
+var t = require('tap')
+
+function _ (fn) { return function (er) {
+  if (er) throw er
+  fn()
+}}
+
+var files = [
+  'sync',
+  'sync-ref',
+  'async',
+  'async-ref'
+]
+
+files.forEach(function (f) {
+  try { fs.unlinkSync(f) } catch (e) {}
+})
+
+var now = Math.floor(Date.now() / 1000) * 1000
+var then = now - 1000000000 // now - 1Msec
+
+t.test('set both to now', function (t) {
+  touch.sync("sync")
+  touch("async", _(function () {
+    var astat = fs.statSync("async")
+    var sstat = fs.statSync("sync")
+    var asa = astat.atime.getTime()
+    var ssa = sstat.atime.getTime()
+    var asm = astat.mtime.getTime()
+    var ssm = sstat.mtime.getTime()
+
+    t.equal(asm, asa)
+    t.equal(ssm, ssa)
+    t.equal(ssa, now)
+    t.equal(asa, now)
+
+    // ctime should always be now-ish
+    t.ok(Math.abs(Date.now() - sstat.ctime.getTime()) < 1000)
+    t.ok(Math.abs(Date.now() - astat.ctime.getTime()) < 1000)
+    t.end()
+  }))
+})
+
+t.test('set both to now, using futimes', function (t) {
+  function runTest (closeAfter) {
+    t.test('closeAfter=' + closeAfter, function (t) {
+      var sfd = fs.openSync('sync', 'w')
+
+      if (closeAfter) {
+        touch.ftouchSync(sfd, { closeAfter: true })
+      } else {
+        touch.ftouchSync(sfd)
+        fs.closeSync(sfd)
+      }
+
+      var afd = fs.openSync('async', 'w')
+      t.equal(afd, sfd)
+
+      var then = _(function () {
+        if (!closeAfter) {
+          fs.closeSync(afd)
+        }
+
+        var astat = fs.statSync("async")
+        var sstat = fs.statSync("sync")
+        var asa = astat.atime.getTime()
+        var ssa = sstat.atime.getTime()
+        var asm = astat.mtime.getTime()
+        var ssm = sstat.mtime.getTime()
+
+        t.equal(asm, asa)
+        t.equal(ssm, ssa)
+        t.equal(ssa, now)
+        t.equal(asa, now)
+
+        // ctime should always be now-ish
+        t.ok(Math.abs(Date.now() - sstat.ctime.getTime()) < 1000)
+        t.ok(Math.abs(Date.now() - astat.ctime.getTime()) < 1000)
+        t.end()
+      })
+
+      if (closeAfter) {
+        touch.ftouch(afd, {closeAfter: true}, then)
+      } else {
+        touch.ftouch(afd, then)
+      }
+    })
+  }
+
+  runTest(true)
+  runTest(false)
+  t.end()
+})
+
+t.test('set both to now - 1Msec', function (t) {
+  // also use force, just for funsies
+  touch.sync("sync", { time: then, force: true })
+  touch("async", { time: then, force: true }, _(function () {
+    var astat = fs.statSync("async")
+    var sstat = fs.statSync("sync")
+    var asa = astat.atime.getTime()
+    var ssa = sstat.atime.getTime()
+    var asm = astat.mtime.getTime()
+    var ssm = sstat.mtime.getTime()
+
+    t.notEqual(asm, now)
+    t.equal(asa, asm)
+
+    t.notEqual(ssm, now)
+    t.equal(ssa, ssm)
+
+    t.equal(ssa, then)
+    t.equal(asa, then)
+
+    t.ok(Math.abs(Date.now() - sstat.ctime.getTime()) < 1000)
+    t.ok(Math.abs(Date.now() - astat.ctime.getTime()) < 1000)
+    t.end()
+  }))
+})
+
+t.test('set mtime to now', function (t) {
+  touch.sync("sync", { time: now, mtime: true })
+  touch("async", { time: now, mtime: true }, _(function () {
+    var astat = fs.statSync("async")
+    var sstat = fs.statSync("sync")
+    var asa = astat.atime.getTime()
+    var ssa = sstat.atime.getTime()
+    var asm = astat.mtime.getTime()
+    var ssm = sstat.mtime.getTime()
+
+    t.notEqual(asa, asm)
+    t.notEqual(ssa, ssm)
+
+    t.equal(ssa, then)
+    t.equal(asa, then)
+
+    t.equal(ssm, now)
+    t.equal(asm, now)
+
+    t.ok(Math.abs(Date.now() - sstat.ctime.getTime()) < 1000)
+    t.ok(Math.abs(Date.now() - astat.ctime.getTime()) < 1000)
+    t.end()
+  }))
+})
+
+t.test('set atime to now', function (t) {
+  touch.sync("sync", { time: now, atime: true })
+  touch("async", { time: now, atime: true }, _(function () {
+    var astat = fs.statSync("async")
+    var sstat = fs.statSync("sync")
+    var asa = astat.atime.getTime()
+    var ssa = sstat.atime.getTime()
+    var asm = astat.mtime.getTime()
+    var ssm = sstat.mtime.getTime()
+
+    t.equal(asm, now)
+    t.equal(ssm, now)
+
+    t.equal(asa, now)
+    t.equal(ssa, now)
+
+    t.ok(Math.abs(Date.now() - sstat.ctime.getTime()) < 1000)
+    t.ok(Math.abs(Date.now() - astat.ctime.getTime()) < 1000)
+    t.end()
+  }))
+})
+
+t.test('nocreate should throw on ENOENT', function (t) {
+  t.throws(function () {
+    touch.sync('sync-noent', { nocreate: true })
+  })
+  touch('async-noent', { nocreate: true }, function (er) {
+    t.isa(er, Error)
+    t.end()
+  })
+})
+
+t.test('use one file as ref for another', function (t) {
+  touch.sync('sync-ref', { ref: 'sync' })
+  touch('async-ref', { ref: 'async' }, _(function () {
+    var astat = fs.statSync("async")
+    var sstat = fs.statSync("sync")
+    var arstat = fs.statSync('async-ref')
+    var srstat = fs.statSync('sync-ref')
+
+    var asa = astat.atime.getTime()
+    var ssa = sstat.atime.getTime()
+    var arsa = arstat.atime.getTime()
+    var srsa = srstat.atime.getTime()
+
+    var asm = astat.mtime.getTime()
+    var ssm = sstat.mtime.getTime()
+    var arsm = arstat.mtime.getTime()
+    var srsm = srstat.mtime.getTime()
+
+    var arsc = arstat.ctime.getTime()
+    var srsc = srstat.ctime.getTime()
+
+    t.equal(asm, arsm)
+    t.equal(ssm, srsm)
+
+    t.equal(asa, arsa)
+    t.equal(ssa, srsa)
+
+    t.ok(Math.abs(Date.now() - srsc) < 1000)
+    t.ok(Math.abs(Date.now() - arsc) < 1000)
+    t.end()
+  }))
+})
+
+
+t.test('cleanup', function (t) {
+  files.forEach(function (f) {
+    t.doesNotThrow('rm ' + f, function () {
+      fs.unlinkSync(f)
+    })
+  })
+  t.end()
+})

node_modules/touch/touch.js

@@ -0,0 +1,158 @@
+var fs = require("fs")
+  , cons = require("constants")
+
+module.exports = touch
+touch.touchSync = touch.sync = function (f, options) {
+  return touch(f, options)
+}
+
+touch.ftouch = ftouch
+touch.ftouchSync = ftouch.sync = function (fd, options) {
+  return ftouch(fd, options)
+}
+
+function validOpts (options) {
+  options = Object.create(options || {})
+
+  // {mtime: true}, {ctime: true}
+  // If set to something else, then treat as epoch ms value
+  var now = new Date(options.time || Date.now())
+  if (!options.atime && !options.mtime) {
+    options.atime = options.mtime = now
+  } else {
+    if (true === options.atime) {
+      options.atime = now
+    }
+    if (true === options.mtime) {
+      options.mtime = now
+    }
+  }
+
+  var oflags = 0
+  if (!options.force) {
+    oflags = oflags | cons.O_RDWR
+  }
+
+  if (!options.nocreate) {
+    oflags = oflags | cons.O_CREAT
+  }
+
+  options.oflags = oflags
+  return options
+}
+
+function optionsRef (then, arg, options, cb) {
+  if (!options.ref) return then(arg, options, cb)
+
+  return cb
+       ? fs.stat(options.ref, optionsRefcb(then, arg, options, cb))
+       : optionsRefcb(then, arg, options)(null, fs.statSync(options.ref))
+}
+
+function optionsRefcb (then, arg, options, cb) { return function (er, s) {
+  if (er) {
+    er.path = er.file = options.ref
+    return cb(er)
+  }
+  options.atime = options.atime && s.atime.getTime()
+  options.mtime = options.mtime && s.mtime.getTime()
+
+  // so we don't keep doing this.
+  options.ref = null
+
+  return then(arg, options, cb)
+}}
+
+function touch (f, options, cb) {
+  if (typeof options === "function") cb = options, options = null
+  options = validOpts(options)
+  return optionsRef(touch_, f, validOpts(options), cb)
+}
+
+function touch_ (f, options, cb) {
+  return openThenF(f, options, cb)
+}
+
+function openThenF (f, options, cb) {
+  options.closeAfter = true
+  return cb
+       ? fs.open(f, options.oflags, openThenFcb(options, cb))
+       : openThenFcb(options)(null, fs.openSync(f, options.oflags))
+}
+
+function openThenFcb (options, cb) { return function (er, fd) {
+  if (er) {
+    if (fd && options.closeAfter) fs.close(fd, function () {})
+    return cb(er)
+  }
+  return ftouch(fd, options, cb)
+}}
+
+function ftouch (fd, options, cb) {
+  if (typeof options === "function") cb = options, options = null
+  return optionsRef(ftouch_, fd, validOpts(options), cb)
+}
+
+function ftouch_ (fd, options, cb) {
+  // still not set.  leave as what the file already has.
+  return fstatThenFutimes(fd, options, cb)
+}
+
+function fstatThenFutimes (fd, options, cb) {
+  if (options.atime && options.mtime) return thenFutimes(fd, options, cb)
+
+  return cb
+       ? fs.fstat(fd, fstatThenFutimescb(fd, options, cb))
+       : fstatThenFutimescb(fd, options)(null, fs.fstatSync(fd))
+}
+
+function fstatThenFutimescb (fd, options, cb) { return function (er, s) {
+  if (er) {
+    if (options.closeAfter) fs.close(fd, function () {})
+    return cb(er)
+  }
+  options.atime = options.atime || s.atime.getTime()
+  options.mtime = options.mtime || s.mtime.getTime()
+  return thenFutimes(fd, options, cb)
+}}
+
+function thenFutimes (fd, options, cb) {
+  if (typeof options.atime === "object") {
+    options.atime = options.atime.getTime()
+  }
+  if (typeof options.mtime === "object") {
+    options.mtime = options.mtime.getTime()
+  }
+
+  var a = parseInt(options.atime / 1000, 10)
+    , m = parseInt(options.mtime / 1000, 10)
+  return cb
+       ? fs.futimes(fd, a, m, thenFutimescb(fd, options, cb))
+       : thenFutimescb(fd, options)(null, fs.futimesSync(fd, a, m))
+}
+
+function thenFutimescb (fd, options, cb) { return function (er, res) {
+  if (er) {
+    if (options.closeAfter) fs.close(fd, function () {})
+    return cb(er)
+  }
+  return finish(fd, options, res, cb)
+}}
+
+function finish (fd, options, res, cb) {
+  return options.closeAfter ? finishClose(fd, options, res, cb)
+       : cb ? cb(null, res)
+       : res
+}
+
+function finishClose (fd, options, res, cb) {
+  return cb
+       ? fs.close(fd, finishClosecb(res, options, cb))
+       : finishClosecb(res, options)(null, fs.closeSync(fd))
+}
+
+function finishClosecb (res, options, cb) { return function (er) {
+  if (er) return cb(er)
+  options.closeAfter = null
+  return finish(null, options, res, cb)
+}}