@socketsecurity/cli-with-sentry 1.1.23 → 2.0.0

package/external/@socketsecurity/registry/lib/path.js

@@ -1,231 +0,0 @@
-'use strict'
-
-const { search } = /*@__PURE__*/ require('./strings')
-
-const leadingDotSlashRegExp = /^\.\.?[/\\]/
-const slashRegExp = /[/\\]/
-const nodeModulesPathRegExp = /(?:^|[/\\])node_modules(?:[/\\]|$)/
-
-let _buffer
-/**
- * Lazily load the buffer module.
- * @returns {import('buffer')} The Node.js buffer module.
- * @private
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getBuffer() {
-  if (_buffer === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _buffer = /*@__PURE__*/ require('buffer')
-  }
-  return _buffer
-}
-
-let _path
-/**
- * Lazily load the path module.
- * @returns {import('path')} The Node.js path module.
- * @private
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getPath() {
-  if (_path === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _path = /*@__PURE__*/ require('path')
-  }
-  return _path
-}
-
-let _url
-/**
- * Lazily load the url module.
- * @returns {import('url')} The Node.js url module.
- * @private
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getUrl() {
-  if (_url === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _url = /*@__PURE__*/ require('url')
-  }
-  return _url
-}
-
-/**
- * Check if a path contains node_modules directory.
- * @param {string | Buffer | URL} pathLike - The path to check.
- * @returns {boolean} True if the path contains node_modules.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function isNodeModules(pathLike) {
-  const filepath = pathLikeToString(pathLike)
-  return nodeModulesPathRegExp.test(filepath)
-}
-
-/**
- * Check if a value is a valid file path (absolute or relative).
- * @param {any} pathLike - The value to check.
- * @returns {boolean} True if the value is a valid path.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function isPath(pathLike) {
-  return isRelative(pathLike) || getPath().isAbsolute(pathLike)
-}
-
-/**
- * Check if a path is relative (starts with . or ..).
- * @param {any} pathLike - The path to check.
- * @returns {boolean} True if the path is relative.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function isRelative(pathLike) {
-  const filepath = pathLikeToString(pathLike)
-  if (typeof filepath !== 'string') {
-    return false
-  }
-  const { length } = filepath
-  if (length === 0) {
-    return false
-  }
-  if (filepath.charCodeAt(0) === 46 /*'.'*/) {
-    if (length === 1) {
-      return true
-    }
-    let code = filepath.charCodeAt(1)
-    if (code === 46 /*'.'*/) {
-      code = filepath.charCodeAt(2)
-    }
-    return code === 47 /*'/'*/ || code === 92 /*'\\'*/
-  }
-  return false
-}
-
-/**
- * Normalize a path by converting backslashes to forward slashes and collapsing segments.
- * @param {string | Buffer | URL} pathLike - The path to normalize.
- * @returns {string} The normalized path.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function normalizePath(pathLike) {
-  const filepath = pathLikeToString(pathLike)
-  const { length } = filepath
-  if (length < 2) {
-    return length === 1 && filepath.charCodeAt(0) === 92 /*'\\'*/
-      ? '/'
-      : filepath
-  }
-
-  let code = 0
-  let collapsed = ''
-  let start = 0
-
-  // Ensure win32 namespaces have two leading slashes so they are handled properly
-  // by path.win32.parse() after being normalized.
-  // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#namespaces
-  // UNC paths, paths starting with double slashes, e.g. "\\\\wsl.localhost\\Ubuntu\home\\",
-  // are okay to convert to forward slashes.
-  // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
-  let prefix = ''
-  if (length > 4 && filepath.charCodeAt(3) === 92 /*'\\'*/) {
-    const code2 = filepath.charCodeAt(2)
-    // Look for \\?\ or \\.\
-    if (
-      (code2 === 63 /*'?'*/ || code2 === 46) /*'.'*/ &&
-      filepath.charCodeAt(0) === 92 /*'\\'*/ &&
-      filepath.charCodeAt(1) === 92 /*'\\'*/
-    ) {
-      start = 2
-      prefix = '//'
-    }
-  }
-  if (start === 0) {
-    // Trim leading slashes
-    while (
-      ((code = filepath.charCodeAt(start)),
-      code === 47 /*'/'*/ || code === 92) /*'\\'*/
-    ) {
-      start += 1
-    }
-    if (start) {
-      prefix = '/'
-    }
-  }
-  let nextIndex = search(filepath, slashRegExp, start)
-  if (nextIndex === -1) {
-    return prefix + filepath.slice(start)
-  }
-  // Discard any empty string segments by collapsing repeated segment separator slashes.
-  while (nextIndex !== -1) {
-    const segment = filepath.slice(start, nextIndex)
-    collapsed = collapsed + (collapsed.length === 0 ? '' : '/') + segment
-    start = nextIndex + 1
-    while (
-      ((code = filepath.charCodeAt(start)),
-      code === 47 /*'/'*/ || code === 92) /*'\\'*/
-    ) {
-      start += 1
-    }
-    nextIndex = search(filepath, slashRegExp, start)
-  }
-  const lastSegment = filepath.slice(start)
-  if (lastSegment.length !== 0) {
-    collapsed = collapsed + '/' + lastSegment
-  }
-  return prefix + collapsed
-}
-
-/**
- * Convert a path-like value to a string.
- * @param {string | Buffer | URL | any} pathLike - The path-like value to convert.
- * @returns {string} The path as a string.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function pathLikeToString(pathLike) {
-  if (typeof pathLike === 'string') {
-    return pathLike
-  }
-  const { Buffer } = getBuffer()
-  if (Buffer.isBuffer(pathLike)) {
-    return pathLike.toString('utf8')
-  }
-  const url = getUrl()
-  if (pathLike instanceof URL) {
-    return url.fileURLToPath(pathLike)
-  }
-  return String(pathLike)
-}
-
-/**
- * Split a path into an array of segments.
- * @param {string | Buffer | URL} pathLike - The path to split.
- * @returns {string[]} Array of path segments.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function splitPath(pathLike) {
-  const filepath = pathLikeToString(pathLike)
-  return filepath.split(slashRegExp)
-}
-
-/**
- * Remove leading ./ or ../ from a path.
- * @param {string | Buffer | URL} pathLike - The path to trim.
- * @returns {string} The path without leading dot-slash.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function trimLeadingDotSlash(pathLike) {
-  const filepath = pathLikeToString(pathLike)
-  return filepath.replace(leadingDotSlashRegExp, '')
-}
-
-module.exports = {
-  isNodeModules,
-  isPath,
-  isRelative,
-  normalizePath,
-  pathLikeToString,
-  splitPath,
-  trimLeadingDotSlash
-}

package/external/@socketsecurity/registry/lib/promises.js

@@ -1,286 +0,0 @@
-'use strict'
-
-const { arrayChunk } = /*@__PURE__*/ require('./arrays')
-
-let _timers
-/**
- * Get the timers/promises module.
- * @returns {Object} The timers/promises module.
- * @private
- */
-/*@__NO_SIDE_EFFECTS__*/
-function getTimers() {
-  if (_timers === undefined) {
-    // Use non-'node:' prefixed require to avoid Webpack errors.
-    // eslint-disable-next-line n/prefer-node-protocol
-    _timers = /*@__PURE__*/ require('timers/promises')
-  }
-  return _timers
-}
-
-/**
- * Normalize options for iteration functions.
- * @param {Object} [options] - Iteration options.
- * @returns {Object} Normalized iteration options.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function normalizeIterationOptions(options) {
-  const {
-    // The number of concurrent executions performed at one time.
-    concurrency = 1,
-    // Retries as a number or options object.
-    retries,
-    // AbortSignal used to support cancellation.
-    signal = /*@__PURE__*/ require('./constants/abort-signal')
-  } = { __proto__: null, ...options }
-  const retryOpts = resolveRetryOptions(retries)
-  return {
-    __proto__: null,
-    concurrency,
-    retries: normalizeRetryOptions({ signal, ...retryOpts }),
-    signal
-  }
-}
-
-/**
- * Normalize options for retry functionality.
- * @param {Object|number} [options] - Retry options or number of retries.
- * @returns {Object} Normalized retry options.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function normalizeRetryOptions(options) {
-  const {
-    // Arguments to pass to the callback function.
-    args = [],
-    // Multiplier for exponential backoff (e.g., 2 doubles delay each retry).
-    backoffFactor = 2,
-    // Initial delay before the first retry (in milliseconds).
-    baseDelayMs = 200,
-    // Whether to apply randomness to spread out retries.
-    jitter = true,
-    // Upper limit for any backoff delay (in milliseconds).
-    maxDelayMs = 10000,
-    // Optional callback invoked on each retry attempt:
-    // (attempt: number, error: unknown, delay: number) => void
-    onRetry,
-    // Whether onRetry can cancel retries by returning `false`.
-    onRetryCancelOnFalse = false,
-    // Whether onRetry will rethrow errors.
-    onRetryRethrow = false,
-    // Number of retry attempts (0 = no retries, only initial attempt).
-    retries = 0,
-    // AbortSignal used to support cancellation.
-    signal = /*@__PURE__*/ require('./constants/abort-signal')
-  } = resolveRetryOptions(options)
-  return {
-    __proto__: null,
-    args,
-    backoffFactor,
-    baseDelayMs,
-    jitter,
-    maxDelayMs,
-    onRetry,
-    onRetryCancelOnFalse,
-    onRetryRethrow,
-    retries,
-    signal
-  }
-}
-
-/**
- * Resolve retry options from various input formats.
- * @param {Object|number} [options] - Options object or number of retries.
- * @returns {Object} Resolved retry options object.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function resolveRetryOptions(options) {
-  return {
-    __proto__: null,
-    ...(typeof options === 'number' ? { retries: options } : options)
-  }
-}
-
-/**
- * Execute an async function for each array element with concurrency control.
- * @param {any[]} array - Array to iterate over.
- * @param {Function} callbackFn - Async function to execute for each element.
- * @param {Object} [options] - Iteration options including concurrency and retries.
- * @returns {Promise<void>} Resolves when all iterations complete.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function pEach(array, callbackFn, options) {
-  const iterOpts = normalizeIterationOptions(options)
-  await pEachChunk(
-    arrayChunk(array, iterOpts.concurrency),
-    callbackFn,
-    iterOpts.retries
-  )
-}
-
-/**
- * Filter an array asynchronously with concurrency control.
- * @param {any[]} array - Array to filter.
- * @param {Function} callbackFn - Async predicate function.
- * @param {Object} [options] - Iteration options including concurrency and retries.
- * @returns {Promise<any[]>} Filtered array.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function pFilter(array, callbackFn, options) {
-  const iterOpts = normalizeIterationOptions(options)
-  return (
-    await pFilterChunk(
-      arrayChunk(array, iterOpts.concurrency),
-      callbackFn,
-      iterOpts.retries
-    )
-  ).flat()
-}
-
-/**
- * Process chunked arrays with an async callback.
- * @param {any[][]} chunks - Array of array chunks.
- * @param {Function} callbackFn - Async function to execute for each element.
- * @param {Object} [options] - Retry options.
- * @returns {Promise<void>} Resolves when all chunks are processed.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function pEachChunk(chunks, callbackFn, options) {
-  const retryOpts = normalizeRetryOptions(options)
-  const { signal } = retryOpts
-  for (const chunk of chunks) {
-    if (signal?.aborted) {
-      return
-    }
-    // eslint-disable-next-line no-await-in-loop
-    await Promise.all(
-      chunk.map(value =>
-        pRetry(callbackFn, {
-          ...retryOpts,
-          args: [value]
-        })
-      )
-    )
-  }
-}
-
-/**
- * Filter chunked arrays with an async predicate.
- * @param {any[][]} chunks - Array of array chunks.
- * @param {Function} callbackFn - Async predicate function.
- * @param {Object} [options] - Retry options.
- * @returns {Promise<any[][]>} Filtered chunks.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function pFilterChunk(chunks, callbackFn, options) {
-  const retryOpts = normalizeRetryOptions(options)
-  const { signal } = retryOpts
-  const { length } = chunks
-  const filteredChunks = Array(length)
-  for (let i = 0; i < length; i += 1) {
-    // Process each chunk, filtering based on the callback function.
-    if (signal?.aborted) {
-      filteredChunks[i] = []
-    } else {
-      const chunk = chunks[i]
-      // eslint-disable-next-line no-await-in-loop
-      const predicateResults = await Promise.all(
-        chunk.map(value =>
-          pRetry(callbackFn, {
-            ...retryOpts,
-            args: [value]
-          })
-        )
-      )
-      filteredChunks[i] = chunk.filter((_v, i) => predicateResults[i])
-    }
-  }
-  return filteredChunks
-}
-
-/**
- * Retry an async function with exponential backoff.
- * @param {Function} callbackFn - Async function to retry.
- * @param {Object} [options] - Retry options including retries, backoff, and delays.
- * @returns {Promise<any>} Result of the successful function call.
- * @throws {Error} The last error if all retries fail.
- */
-/*@__NO_SIDE_EFFECTS__*/
-async function pRetry(callbackFn, options) {
-  const {
-    args,
-    backoffFactor,
-    baseDelayMs,
-    jitter,
-    maxDelayMs,
-    onRetry,
-    onRetryCancelOnFalse,
-    onRetryRethrow,
-    retries,
-    signal
-  } = normalizeRetryOptions(options)
-  if (signal?.aborted) {
-    return undefined
-  }
-  if (retries === 0) {
-    return await callbackFn(...args, { signal })
-  }
-
-  const UNDEFINED_TOKEN = /*@__PURE__*/ require('./constants/undefined-token')
-  const timers = getTimers()
-
-  let attempts = retries
-  let delay = baseDelayMs
-  let error = UNDEFINED_TOKEN
-
-  while (attempts-- >= 0 && !signal?.aborted) {
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      return await callbackFn(...args, { signal })
-    } catch (e) {
-      if (error === UNDEFINED_TOKEN) {
-        error = e
-      }
-      if (attempts < 0) {
-        break
-      }
-      let waitTime = delay
-      if (jitter) {
-        // Add randomness: Pick a value between 0 and `delay`.
-        waitTime += Math.floor(Math.random() * delay)
-      }
-      // Clamp wait time to max delay.
-      waitTime = Math.min(waitTime, maxDelayMs)
-      if (typeof onRetry === 'function') {
-        try {
-          const result = onRetry(retries - attempts, e, waitTime)
-          if (result === false && onRetryCancelOnFalse) {
-            break
-          }
-        } catch (e) {
-          if (onRetryRethrow) {
-            throw e
-          }
-        }
-      }
-      // eslint-disable-next-line no-await-in-loop
-      await timers.setTimeout(waitTime, undefined, { signal })
-      // Exponentially increase the delay for the next attempt, capping at maxDelayMs.
-      delay = Math.min(delay * backoffFactor, maxDelayMs)
-    }
-  }
-  if (error !== UNDEFINED_TOKEN) {
-    throw error
-  }
-  return undefined
-}
-
-module.exports = {
-  normalizeIterationOptions,
-  normalizeRetryOptions,
-  pEach,
-  pEachChunk,
-  pFilter,
-  pFilterChunk,
-  pRetry,
-  resolveRetryOptions
-}

