@nirvana-labs/nirvana 1.31.0 → 1.32.0

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/nerf-dart.js

@@ -0,0 +1,18 @@
+const { URL } = require('node:url')
+
+/**
+ * Maps a URL to an identifier.
+ *
+ * Name courtesy schiffertronix media LLC, a New Jersey corporation
+ *
+ * @param {String} uri The URL to be nerfed.
+ *
+ * @returns {String} A nerfed URL.
+ */
+module.exports = (url) => {
+  const parsed = new URL(url)
+  const from = `${parsed.protocol}//${parsed.host}${parsed.pathname}`
+  const rel = new URL('.', from)
+  const res = `//${rel.host}${rel.pathname}`
+  return res
+}

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/parse-field.js

@@ -0,0 +1,86 @@
+// Parse a field, coercing it to the best type available.
+const typeDefs = require('./type-defs.js')
+const envReplace = require('./env-replace.js')
+const { resolve } = require('node:path')
+
+const { parse: umaskParse } = require('./umask.js')
+
+const parseField = (f, key, opts, listElement = false) => {
+  if (typeof f !== 'string' && !Array.isArray(f)) {
+    return f
+  }
+
+  const { platform, types, home, env } = opts
+
+  // type can be array or a single thing.  coerce to array.
+  const typeList = new Set([].concat(types[key]))
+  const isPath = typeList.has(typeDefs.path.type)
+  const isBool = typeList.has(typeDefs.Boolean.type)
+  const isString = isPath || typeList.has(typeDefs.String.type)
+  const isUmask = typeList.has(typeDefs.Umask.type)
+  const isNumber = typeList.has(typeDefs.Number.type)
+  const isList = !listElement && typeList.has(Array)
+  const isDate = typeList.has(typeDefs.Date.type)
+
+  if (Array.isArray(f)) {
+    return !isList ? f : f.map(field => parseField(field, key, opts, true))
+  }
+
+  // now we know it's a string
+  f = f.trim()
+
+  // list types get put in the environment separated by double-\n
+  // usually a single \n would suffice, but ca/cert configs can contain
+  // line breaks and multiple entries.
+  if (isList) {
+    return parseField(f.split('\n\n'), key, opts)
+  }
+
+  // --foo is like --foo=true for boolean types
+  if (isBool && !isString && f === '') {
+    return true
+  }
+
+  // string types can be the string 'true', 'false', etc.
+  // otherwise, parse these values out
+  if (!isString && !isPath && !isNumber) {
+    switch (f) {
+      case 'true': return true
+      case 'false': return false
+      case 'null': return null
+      case 'undefined': return undefined
+    }
+  }
+
+  f = envReplace(f, env)
+
+  if (isDate) {
+    return new Date(f)
+  }
+
+  if (isPath) {
+    const homePattern = platform === 'win32' ? /^~(\/|\\)/ : /^~\//
+    if (homePattern.test(f) && home) {
+      f = resolve(home, f.slice(2))
+    } else {
+      f = resolve(f)
+    }
+  }
+
+  if (isUmask) {
+    try {
+      return umaskParse(f)
+    } catch (er) {
+      // let it warn later when we validate
+      return f
+    }
+  }
+
+  if (isNumber && !isNaN(f)) {
+    f = +f
+  }
+
+  return f
+}
+
+module.exports = parseField

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/set-envs.js

