@genesislcap/pbc-reconciliation-ui 0.0.21 → 0.0.23

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/read-user-info.js

@@ -1,68 +0,0 @@
-const read = require('read')
-const userValidate = require('npm-user-validate')
-const log = require('./log-shim.js')
-
-exports.otp = readOTP
-exports.password = readPassword
-exports.username = readUsername
-exports.email = readEmail
-
-const otpPrompt = `This command requires a one-time password (OTP) from your authenticator app.
-Enter one below. You can also pass one on the command line by appending --otp=123456.
-For more information, see:
-https://docs.npmjs.com/getting-started/using-two-factor-authentication
-Enter OTP: `
-const passwordPrompt = 'npm password: '
-const usernamePrompt = 'npm username: '
-const emailPrompt = 'email (this IS public): '
-
-function readWithProgress (opts) {
-  log.clearProgress()
-  return read(opts).finally(() => log.showProgress())
-}
-
-function readOTP (msg = otpPrompt, otp, isRetry) {
-  if (isRetry && otp && /^[\d ]+$|^[A-Fa-f0-9]{64,64}$/.test(otp)) {
-    return otp.replace(/\s+/g, '')
-  }
-
-  return readWithProgress({ prompt: msg, default: otp || '' })
-    .then((rOtp) => readOTP(msg, rOtp, true))
-}
-
-function readPassword (msg = passwordPrompt, password, isRetry) {
-  if (isRetry && password) {
-    return password
-  }
-
-  return readWithProgress({ prompt: msg, silent: true, default: password || '' })
-    .then((rPassword) => readPassword(msg, rPassword, true))
-}
-
-function readUsername (msg = usernamePrompt, username, isRetry) {
-  if (isRetry && username) {
-    const error = userValidate.username(username)
-    if (error) {
-      log.warn(error.message)
-    } else {
-      return Promise.resolve(username.trim())
-    }
-  }
-
-  return readWithProgress({ prompt: msg, default: username || '' })
-    .then((rUsername) => readUsername(msg, rUsername, true))
-}
-
-function readEmail (msg = emailPrompt, email, isRetry) {
-  if (isRetry && email) {
-    const error = userValidate.email(email)
-    if (error) {
-      log.warn(error.message)
-    } else {
-      return email.trim()
-    }
-  }
-
-  return readWithProgress({ prompt: msg, default: email || '' })
-    .then((username) => readEmail(msg, username, true))
-}

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/reify-finish.js

@@ -1,33 +0,0 @@
-const reifyOutput = require('./reify-output.js')
-const ini = require('ini')
-const { writeFile } = require('fs').promises
-const { resolve } = require('path')
-
-const reifyFinish = async (npm, arb) => {
-  await saveBuiltinConfig(npm, arb)
-  reifyOutput(npm, arb)
-}
-
-const saveBuiltinConfig = async (npm, arb) => {
-  const { options: { global }, actualTree } = arb
-  if (!global) {
-    return
-  }
-
-  // if we are using a builtin config, and just installed npm as
-  // a top-level global package, we have to preserve that config.
-  const npmNode = actualTree.inventory.get('node_modules/npm')
-  if (!npmNode) {
-    return
-  }
-
-  const builtinConf = npm.config.data.get('builtin')
-  if (builtinConf.loadError) {
-    return
-  }
-
-  const content = ini.stringify(builtinConf.raw).trim() + '\n'
-  await writeFile(resolve(npmNode.path, 'npmrc'), content)
-}
-
-module.exports = reifyFinish

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/reify-output.js

