Deployed the page to Github Pages.

node_modules/nopt/lib/debug.js

@@ -0,0 +1,5 @@
+/* istanbul ignore next */
+module.exports = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
+  // eslint-disable-next-line no-console
+  ? (...a) => console.error(...a)
+  : () => {}

node_modules/nopt/lib/nopt-lib.js

@@ -0,0 +1,479 @@
+const abbrev = require('abbrev')
+const debug = require('./debug')
+const defaultTypeDefs = require('./type-defs')
+
+const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
+
+const getType = (k, { types, dynamicTypes }) => {
+  let hasType = hasOwn(types, k)
+  let type = types[k]
+  if (!hasType && typeof dynamicTypes === 'function') {
+    const matchedType = dynamicTypes(k)
+    if (matchedType !== undefined) {
+      type = matchedType
+      hasType = true
+    }
+  }
+  return [hasType, type]
+}
+
+const isTypeDef = (type, def) => def && type === def
+const hasTypeDef = (type, def) => def && type.indexOf(def) !== -1
+const doesNotHaveTypeDef = (type, def) => def && !hasTypeDef(type, def)
+
+function nopt (args, {
+  types,
+  shorthands,
+  typeDefs,
+  invalidHandler,
+  typeDefault,
+  dynamicTypes,
+} = {}) {
+  debug(types, shorthands, args, typeDefs)
+
+  const data = {}
+  const argv = {
+    remain: [],
+    cooked: args,
+    original: args.slice(0),
+  }
+
+  parse(args, data, argv.remain, { typeDefs, types, dynamicTypes, shorthands })
+
+  // now data is full
+  clean(data, { types, dynamicTypes, typeDefs, invalidHandler, typeDefault })
+  data.argv = argv
+
+  Object.defineProperty(data.argv, 'toString', {
+    value: function () {
+      return this.original.map(JSON.stringify).join(' ')
+    },
+    enumerable: false,
+  })
+
+  return data
+}
+
+function clean (data, {
+  types = {},
+  typeDefs = {},
+  dynamicTypes,
+  invalidHandler,
+  typeDefault,
+} = {}) {
+  const StringType = typeDefs.String?.type
+  const NumberType = typeDefs.Number?.type
+  const ArrayType = typeDefs.Array?.type
+  const BooleanType = typeDefs.Boolean?.type
+  const DateType = typeDefs.Date?.type
+
+  const hasTypeDefault = typeof typeDefault !== 'undefined'
+  if (!hasTypeDefault) {
+    typeDefault = [false, true, null]
+    if (StringType) {
+      typeDefault.push(StringType)
+    }
+    if (ArrayType) {
+      typeDefault.push(ArrayType)
+    }
+  }
+
+  const remove = {}
+
+  Object.keys(data).forEach((k) => {
+    if (k === 'argv') {
+      return
+    }
+    let val = data[k]
+    debug('val=%j', val)
+    const isArray = Array.isArray(val)
+    let [hasType, rawType] = getType(k, { types, dynamicTypes })
+    let type = rawType
+    if (!isArray) {
+      val = [val]
+    }
+    if (!type) {
+      type = typeDefault
+    }
+    if (isTypeDef(type, ArrayType)) {
+      type = typeDefault.concat(ArrayType)
+    }
+    if (!Array.isArray(type)) {
+      type = [type]
+    }
+
+    debug('val=%j', val)
+    debug('types=', type)
+    val = val.map((v) => {
+      // if it's an unknown value, then parse false/true/null/numbers/dates
+      if (typeof v === 'string') {
+        debug('string %j', v)
+        v = v.trim()
+        if ((v === 'null' && ~type.indexOf(null))
+            || (v === 'true' &&
+               (~type.indexOf(true) || hasTypeDef(type, BooleanType)))
+            || (v === 'false' &&
+               (~type.indexOf(false) || hasTypeDef(type, BooleanType)))) {
+          v = JSON.parse(v)
+          debug('jsonable %j', v)
+        } else if (hasTypeDef(type, NumberType) && !isNaN(v)) {
+          debug('convert to number', v)
+          v = +v
+        } else if (hasTypeDef(type, DateType) && !isNaN(Date.parse(v))) {
+          debug('convert to date', v)
+          v = new Date(v)
+        }
+      }
+
+      if (!hasType) {
+        if (!hasTypeDefault) {
+          return v
+        }
+        // if the default type has been passed in then we want to validate the
+        // unknown data key instead of bailing out earlier. we also set the raw
+        // type which is passed to the invalid handler so that it can be
+        // determined if during validation if it is unknown vs invalid
+        rawType = typeDefault
+      }
+
+      // allow `--no-blah` to set 'blah' to null if null is allowed
+      if (v === false && ~type.indexOf(null) &&
+          !(~type.indexOf(false) || hasTypeDef(type, BooleanType))) {
+        v = null
+      }
+
+      const d = {}
+      d[k] = v
+      debug('prevalidated val', d, v, rawType)
+      if (!validate(d, k, v, rawType, { typeDefs })) {
+        if (invalidHandler) {
+          invalidHandler(k, v, rawType, data)
+        } else if (invalidHandler !== false) {
+          debug('invalid: ' + k + '=' + v, rawType)
+        }
+        return remove
+      }
+      debug('validated v', d, v, rawType)
+      return d[k]
+    }).filter((v) => v !== remove)
+
+    // if we allow Array specifically, then an empty array is how we
+    // express 'no value here', not null.  Allow it.
+    if (!val.length && doesNotHaveTypeDef(type, ArrayType)) {
+      debug('VAL HAS NO LENGTH, DELETE IT', val, k, type.indexOf(ArrayType))
+      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 validate (data, k, val, type, { typeDefs } = {}) {
+  const ArrayType = typeDefs?.Array?.type
+  // arrays are lists of types.
+  if (Array.isArray(type)) {
+    for (let i = 0, l = type.length; i < l; i++) {
+      if (isTypeDef(type[i], ArrayType)) {
+        continue
+      }
+      if (validate(data, k, val, type[i], { typeDefs })) {
+        return true
+      }
+    }
+    delete data[k]
+    return false
+  }
+
+  // an array of anything?
+  if (isTypeDef(type, ArrayType)) {
+    return true
+  }
+
+  // Original comment:
+  // NaN is poisonous.  Means that something is not allowed.
+  // New comment: Changing this to an isNaN check breaks a lot of tests.
+  // Something is being assumed here that is not actually what happens in
+  // practice.  Fixing it is outside the scope of getting linting to pass in
+  // this repo. Leaving as-is for now.
+  /* eslint-disable-next-line no-self-compare */
+  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)
+    data[k] = val
+    return true
+  }
+
+  // now go through the list of typeDefs, validate against each one.
+  let ok = false
+  const types = Object.keys(typeDefs)
+  for (let i = 0, l = types.length; i < l; i++) {
+    debug('test type %j %j %j', k, val, types[i])
+    const t = typeDefs[types[i]]
+    if (t && (
+      (type && type.name && t.type && t.type.name) ?
+        (type.name === t.type.name) :
+        (type === t.type)
+    )) {
+      const d = {}
+      ok = t.validate(d, k, val) !== false
+      val = d[k]
+      if (ok) {
+        data[k] = val
+        break
+      }
+    }
+  }
+  debug('OK? %j (%j %j %j)', ok, k, val, types[types.length - 1])
+
+  if (!ok) {
+    delete data[k]
+  }
+  return ok
+}
+
+function parse (args, data, remain, {
+  types = {},
+  typeDefs = {},
+  shorthands = {},
+  dynamicTypes,
+} = {}) {
+  const StringType = typeDefs.String?.type
+  const NumberType = typeDefs.Number?.type
+  const ArrayType = typeDefs.Array?.type
+  const BooleanType = typeDefs.Boolean?.type
+
+  debug('parse', args, data, remain)
+
+  const abbrevs = abbrev(Object.keys(types))
+  debug('abbrevs=%j', abbrevs)
+  const shortAbbr = abbrev(Object.keys(shorthands))
+
+  for (let i = 0; i < args.length; i++) {
+    let 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
+    }
+    let hadEq = false
+    if (arg.charAt(0) === '-' && arg.length > 1) {
+      const at = arg.indexOf('=')
+      if (at > -1) {
+        hadEq = true
+        const v = arg.slice(at + 1)
+        arg = arg.slice(0, at)
+        args.splice(i, 1, arg, v)
+      }
+
+      // see if it's a shorthand
+      // if so, splice and back up to re-parse it.
+      const shRes = resolveShort(arg, shortAbbr, abbrevs, { shorthands })
+      debug('arg=%j shRes=%j', arg, shRes)
+      if (shRes) {
+        args.splice.apply(args, [i, 1].concat(shRes))
+        if (arg !== shRes[0]) {
+          i--
+          continue
+        }
+      }
+      arg = arg.replace(/^-+/, '')
+      let no = null
+      while (arg.toLowerCase().indexOf('no-') === 0) {
+        no = !no
+        arg = arg.slice(3)
+      }
+
+      if (abbrevs[arg]) {
+        arg = abbrevs[arg]
+      }
+
+      let [hasType, argType] = getType(arg, { types, dynamicTypes })
+      let isTypeArray = Array.isArray(argType)
+      if (isTypeArray && argType.length === 1) {
+        isTypeArray = false
+        argType = argType[0]
+      }
+
+      let isArray = isTypeDef(argType, ArrayType) ||
+        isTypeArray && hasTypeDef(argType, ArrayType)
+
+      // allow unknown things to be arrays if specified multiple times.
+      if (!hasType && hasOwn(data, arg)) {
+        if (!Array.isArray(data[arg])) {
+          data[arg] = [data[arg]]
+        }
+        isArray = true
+      }
+
+      let val
+      let la = args[i + 1]
+
+      const isBool = typeof no === 'boolean' ||
+        isTypeDef(argType, BooleanType) ||
+        isTypeArray && hasTypeDef(argType, BooleanType) ||
+        (typeof argType === 'undefined' && !hadEq) ||
+        (la === 'false' &&
+         (argType === null ||
+          isTypeArray && ~argType.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 (isTypeArray && la) {
+          if (~argType.indexOf(la)) {
+            // an explicit type
+            val = la
+            i++
+          } else if (la === 'null' && ~argType.indexOf(null)) {
+            // null allowed
+            val = null
+            i++
+          } else if (!la.match(/^-{2,}[^-]/) &&
+                      !isNaN(la) &&
+                      hasTypeDef(argType, NumberType)) {
+            // number
+            val = +la
+            i++
+          } else if (!la.match(/^-[^-]/) && hasTypeDef(argType, StringType)) {
+            // string
+            val = la
+            i++
+          }
+        }
+
+        if (isArray) {
+          (data[arg] = data[arg] || []).push(val)
+        } else {
+          data[arg] = val
+        }
+
+        continue
+      }
+
+      if (isTypeDef(argType, StringType)) {
+        if (la === undefined) {
+          la = ''
+        } else if (la.match(/^-{1,2}[^-]+/)) {
+          la = ''
+          i--
+        }
+      }
+
+      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)
+  }
+}
+
+const SINGLES = Symbol('singles')
+const singleCharacters = (arg, shorthands) => {
+  let singles = shorthands[SINGLES]
+  if (!singles) {
+    singles = Object.keys(shorthands).filter((s) => s.length === 1).reduce((l, r) => {
+      l[r] = true
+      return l
+    }, {})
+    shorthands[SINGLES] = singles
+    debug('shorthand singles', singles)
+  }
+  const chrs = arg.split('').filter((c) => singles[c])
+  return chrs.join('') === arg ? chrs : null
+}
+
+function resolveShort (arg, ...rest) {
+  const { types = {}, shorthands = {} } = rest.length ? rest.pop() : {}
+  const shortAbbr = rest[0] ?? abbrev(Object.keys(shorthands))
+  const abbrevs = rest[1] ?? abbrev(Object.keys(types))
+
+  // 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 it's an exact known option, then don't go any further
+  if (abbrevs[arg] === arg) {
+    return null
+  }
+
+  // if it's an exact known shortopt, same deal
+  if (shorthands[arg]) {
+    // make it an array, if it's a list of words
+    if (shorthands[arg] && !Array.isArray(shorthands[arg])) {
+      shorthands[arg] = shorthands[arg].split(/\s+/)
+    }
+
+    return shorthands[arg]
+  }
+
+  // first check to see if this arg is a set of single-char shorthands
+  const chrs = singleCharacters(arg, shorthands)
+  if (chrs) {
+    return chrs.map((c) => shorthands[c]).reduce((l, r) => l.concat(r), [])
+  }
+
+  // if it's an arg abbrev, and not a literal shorthand, then prefer the arg
+  if (abbrevs[arg] && !shorthands[arg]) {
+    return null
+  }
+
+  // if it's an abbr for a shorthand, then use that
+  if (shortAbbr[arg]) {
+    arg = shortAbbr[arg]
+  }
+
+  // make it an array, if it's a list of words
+  if (shorthands[arg] && !Array.isArray(shorthands[arg])) {
+    shorthands[arg] = shorthands[arg].split(/\s+/)
+  }
+
+  return shorthands[arg]
+}
+
+module.exports = {
+  nopt,
+  clean,
+  parse,
+  validate,
+  resolveShort,
+  typeDefs: defaultTypeDefs,
+}

node_modules/nopt/lib/nopt.js

@@ -0,0 +1,30 @@
+const lib = require('./nopt-lib')
+const defaultTypeDefs = require('./type-defs')
+
+// This is the version of nopt's API that requires setting typeDefs and invalidHandler
+// on the required `nopt` object since it is a singleton. To not do a breaking change
+// an API that requires all options be passed in is located in `nopt-lib.js` and
+// exported here as lib.
+// TODO(breaking): make API only work in non-singleton mode
+
+module.exports = exports = nopt
+exports.clean = clean
+exports.typeDefs = defaultTypeDefs
+exports.lib = lib
+
+function nopt (types, shorthands, args = process.argv, slice = 2) {
+  return lib.nopt(args.slice(slice), {
+    types: types || {},
+    shorthands: shorthands || {},
+    typeDefs: exports.typeDefs,
+    invalidHandler: exports.invalidHandler,
+  })
+}
+
+function clean (data, types, typeDefs = exports.typeDefs) {
+  return lib.clean(data, {
+    types: types || {},
+    typeDefs,
+    invalidHandler: exports.invalidHandler,
+  })
+}

node_modules/nopt/lib/type-defs.js

@@ -0,0 +1,91 @@
+const url = require('url')
+const path = require('path')
+const Stream = require('stream').Stream
+const os = require('os')
+const debug = require('./debug')
+
+function validateString (data, k, val) {
+  data[k] = String(val)
+}
+
+function validatePath (data, k, val) {
+  if (val === true) {
+    return false
+  }
+  if (val === null) {
+    return true
+  }
+
+  val = String(val)
+
+  const isWin = process.platform === 'win32'
+  const homePattern = isWin ? /^~(\/|\\)/ : /^~\//
+  const home = os.homedir()
+
+  if (home && val.match(homePattern)) {
+    data[k] = path.resolve(home, val.slice(2))
+  } else {
+    data[k] = path.resolve(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) {
+  const s = Date.parse(val)
+  debug('validate Date %j %j %j', k, val, s)
+  if (isNaN(s)) {
+    return false
+  }
+  data[k] = new Date(val)
+}
+
+function validateBoolean (data, k, val) {
+  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) {
+  // Changing this would be a breaking change in the npm cli
+  /* eslint-disable-next-line node/no-deprecated-api */
+  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
+}
+
+module.exports = {
+  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 },
+  Array: { type: Array },
+}