package/external/@socketsecurity/registry/lib/prompts.js

@@ -1,63 +0,0 @@
-'use strict'
-
-/*@__NO_SIDE_EFFECTS__*/
-function wrapPrompt(inquirerPrompt) {
-  return async (...args) => {
-    const origContext = args.length > 1 ? args[1] : undefined
-    const {
-      spinner = /*@__PURE__*/ require('./constants/spinner'),
-      ...contextWithoutSpinner
-    } = origContext ?? {}
-    const abortSignal = /*@__PURE__*/ require('./constants/abort-signal')
-    if (origContext) {
-      args[1] = {
-        signal: abortSignal,
-        ...contextWithoutSpinner
-      }
-    } else {
-      args[1] = { signal: abortSignal }
-    }
-    const wasSpinning = !!spinner?.isSpinning
-    spinner?.stop()
-    let result
-    try {
-      result = await inquirerPrompt(...args)
-    } catch (e) {
-      if (e instanceof TypeError) {
-        throw e
-      }
-    }
-    if (wasSpinning) {
-      spinner.start()
-    }
-    return typeof result === 'string' ? result.trim() : result
-  }
-}
-
-const selectExport = /*@__PURE__*/ require('../external/@inquirer/select')
-const selectRaw = selectExport.default
-const Separator = selectExport.Separator
-
-const confirmRaw = /*@__PURE__*/ require('../external/@inquirer/confirm')
-const confirm = /*@__PURE__*/ wrapPrompt(confirmRaw)
-
-const inputRaw = /*@__PURE__*/ require('../external/@inquirer/input')
-const input = /*@__PURE__*/ wrapPrompt(inputRaw)
-
-const passwordRaw = /*@__PURE__*/ require('../external/@inquirer/password')
-const password = /*@__PURE__*/ wrapPrompt(passwordRaw)
-
-const searchExport = /*@__PURE__*/ require('../external/@inquirer/search')
-const searchRaw = searchExport.default
-
-const search = /*@__PURE__*/ wrapPrompt(searchRaw)
-const select = /*@__PURE__*/ wrapPrompt(selectRaw)
-
-module.exports = {
-  Separator,
-  confirm,
-  input,
-  password,
-  search,
-  select
-}