@@ -1,185 +0,0 @@
-// pass in an arborist object, and it'll output the data about what
-// was done, what was audited, etc.
-//
-// added ## packages, removed ## packages, and audited ## packages in 19.157s
-//
-// 1 package is looking for funding
-//   run `npm fund` for details
-//
-// found 37 vulnerabilities (5 low, 7 moderate, 25 high)
-//   run `npm audit fix` to fix them, or `npm audit` for details
-
-const log = require('./log-shim.js')
-const { depth } = require('treeverse')
-const ms = require('ms')
-const npmAuditReport = require('npm-audit-report')
-const { readTree: getFundingInfo } = require('libnpmfund')
-const auditError = require('./audit-error.js')
-
-// TODO: output JSON if flatOptions.json is true
-const reifyOutput = (npm, arb) => {
-  const { diff, actualTree } = arb
-
-  // note: fails and crashes if we're running audit fix and there was an error
-  // which is a good thing, because there's no point printing all this other
-  // stuff in that case!
-  const auditReport = auditError(npm, arb.auditReport) ? null : arb.auditReport
-
-  // don't print any info in --silent mode, but we still need to
-  // set the exitCode properly from the audit report, if we have one.
-  if (npm.silent) {
-    getAuditReport(npm, auditReport)
-    return
-  }
-
-  const summary = {
-    added: 0,
-    removed: 0,
-    changed: 0,
-    audited: auditReport && !auditReport.error ? actualTree.inventory.size : 0,
-    funding: 0,
-  }
-
-  if (diff) {
-    depth({
-      tree: diff,
-      visit: d => {
-        switch (d.action) {
-          case 'REMOVE':
-            summary.removed++
-            break
-          case 'ADD':
-            actualTree.inventory.has(d.ideal) && summary.added++
-            break
-          case 'CHANGE':
-            summary.changed++
-            break
-          default:
-            return
-        }
-        const node = d.actual || d.ideal
-        log.silly(d.action, node.location)
-      },
-      getChildren: d => d.children,
-    })
-  }
-
-  if (npm.flatOptions.fund) {
-    const fundingInfo = getFundingInfo(actualTree, { countOnly: true })
-    summary.funding = fundingInfo.length
-  }
-
-  if (npm.flatOptions.json) {
-    if (auditReport) {
-      // call this to set the exit code properly
-      getAuditReport(npm, auditReport)
-      summary.audit = npm.command === 'audit' ? auditReport
-        : auditReport.toJSON().metadata
-    }
-    npm.output(JSON.stringify(summary, 0, 2))
-  } else {
-    packagesChangedMessage(npm, summary)
-    packagesFundingMessage(npm, summary)
-    printAuditReport(npm, auditReport)
-  }
-}
-
-// if we're running `npm audit fix`, then we print the full audit report
-// at the end if there's still stuff, because it's silly for `npm audit`
-// to tell you to run `npm audit` for details.  otherwise, use the summary
-// report.  if we get here, we know it's not quiet or json.
-// If the loglevel is silent, then we just run the report
-// to get the exitCode set appropriately.
-const printAuditReport = (npm, report) => {
-  const res = getAuditReport(npm, report)
-  if (!res || !res.report) {
-    return
-  }
-  npm.output(`\n${res.report}`)
-}
-
-const getAuditReport = (npm, report) => {
-  if (!report) {
-    return
-  }
-
-  // when in silent mode, we print nothing.  the JSON output is
-  // going to just JSON.stringify() the report object.
-  const reporter = npm.silent ? 'quiet'
-    : npm.flatOptions.json ? 'quiet'
-    : npm.command !== 'audit' ? 'install'
-    : 'detail'
-  const defaultAuditLevel = npm.command !== 'audit' ? 'none' : 'low'
-  const auditLevel = npm.flatOptions.auditLevel || defaultAuditLevel
-
-  const res = npmAuditReport(report, {
-    reporter,
-    ...npm.flatOptions,
-    auditLevel,
-    chalk: npm.chalk,
-  })
-  if (npm.command === 'audit') {
-    process.exitCode = process.exitCode || res.exitCode
-  }
-  return res
-}
-
-const packagesChangedMessage = (npm, { added, removed, changed, audited }) => {
-  const msg = ['\n']
-  if (added === 0 && removed === 0 && changed === 0) {
-    msg.push('up to date')
-    if (audited) {
-      msg.push(', ')
-    }
-  } else {
-    if (added) {
-      msg.push(`added ${added} package${added === 1 ? '' : 's'}`)
-    }
-
-    if (removed) {
-      if (added) {
-        msg.push(', ')
-      }
-
-      if (added && !audited && !changed) {
-        msg.push('and ')
-      }
-
-      msg.push(`removed ${removed} package${removed === 1 ? '' : 's'}`)
-    }
-    if (changed) {
-      if (added || removed) {
-        msg.push(', ')
-      }
-
-      if (!audited && (added || removed)) {
-        msg.push('and ')
-      }
-
-      msg.push(`changed ${changed} package${changed === 1 ? '' : 's'}`)
-    }
-    if (audited) {
-      msg.push(', and ')
-    }
-  }
-  if (audited) {
-    msg.push(`audited ${audited} package${audited === 1 ? '' : 's'}`)
-  }
-
-  msg.push(` in ${ms(Date.now() - npm.started)}`)
-  npm.output(msg.join(''))
-}
-
-const packagesFundingMessage = (npm, { funding }) => {
-  if (!funding) {
-    return
-  }
-
-  npm.output('')
-  const pkg = funding === 1 ? 'package' : 'packages'
-  const is = funding === 1 ? 'is' : 'are'
-  npm.output(`${funding} ${pkg} ${is} looking for funding`)
-  npm.output('  run `npm fund` for details')
-}
-
-module.exports = reifyOutput

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/replace-info.js