@@ -0,0 +1,113 @@
+// Set environment variables for any non-default configs,
+// so that they're already there when we run lifecycle scripts.
+//
+// See https://github.com/npm/rfcs/pull/90
+
+// Return the env key if this is a thing that belongs in the env.
+// Ie, if the key isn't a @scope, //nerf.dart, or _private,
+// and the value is a string or array.  Otherwise return false.
+const envKey = (key, val) => {
+  return !/^[/@_]/.test(key) &&
+    (typeof envVal(val) === 'string') &&
+      `npm_config_${key.replace(/-/g, '_').toLowerCase()}`
+}
+
+const envVal = val => Array.isArray(val) ? val.map(v => envVal(v)).join('\n\n')
+  : val === null || val === undefined || val === false ? ''
+  : typeof val === 'object' ? null
+  : String(val)
+
+const sameConfigValue = (def, val) =>
+  !Array.isArray(val) || !Array.isArray(def) ? def === val
+  : sameArrayValue(def, val)
+
+const sameArrayValue = (def, val) => {
+  if (def.length !== val.length) {
+    return false
+  }
+
+  for (let i = 0; i < def.length; i++) {
+    /* istanbul ignore next - there are no array configs where the default
+     * is not an empty array, so this loop is a no-op, but it's the correct
+     * thing to do if we ever DO add a config like that. */
+    if (def[i] !== val[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+const setEnv = (env, rawKey, rawVal) => {
+  const val = envVal(rawVal)
+  const key = envKey(rawKey, val)
+  if (key && val !== null) {
+    env[key] = val
+  }
+}
+
+const setEnvs = (config) => {
+  // This ensures that all npm config values that are not the defaults are
+  // shared appropriately with child processes, without false positives.
+  const {
+    env,
+    defaults,
+    definitions,
+    list: [cliConf, envConf],
+  } = config
+
+  env.INIT_CWD = process.cwd()
+
+  // if the key is deprecated, skip it always.
+  // if the key is the default value,
+  //   if the environ is NOT the default value,
+  //     set the environ
+  //   else skip it, it's fine
+  // if the key is NOT the default value,
+  //   if the env is setting it, then leave it (already set)
+  //   otherwise, set the env
+  const cliSet = new Set(Object.keys(cliConf))
+  const envSet = new Set(Object.keys(envConf))
+  for (const key in cliConf) {
+    const { deprecated, envExport = true } = definitions[key] || {}
+    if (deprecated || envExport === false) {
+      continue
+    }
+
+    if (sameConfigValue(defaults[key], cliConf[key])) {
+      // config is the default, if the env thought different, then we
+      // have to set it BACK to the default in the environment.
+      if (!sameConfigValue(envConf[key], cliConf[key])) {
+        setEnv(env, key, cliConf[key])
+      }
+    } else {
+      // config is not the default.  if the env wasn't the one to set
+      // it that way, then we have to put it in the env
+      if (!(envSet.has(key) && !cliSet.has(key))) {
+        setEnv(env, key, cliConf[key])
+      }
+    }
+  }
+
+  // also set some other common nice envs that we want to rely on
+  env.HOME = config.home
+  // TODO this may not be the best away to persist these
+  env.npm_config_global_prefix = config.globalPrefix
+  env.npm_config_local_prefix = config.localPrefix
+  if (cliConf.editor) {
+    env.EDITOR = cliConf.editor
+  }
+
+  // note: this doesn't affect the *current* node process, of course, since
+  // it's already started, but it does affect the options passed to scripts.
+  if (cliConf['node-options']) {
+    env.NODE_OPTIONS = cliConf['node-options']
+  }
+  // the node-gyp bin uses this so we always set it
+  env.npm_config_node_gyp = cliConf['node-gyp']
+  // this doesn't have a full definition so we manually export it here
+  env.npm_config_npm_version = cliConf['npm-version'] || 'unknown'
+  env.npm_execpath = config.npmBin
+  env.NODE = env.npm_node_execpath = config.execPath
+}
+
+module.exports = setEnvs

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/type-defs.js

@@ -0,0 +1,61 @@
+const nopt = require('nopt')
+
+const { validate: validateUmask } = require('./umask.js')
+
+class Umask {}
+class Semver {}
+const semverValid = require('semver/functions/valid')
+const validateSemver = (data, k, val) => {
+  const valid = semverValid(val)
+  if (!valid) {
+    return false
+  }
+  data[k] = valid
+}
+
+const noptValidatePath = nopt.typeDefs.path.validate
+const validatePath = (data, k, val) => {
+  if (typeof val !== 'string') {
+    return false
+  }
+  return noptValidatePath(data, k, val)
+}
+
+// add descriptions so we can validate more usefully
+module.exports = {
+  ...nopt.typeDefs,
+  semver: {
+    type: Semver,
+    validate: validateSemver,
+    description: 'full valid SemVer string',
+  },
+  Umask: {
+    type: Umask,
+    validate: validateUmask,
+    description: 'octal number in range 0o000..0o777 (0..511)',
+  },
+  url: {
+    ...nopt.typeDefs.url,
+    description: 'full url with "http://"',
+  },
+  path: {
+    ...nopt.typeDefs.path,
+    validate: validatePath,
+    description: 'valid filesystem path',
+  },
+  Number: {
+    ...nopt.typeDefs.Number,
+    description: 'numeric value',
+  },
+  Boolean: {
+    ...nopt.typeDefs.Boolean,
+    description: 'boolean value (true or false)',
+  },
+  Date: {
+    ...nopt.typeDefs.Date,
+    description: 'valid Date string',
+  },
+}
+
+// TODO: make nopt less of a global beast so this kludge isn't necessary
+nopt.typeDefs = module.exports

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/type-description.js

@@ -0,0 +1,21 @@
+// return the description of the valid values of a field
+// returns a string for one thing, or an array of descriptions
+const typeDefs = require('./type-defs.js')
+const typeDescription = t => {
+  if (!t || typeof t !== 'function' && typeof t !== 'object') {
+    return t
+  }
+
+  if (Array.isArray(t)) {
+    return t.map(t => typeDescription(t))
+  }
+
+  for (const { type, description } of Object.values(typeDefs)) {
+    if (type === t) {
+      return description || type
+    }
+  }
+
+  return t
+}
+module.exports = t => [].concat(typeDescription(t)).filter(t => t !== undefined)

package/oidc/node_modules/npm/node_modules/@npmcli/config/lib/umask.js

@@ -0,0 +1,35 @@
+const parse = val => {
+  // this is run via nopt and parse field where everything is
+  // converted to a string first, ignoring coverage for now
+  // instead of figuring out what is happening under the hood in nopt
+  // istanbul ignore else
+  if (typeof val === 'string') {
+    if (/^0o?[0-7]+$/.test(val)) {
+      return parseInt(val.replace(/^0o?/, ''), 8)
+    } else if (/^[1-9][0-9]*$/.test(val)) {
+      return parseInt(val, 10)
+    } else {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+  } else {
+    if (typeof val !== 'number') {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+    val = Math.floor(val)
+    if (val < 0 || val > 511) {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+    return val
+  }
+}
+
+const validate = (data, k, val) => {
+  try {
+    data[k] = parse(val)
+    return true
+  } catch (er) {
+    return false
+  }
+}
+
+module.exports = { parse, validate }

package/oidc/node_modules/npm/node_modules/@npmcli/config/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@npmcli/config",
+  "version": "10.4.2",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "main": "lib/index.js",
+  "description": "Configuration management for the npm cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/config"
+  },
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "lint": "npm run eslint",
+    "postlint": "template-oss-check",
+    "lintfix": "npm run eslint -- --fix",
+    "posttest": "npm run lint",
+    "template-oss-apply": "template-oss-apply --force",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+  },
+  "tap": {
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.1",
+    "@npmcli/mock-globals": "^1.0.0",
+    "@npmcli/template-oss": "4.25.1",
+    "tap": "^16.3.8"
+  },
+  "dependencies": {
+    "@npmcli/map-workspaces": "^5.0.0",
+    "@npmcli/package-json": "^7.0.0",
+    "ci-info": "^4.0.0",
+    "ini": "^5.0.0",
+    "nopt": "^8.1.0",
+    "proc-log": "^5.0.0",
+    "semver": "^7.3.5",
+    "walk-up-path": "^4.0.0"
+  },
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "4.25.1",
+    "content": "../../scripts/template-oss/index.js"
+  }
+}

package/oidc/node_modules/npm/node_modules/@npmcli/fs/LICENSE.md

@@ -0,0 +1,20 @@
+<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
+
+ISC License
+
+Copyright npm, Inc.
+
+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 NPM DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+EVENT SHALL NPM 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.

package/oidc/node_modules/npm/node_modules/@npmcli/fs/lib/common/get-options.js

@@ -0,0 +1,20 @@
+// given an input that may or may not be an object, return an object that has
+// a copy of every defined property listed in 'copy'. if the input is not an
+// object, assign it to the property named by 'wrap'
+const getOptions = (input, { copy, wrap }) => {
+  const result = {}
+
+  if (input && typeof input === 'object') {
+    for (const prop of copy) {
+      if (input[prop] !== undefined) {
+        result[prop] = input[prop]
+      }
+    }
+  } else {
+    result[wrap] = input
+  }
+
+  return result
+}
+
+module.exports = getOptions

package/oidc/node_modules/npm/node_modules/@npmcli/fs/lib/common/node.js

@@ -0,0 +1,9 @@
+const semver = require('semver')
+
+const satisfies = (range) => {
+  return semver.satisfies(process.version, range, { includePrerelease: true })
+}
+
+module.exports = {
+  satisfies,
+}

package/oidc/node_modules/npm/node_modules/@npmcli/fs/lib/cp/LICENSE

@@ -0,0 +1,15 @@
+(The MIT License)
+
+Copyright (c) 2011-2017 JP Richardson
+
+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.

package/oidc/node_modules/npm/node_modules/@npmcli/fs/lib/cp/errors.js

@@ -0,0 +1,129 @@
+'use strict'
+const { inspect } = require('util')
+
+// adapted from node's internal/errors
+// https://github.com/nodejs/node/blob/c8a04049/lib/internal/errors.js
+
+// close copy of node's internal SystemError class.
+class SystemError {
+  constructor (code, prefix, context) {
+    // XXX context.code is undefined in all constructors used in cp/polyfill
+    // that may be a bug copied from node, maybe the constructor should use
+    // `code` not `errno`?  nodejs/node#41104
+    let message = `${prefix}: ${context.syscall} returned ` +
+                  `${context.code} (${context.message})`
+
+    if (context.path !== undefined) {
+      message += ` ${context.path}`
+    }
+    if (context.dest !== undefined) {
+      message += ` => ${context.dest}`
+    }
+
+    this.code = code
+    Object.defineProperties(this, {
+      name: {
+        value: 'SystemError',
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      },
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      },
+      info: {
+        value: context,
+        enumerable: true,
+        configurable: true,
+        writable: false,
+      },
+      errno: {
+        get () {
+          return context.errno
+        },
+        set (value) {
+          context.errno = value
+        },
+        enumerable: true,
+        configurable: true,
+      },
+      syscall: {
+        get () {
+          return context.syscall
+        },
+        set (value) {
+          context.syscall = value
+        },
+        enumerable: true,
+        configurable: true,
+      },
+    })
+
+    if (context.path !== undefined) {
+      Object.defineProperty(this, 'path', {
+        get () {
+          return context.path
+        },
+        set (value) {
+          context.path = value
+        },
+        enumerable: true,
+        configurable: true,
+      })
+    }
+
+    if (context.dest !== undefined) {
+      Object.defineProperty(this, 'dest', {
+        get () {
+          return context.dest
+        },
+        set (value) {
+          context.dest = value
+        },
+        enumerable: true,
+        configurable: true,
+      })
+    }
+  }
+
+  toString () {
+    return `${this.name} [${this.code}]: ${this.message}`
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')] (_recurseTimes, ctx) {
+    return inspect(this, {
+      ...ctx,
+      getters: true,
+      customInspect: false,
+    })
+  }
+}
+
+function E (code, message) {
+  module.exports[code] = class NodeError extends SystemError {
+    constructor (ctx) {
+      super(code, message, ctx)
+    }
+  }
+}
+
+E('ERR_FS_CP_DIR_TO_NON_DIR', 'Cannot overwrite directory with non-directory')
+E('ERR_FS_CP_EEXIST', 'Target already exists')
+E('ERR_FS_CP_EINVAL', 'Invalid src or dest')
+E('ERR_FS_CP_FIFO_PIPE', 'Cannot copy a FIFO pipe')
+E('ERR_FS_CP_NON_DIR_TO_DIR', 'Cannot overwrite non-directory with directory')
+E('ERR_FS_CP_SOCKET', 'Cannot copy a socket file')
+E('ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY', 'Cannot overwrite symlink in subdirectory of self')
+E('ERR_FS_CP_UNKNOWN', 'Cannot copy an unknown file type')
+E('ERR_FS_EISDIR', 'Path is a directory')
+
+module.exports.ERR_INVALID_ARG_TYPE = class ERR_INVALID_ARG_TYPE extends Error {
+  constructor (name, expected, actual) {
+    super()
+    this.code = 'ERR_INVALID_ARG_TYPE'
+    this.message = `The ${name} argument must be ${expected}. Received ${typeof actual}`
+  }
+}

package/oidc/node_modules/npm/node_modules/@npmcli/fs/lib/cp/index.js

@@ -0,0 +1,22 @@
+const fs = require('fs/promises')
+const getOptions = require('../common/get-options.js')
+const node = require('../common/node.js')
+const polyfill = require('./polyfill.js')
+
+// node 16.7.0 added fs.cp
+const useNative = node.satisfies('>=16.7.0')
+
+const cp = async (src, dest, opts) => {
+  const options = getOptions(opts, {
+    copy: ['dereference', 'errorOnExist', 'filter', 'force', 'preserveTimestamps', 'recursive'],
+  })
+
+  // the polyfill is tested separately from this module, no need to hack
+  // process.version to try to trigger it just for coverage
+  // istanbul ignore next
+  return useNative
+    ? fs.cp(src, dest, options)
+    : polyfill(src, dest, options)
+}
+
+module.exports = cp