package/external/@socketsecurity/registry/lib/regexps.js

@@ -1,23 +0,0 @@
-'use strict'
-
-// Inlined escape-string-regexp:
-// https://socket.dev/npm/package/escape-string-regexp/overview/5.0.0
-// MIT License
-// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
-
-/**
- * Escape special characters in a string for use in a regular expression.
- * @param {string} str - The string to escape.
- * @returns {string} The escaped string safe for use in a RegExp.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function escapeRegExp(str) {
-  // Escape characters with special meaning either inside or outside character sets.
-  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when
-  // the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-  return str.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d')
-}
-
-module.exports = {
-  escapeRegExp
-}

package/external/@socketsecurity/registry/lib/sorts.js

@@ -1,70 +0,0 @@
-'use strict'
-
-let _localeCompare
-/**
- * Compare two strings using locale-aware comparison.
- * @param {string} x - First string to compare.
- * @param {string} y - Second string to compare.
- * @returns {number} Negative if x < y, positive if x > y, 0 if equal.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function localeCompare(x, y) {
-  if (_localeCompare === undefined) {
-    // Lazily call new Intl.Collator() because in Node it can take 10-14ms.
-    _localeCompare = new Intl.Collator().compare
-  }
-  return _localeCompare(x, y)
-}
-
-let _naturalCompare
-/**
- * Compare two strings using natural sorting (numeric-aware, case-insensitive).
- * @param {string} x - First string to compare.
- * @param {string} y - Second string to compare.
- * @returns {number} Negative if x < y, positive if x > y, 0 if equal.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function naturalCompare(x, y) {
-  if (_naturalCompare === undefined) {
-    // Lazily call new Intl.Collator() because in Node it can take 10-14ms.
-    _naturalCompare = new Intl.Collator(
-      // The `undefined` locale means it uses the default locale of the user's
-      // environment.
-      undefined,
-      {
-        // Enables numeric sorting: numbers in strings are compared by value,
-        // e.g. 'file2' comes before 'file10' as numbers and not 'file10' before
-        // 'file2' as plain text.
-        numeric: true,
-        // Makes the comparison case-insensitive and ignores diacritics, e.g.
-        // 'a', 'A', and 'á' are treated as equivalent.
-        sensitivity: 'base'
-      }
-    ).compare
-  }
-  return _naturalCompare(x, y)
-}
-
-let _naturalSorter
-/**
- * Sort an array using natural comparison.
- * @param {any[]} arrayToSort - The array to sort.
- * @returns {any} The fast-sort instance with natural comparison.
- */
-/*@__NO_SIDE_EFFECTS__*/
-function naturalSorter(arrayToSort) {
-  if (_naturalSorter === undefined) {
-    // The 'fast-sort' package is browser safe.
-    const fastSort = /*@__PURE__*/ require('../external/fast-sort')
-    _naturalSorter = fastSort.createNewSortInstance({
-      comparer: naturalCompare
-    })
-  }
-  return _naturalSorter(arrayToSort)
-}
-
-module.exports = {
-  localeCompare,
-  naturalCompare,
-  naturalSorter
-}