@@ -1,31 +0,0 @@
-const { cleanUrl } = require('npm-registry-fetch')
-const isString = (v) => typeof v === 'string'
-
-// split on \s|= similar to how nopt parses options
-const splitAndReplace = (str) => {
-  // stateful regex, don't move out of this scope
-  const splitChars = /[\s=]/g
-
-  let match = null
-  let result = ''
-  let index = 0
-  while (match = splitChars.exec(str)) {
-    result += cleanUrl(str.slice(index, match.index)) + match[0]
-    index = splitChars.lastIndex
-  }
-
-  return result + cleanUrl(str.slice(index))
-}
-
-// replaces auth info in an array of arguments or in a strings
-function replaceInfo (arg) {
-  if (isString(arg)) {
-    return splitAndReplace(arg)
-  } else if (Array.isArray(arg)) {
-    return arg.map((a) => isString(a) ? splitAndReplace(a) : a)
-  }
-
-  return arg
-}
-
-module.exports = replaceInfo

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/tar.js

@@ -1,132 +0,0 @@
-const tar = require('tar')
-const ssri = require('ssri')
-const log = require('./log-shim')
-const formatBytes = require('./format-bytes.js')
-const columnify = require('columnify')
-const localeCompare = require('@isaacs/string-locale-compare')('en', {
-  sensitivity: 'case',
-  numeric: true,
-})
-
-const logTar = (tarball, opts = {}) => {
-  const { unicode = false } = opts
-  log.notice('')
-  log.notice('', `${unicode ? '📦 ' : 'package:'} ${tarball.name}@${tarball.version}`)
-  log.notice('=== Tarball Contents ===')
-  if (tarball.files.length) {
-    log.notice(
-      '',
-      columnify(
-        tarball.files
-          .map(f => {
-            const bytes = formatBytes(f.size, false)
-            return /^node_modules\//.test(f.path) ? null : { path: f.path, size: `${bytes}` }
-          })
-          .filter(f => f),
-        {
-          include: ['size', 'path'],
-          showHeaders: false,
-        }
-      )
-    )
-  }
-  if (tarball.bundled.length) {
-    log.notice('=== Bundled Dependencies ===')
-    tarball.bundled.forEach(name => log.notice('', name))
-  }
-  log.notice('=== Tarball Details ===')
-  log.notice(
-    '',
-    columnify(
-      [
-        { name: 'name:', value: tarball.name },
-        { name: 'version:', value: tarball.version },
-        tarball.filename && { name: 'filename:', value: tarball.filename },
-        { name: 'package size:', value: formatBytes(tarball.size) },
-        { name: 'unpacked size:', value: formatBytes(tarball.unpackedSize) },
-        { name: 'shasum:', value: tarball.shasum },
-        {
-          name: 'integrity:',
-          value:
-            tarball.integrity.toString().slice(0, 20) +
-            '[...]' +
-            tarball.integrity.toString().slice(80),
-        },
-        tarball.bundled.length && { name: 'bundled deps:', value: tarball.bundled.length },
-        tarball.bundled.length && {
-          name: 'bundled files:',
-          value: tarball.entryCount - tarball.files.length,
-        },
-        tarball.bundled.length && { name: 'own files:', value: tarball.files.length },
-        { name: 'total files:', value: tarball.entryCount },
-      ].filter(x => x),
-      {
-        include: ['name', 'value'],
-        showHeaders: false,
-      }
-    )
-  )
-  log.notice('', '')
-}
-
-const getContents = async (manifest, tarball) => {
-  const files = []
-  const bundled = new Set()
-  let totalEntries = 0
-  let totalEntrySize = 0
-
-  // reads contents of tarball
-  const stream = tar.t({
-    onentry (entry) {
-      totalEntries++
-      totalEntrySize += entry.size
-      const p = entry.path
-      if (p.startsWith('package/node_modules/')) {
-        const name = p.match(/^package\/node_modules\/((?:@[^/]+\/)?[^/]+)/)[1]
-        bundled.add(name)
-      }
-      files.push({
-        path: entry.path.replace(/^package\//, ''),
-        size: entry.size,
-        mode: entry.mode,
-      })
-    },
-  })
-  stream.end(tarball)
-
-  const integrity = await ssri.fromData(tarball, {
-    algorithms: ['sha1', 'sha512'],
-  })
-
-  const comparator = ({ path: a }, { path: b }) => localeCompare(a, b)
-
-  const isUpper = str => {
-    const ch = str.charAt(0)
-    return ch === ch.toUpperCase()
-  }
-
-  const uppers = files.filter(file => isUpper(file.path))
-  const others = files.filter(file => !isUpper(file.path))
-
-  uppers.sort(comparator)
-  others.sort(comparator)
-
-  const shasum = integrity.sha1[0].hexDigest()
-  return {
-    id: manifest._id || `${manifest.name}@${manifest.version}`,
-    name: manifest.name,
-    version: manifest.version,
-    size: tarball.length,
-    unpackedSize: totalEntrySize,
-    shasum,
-    integrity: ssri.parse(integrity.sha512[0]),
-    // @scope/packagename.tgz => scope-packagename.tgz
-    // we can safely use these global replace rules due to npm package naming rules
-    filename: `${manifest.name.replace('@', '').replace('/', '-')}-${manifest.version}.tgz`,
-    files: uppers.concat(others),
-    entryCount: totalEntries,
-    bundled: Array.from(bundled),
-  }
-}
-
-module.exports = { logTar, getContents }

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/timers.js

@@ -1,116 +0,0 @@
-const EE = require('events')
-const fs = require('fs')
-const log = require('./log-shim')
-
-// This is an event emiiter but on/off
-// only listen on a single internal event that gets
-// emitted whenever a timer ends
-class Timers extends EE {
-  file = null
-
-  #unfinished = new Map()
-  #finished = {}
-  #onTimeEnd = Symbol('onTimeEnd')
-  #initialListener = null
-  #initialTimer = null
-
-  constructor ({ listener = null, start = 'npm' } = {}) {
-    super()
-    this.#initialListener = listener
-    this.#initialTimer = start
-    this.#init()
-  }
-
-  get unfinished () {
-    return this.#unfinished
-  }
-
-  get finished () {
-    return this.#finished
-  }
-
-  #init () {
-    this.on()
-    if (this.#initialListener) {
-      this.on(this.#initialListener)
-    }
-    process.emit('time', this.#initialTimer)
-    this.started = this.#unfinished.get(this.#initialTimer)
-  }
-
-  on (listener) {
-    if (listener) {
-      super.on(this.#onTimeEnd, listener)
-    } else {
-      process.on('time', this.#timeListener)
-      process.on('timeEnd', this.#timeEndListener)
-    }
-  }
-
-  off (listener) {
-    if (listener) {
-      super.off(this.#onTimeEnd, listener)
-    } else {
-      this.removeAllListeners(this.#onTimeEnd)
-      process.off('time', this.#timeListener)
-      process.off('timeEnd', this.#timeEndListener)
-    }
-  }
-
-  time (name, fn) {
-    process.emit('time', name)
-    const end = () => process.emit('timeEnd', name)
-    if (typeof fn === 'function') {
-      const res = fn()
-      return res && res.finally ? res.finally(end) : (end(), res)
-    }
-    return end
-  }
-
-  load ({ path } = {}) {
-    if (path) {
-      this.file = `${path}timing.json`
-    }
-  }
-
-  writeFile (metadata) {
-    if (!this.file) {
-      return
-    }
-
-    try {
-      const globalStart = this.started
-      const globalEnd = this.#finished.npm || Date.now()
-      const content = {
-        metadata,
-        timers: this.#finished,
-        // add any unfinished timers with their relative start/end
-        unfinishedTimers: [...this.#unfinished.entries()].reduce((acc, [name, start]) => {
-          acc[name] = [start - globalStart, globalEnd - globalStart]
-          return acc
-        }, {}),
-      }
-      fs.writeFileSync(this.file, JSON.stringify(content) + '\n')
-    } catch (e) {
-      this.file = null
-      log.warn('timing', `could not write timing file: ${e}`)
-    }
-  }
-
-  #timeListener = (name) => {
-    this.#unfinished.set(name, Date.now())
-  }
-
-  #timeEndListener = (name) => {
-    if (this.#unfinished.has(name)) {
-      const ms = Date.now() - this.#unfinished.get(name)
-      this.#finished[name] = ms
-      this.#unfinished.delete(name)
-      this.emit(this.#onTimeEnd, name, ms)
-    } else {
-      log.silly('timing', "Tried to end timer that doesn't exist:", name)
-    }
-  }
-}
-
-module.exports = Timers

package/.gradle/npm/npm-v10.1.0/lib/node_modules/npm/lib/utils/update-notifier.js

@@ -1,125 +0,0 @@
-// print a banner telling the user to upgrade npm to latest
-// but not in CI, and not if we're doing that already.
-// Check daily for betas, and weekly otherwise.
-
-const ciInfo = require('ci-info')
-const semver = require('semver')
-const { stat, writeFile } = require('fs/promises')
-const { resolve } = require('path')
-
-// update check frequency
-const DAILY = 1000 * 60 * 60 * 24
-const WEEKLY = DAILY * 7
-
-// don't put it in the _cacache folder, just in npm's cache
-const lastCheckedFile = npm =>
-  resolve(npm.flatOptions.cache, '../_update-notifier-last-checked')
-
-// Actual check for updates. This is a separate function so that we only load
-// this if we are doing the actual update
-const updateCheck = async (npm, spec, version, current) => {
-  const pacote = require('pacote')
-
-  const mani = await pacote.manifest(`npm@${spec}`, {
-    // always prefer latest, even if doing --tag=whatever on the cmd
-    defaultTag: 'latest',
-    ...npm.flatOptions,
-  }).catch(() => null)
-
-  // if pacote failed, give up
-  if (!mani) {
-    return null
-  }
-
-  const latest = mani.version
-
-  // if the current version is *greater* than latest, we're on a 'next'
-  // and should get the updates from that release train.
-  // Note that this isn't another http request over the network, because
-  // the packument will be cached by pacote from previous request.
-  if (semver.gt(version, latest) && spec === 'latest') {
-    return updateNotifier(npm, `^${version}`)
-  }
-
-  // if we already have something >= the desired spec, then we're done
-  if (semver.gte(version, latest)) {
-    return null
-  }
-
-  const useColor = npm.logColor
-  const chalk = npm.logChalk
-
-  // ok!  notify the user about this update they should get.
-  // The message is saved for printing at process exit so it will not get
-  // lost in any other messages being printed as part of the command.
-  const update = semver.parse(mani.version)
-  const type = update.major !== current.major ? 'major'
-    : update.minor !== current.minor ? 'minor'
-    : update.patch !== current.patch ? 'patch'
-    : 'prerelease'
-  const typec = type === 'major' ? chalk.red(type)
-    : type === 'minor' ? chalk.yellow(type)
-    : chalk.green(type)
-  const oldc = chalk.red(current)
-  const latestc = chalk.green(latest)
-  const changelog = `https://github.com/npm/cli/releases/tag/v${latest}`
-  const changelogc = !useColor ? `<${changelog}>` : chalk.cyan(changelog)
-  const cmd = `npm install -g npm@${latest}`
-  const cmdc = !useColor ? `\`${cmd}\`` : chalk.green(cmd)
-  const message = `\nNew ${typec} version of npm available! ` +
-    `${oldc} -> ${latestc}\n` +
-    `Changelog: ${changelogc}\n` +
-    `Run ${cmdc} to update!\n`
-
-  return message
-}
-
-const updateNotifier = async (npm, spec = 'latest') => {
-  // if we're on a prerelease train, then updates are coming fast
-  // check for a new one daily.  otherwise, weekly.
-  const { version } = npm
-  const current = semver.parse(version)
-
-  // if we're on a beta train, always get the next beta
-  if (current.prerelease.length) {
-    spec = `^${version}`
-  }
-
-  // while on a beta train, get updates daily
-  const duration = spec !== 'latest' ? DAILY : WEEKLY
-
-  const t = new Date(Date.now() - duration)
-  // if we don't have a file, then definitely check it.
-  const st = await stat(lastCheckedFile(npm)).catch(() => ({ mtime: t - 1 }))
-
-  // if we've already checked within the specified duration, don't check again
-  if (!(t > st.mtime)) {
-    return null
-  }
-
-  return updateCheck(npm, spec, version, current)
-}
-
-// only update the notification timeout if we actually finished checking
-module.exports = async npm => {
-  if (
-    // opted out
-    !npm.config.get('update-notifier')
-    // global npm update
-    || (npm.flatOptions.global &&
-      ['install', 'update'].includes(npm.command) &&
-      npm.argv.some(arg => /^npm(@|$)/.test(arg)))
-    // CI
-    || ciInfo.isCI
-  ) {
-    return null
-  }
-
-  const notification = await updateNotifier(npm)
-
-  // intentional.  do not await this.  it's a best-effort update.  if this
-  // fails, it's ok.  might be using /dev/null as the cache or something weird
-  // like that.
-  writeFile(lastCheckedFile(npm), '').catch(() => {})
-  return notification
-}