@pnpm/exe 11.0.6 → 11.0.7

package/dist/node_modules/@npmcli/fs/lib/move-file.js

@@ -1,78 +0,0 @@
-const { dirname, join, resolve, relative, isAbsolute } = require('path')
-const fs = require('fs/promises')
-
-const pathExists = async path => {
-  try {
-    await fs.access(path)
-    return true
-  } catch (er) {
-    return er.code !== 'ENOENT'
-  }
-}
-
-const moveFile = async (source, destination, options = {}, root = true, symlinks = []) => {
-  if (!source || !destination) {
-    throw new TypeError('`source` and `destination` file required')
-  }
-
-  options = {
-    overwrite: true,
-    ...options,
-  }
-
-  if (!options.overwrite && await pathExists(destination)) {
-    throw new Error(`The destination file exists: ${destination}`)
-  }
-
-  await fs.mkdir(dirname(destination), { recursive: true })
-
-  try {
-    await fs.rename(source, destination)
-  } catch (error) {
-    if (error.code === 'EXDEV' || error.code === 'EPERM') {
-      const sourceStat = await fs.lstat(source)
-      if (sourceStat.isDirectory()) {
-        const files = await fs.readdir(source)
-        await Promise.all(files.map((file) =>
-          moveFile(join(source, file), join(destination, file), options, false, symlinks)
-        ))
-      } else if (sourceStat.isSymbolicLink()) {
-        symlinks.push({ source, destination })
-      } else {
-        await fs.copyFile(source, destination)
-      }
-    } else {
-      throw error
-    }
-  }
-
-  if (root) {
-    await Promise.all(symlinks.map(async ({ source: symSource, destination: symDestination }) => {
-      let target = await fs.readlink(symSource)
-      // junction symlinks in windows will be absolute paths, so we need to
-      // make sure they point to the symlink destination
-      if (isAbsolute(target)) {
-        target = resolve(symDestination, relative(symSource, target))
-      }
-      // try to determine what the actual file is so we can create the correct
-      // type of symlink in windows
-      let targetStat = 'file'
-      try {
-        targetStat = await fs.stat(resolve(dirname(symSource), target))
-        if (targetStat.isDirectory()) {
-          targetStat = 'junction'
-        }
-      } catch {
-        // targetStat remains 'file'
-      }
-      await fs.symlink(
-        target,
-        symDestination,
-        targetStat
-      )
-    }))
-    await fs.rm(source, { recursive: true, force: true })
-  }
-}
-
-module.exports = moveFile

package/dist/node_modules/@npmcli/fs/lib/readdir-scoped.js

@@ -1,20 +0,0 @@
-const { readdir } = require('fs/promises')
-const { join } = require('path')
-
-const readdirScoped = async (dir) => {
-  const results = []
-
-  for (const item of await readdir(dir)) {
-    if (item.startsWith('@')) {
-      for (const scopedItem of await readdir(join(dir, item))) {
-        results.push(join(item, scopedItem))
-      }
-    } else {
-      results.push(item)
-    }
-  }
-
-  return results
-}
-
-module.exports = readdirScoped

package/dist/node_modules/@npmcli/fs/lib/with-temp-dir.js

@@ -1,39 +0,0 @@
-const { join, sep } = require('path')
-
-const getOptions = require('./common/get-options.js')
-const { mkdir, mkdtemp, rm } = require('fs/promises')
-
-// create a temp directory, ensure its permissions match its parent, then call
-// the supplied function passing it the path to the directory. clean up after
-// the function finishes, whether it throws or not
-const withTempDir = async (root, fn, opts) => {
-  const options = getOptions(opts, {
-    copy: ['tmpPrefix'],
-  })
-  // create the directory
-  await mkdir(root, { recursive: true })
-
-  const target = await mkdtemp(join(`${root}${sep}`, options.tmpPrefix || ''))
-  let err
-  let result
-
-  try {
-    result = await fn(target)
-  } catch (_err) {
-    err = _err
-  }
-
-  try {
-    await rm(target, { force: true, recursive: true })
-  } catch {
-    // ignore errors
-  }
-
-  if (err) {
-    throw err
-  }
-
-  return result
-}
-
-module.exports = withTempDir

package/dist/node_modules/@npmcli/fs/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "@npmcli/fs",
-  "version": "5.0.0",
-  "description": "filesystem utilities for the npm cli",
-  "main": "lib/index.js",
-  "files": [
-    "bin/",
-    "lib/"
-  ],
-  "scripts": {
-    "snap": "tap",
-    "test": "tap",
-    "npmclilint": "npmcli-lint",
-    "lint": "npm run eslint",
-    "lintfix": "npm run eslint -- --fix",
-    "posttest": "npm run lint",
-    "postsnap": "npm run lintfix --",
-    "postlint": "template-oss-check",
-    "template-oss-apply": "template-oss-apply --force",
-    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/npm/fs.git"
-  },
-  "keywords": [
-    "npm",
-    "oss"
-  ],
-  "author": "GitHub Inc.",
-  "license": "ISC",
-  "devDependencies": {
-    "@npmcli/eslint-config": "^5.0.0",
-    "@npmcli/template-oss": "4.27.1",
-    "tap": "^16.0.1"
-  },
-  "dependencies": {
-    "semver": "^7.3.5"
-  },
-  "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.27.1",
-    "publish": true
-  },
-  "tap": {
-    "nyc-arg": [
-      "--exclude",
-      "tap-snapshots/**"
-    ]
-  }
-}

package/dist/node_modules/@npmcli/redact/lib/deep-map.js

@@ -1,71 +0,0 @@
-const { serializeError } = require('./error')
-
-const deepMap = (input, handler = v => v, path = ['$'], seen = new Set([input])) => {
-  // this is in an effort to maintain bole's error logging behavior
-  if (path.join('.') === '$' && input instanceof Error) {
-    return deepMap({ err: serializeError(input) }, handler, path, seen)
-  }
-  if (input instanceof Error) {
-    return deepMap(serializeError(input), handler, path, seen)
-  }
-  // allows for non-node js environments, sush as workers
-  if (typeof Buffer !== 'undefined' && input instanceof Buffer) {
-    return `[unable to log instanceof buffer]`
-  }
-  if (input instanceof Uint8Array) {
-    return `[unable to log instanceof Uint8Array]`
-  }
-
-  if (Array.isArray(input)) {
-    const result = []
-    for (let i = 0; i < input.length; i++) {
-      const element = input[i]
-      const elementPath = [...path, i]
-      if (element instanceof Object) {
-        if (!seen.has(element)) { // avoid getting stuck in circular reference
-          seen.add(element)
-          result.push(deepMap(handler(element, elementPath), handler, elementPath, seen))
-        }
-      } else {
-        result.push(handler(element, elementPath))
-      }
-    }
-    return result
-  }
-
-  if (input === null) {
-    return null
-  } else if (typeof input === 'object' || typeof input === 'function') {
-    const result = {}
-
-    for (const propertyName of Object.getOwnPropertyNames(input)) {
-    // skip logging internal properties
-      if (propertyName.startsWith('_')) {
-        continue
-      }
-
-      try {
-        const property = input[propertyName]
-        const propertyPath = [...path, propertyName]
-        if (property instanceof Object) {
-          if (!seen.has(property)) { // avoid getting stuck in circular reference
-            seen.add(property)
-            result[propertyName] = deepMap(
-              handler(property, propertyPath), handler, propertyPath, seen
-            )
-          }
-        } else {
-          result[propertyName] = handler(property, propertyPath)
-        }
-      } catch (err) {
-      // a getter may throw an error
-        result[propertyName] = `[error getting value: ${err.message}]`
-      }
-    }
-    return result
-  }
-
-  return handler(input, path)
-}
-
-module.exports = { deepMap }

package/dist/node_modules/@npmcli/redact/lib/error.js

@@ -1,28 +0,0 @@
-/** takes an error object and serializes it to a plan object */
-function serializeError (input) {
-  if (!(input instanceof Error)) {
-    if (typeof input === 'string') {
-      const error = new Error(`attempted to serialize a non-error, string String, "${input}"`)
-      return serializeError(error)
-    }
-    const error = new Error(`attempted to serialize a non-error, ${typeof input} ${input?.constructor?.name}`)
-    return serializeError(error)
-  }
-  // different error objects store status code differently
-  // AxiosError uses `status`, other services use `statusCode`
-  const statusCode = input.statusCode ?? input.status
-  // CAUTION: what we serialize here gets add to the size of logs
-  return {
-    errorType: input.errorType ?? input.constructor.name,
-    ...(input.message ? { message: input.message } : {}),
-    ...(input.stack ? { stack: input.stack } : {}),
-    // think of this as error code
-    ...(input.code ? { code: input.code } : {}),
-    // think of this as http status code
-    ...(statusCode ? { statusCode } : {}),
-  }
-}
-
-module.exports = {
-  serializeError,
-}

package/dist/node_modules/@npmcli/redact/lib/index.js

@@ -1,44 +0,0 @@
-const matchers = require('./matchers')
-const { redactUrlPassword } = require('./utils')
-
-const REPLACE = '***'
-
-const redact = (value) => {
-  if (typeof value !== 'string' || !value) {
-    return value
-  }
-  return redactUrlPassword(value, REPLACE)
-    .replace(matchers.NPM_SECRET.pattern, `npm_${REPLACE}`)
-    .replace(matchers.UUID.pattern, REPLACE)
-}
-
-// split on \s|= similar to how nopt parses options
-const splitAndRedact = (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 += redact(str.slice(index, match.index)) + match[0]
-    index = splitChars.lastIndex
-  }
-
-  return result + redact(str.slice(index))
-}
-
-// replaces auth info in an array of arguments or in a strings
-const redactLog = (arg) => {
-  if (typeof arg === 'string') {
-    return splitAndRedact(arg)
-  } else if (Array.isArray(arg)) {
-    return arg.map((a) => typeof a === 'string' ? splitAndRedact(a) : a)
-  }
-  return arg
-}
-
-module.exports = {
-  redact,
-  redactLog,
-}

package/dist/node_modules/@npmcli/redact/lib/matchers.js

@@ -1,88 +0,0 @@
-const TYPE_REGEX = 'regex'
-const TYPE_URL = 'url'
-const TYPE_PATH = 'path'
-
-const NPM_SECRET = {
-  type: TYPE_REGEX,
-  pattern: /\b(npms?_)[a-zA-Z0-9]{36,48}\b/gi,
-  replacement: `[REDACTED_NPM_SECRET]`,
-}
-
-const AUTH_HEADER = {
-  type: TYPE_REGEX,
-  pattern: /\b(Basic\s+|Bearer\s+)[\w+=\-.]+\b/gi,
-  replacement: `[REDACTED_AUTH_HEADER]`,
-}
-
-const JSON_WEB_TOKEN = {
-  type: TYPE_REGEX,
-  pattern: /\b[A-Za-z0-9-_]{10,}(?!\.\d+\.)\.[A-Za-z0-9-_]{3,}\.[A-Za-z0-9-_]{20,}\b/gi,
-  replacement: `[REDACTED_JSON_WEB_TOKEN]`,
-}
-
-const UUID = {
-  type: TYPE_REGEX,
-  pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi,
-  replacement: `[REDACTED_UUID]`,
-}
-
-const URL_MATCHER = {
-  type: TYPE_REGEX,
-  pattern: /(?:https?|ftp):\/\/[^\s/"$.?#].[^\s"]*/gi,
-  replacement: '[REDACTED_URL]',
-}
-
-const DEEP_HEADER_AUTHORIZATION = {
-  type: TYPE_PATH,
-  predicate: ({ path }) => path.endsWith('.headers.authorization'),
-  replacement: '[REDACTED_HEADER_AUTHORIZATION]',
-}
-
-const DEEP_HEADER_SET_COOKIE = {
-  type: TYPE_PATH,
-  predicate: ({ path }) => path.endsWith('.headers.set-cookie'),
-  replacement: '[REDACTED_HEADER_SET_COOKIE]',
-}
-
-const DEEP_HEADER_COOKIE = {
-  type: TYPE_PATH,
-  predicate: ({ path }) => path.endsWith('.headers.cookie'),
-  replacement: '[REDACTED_HEADER_COOKIE]',
-}
-
-const REWRITE_REQUEST = {
-  type: TYPE_PATH,
-  predicate: ({ path }) => path.endsWith('.request'),
-  replacement: (input) => ({
-    method: input?.method,
-    path: input?.path,
-    headers: input?.headers,
-    url: input?.url,
-  }),
-}
-
-const REWRITE_RESPONSE = {
-  type: TYPE_PATH,
-  predicate: ({ path }) => path.endsWith('.response'),
-  replacement: (input) => ({
-    data: input?.data,
-    status: input?.status,
-    headers: input?.headers,
-  }),
-}
-
-module.exports = {
-  TYPE_REGEX,
-  TYPE_URL,
-  TYPE_PATH,
-  NPM_SECRET,
-  AUTH_HEADER,
-  JSON_WEB_TOKEN,
-  UUID,
-  URL_MATCHER,
-  DEEP_HEADER_AUTHORIZATION,
-  DEEP_HEADER_SET_COOKIE,
-  DEEP_HEADER_COOKIE,
-  REWRITE_REQUEST,
-  REWRITE_RESPONSE,
-}

package/dist/node_modules/@npmcli/redact/lib/server.js

@@ -1,59 +0,0 @@
-const {
-  AUTH_HEADER,
-  JSON_WEB_TOKEN,
-  NPM_SECRET,
-  DEEP_HEADER_AUTHORIZATION,
-  DEEP_HEADER_SET_COOKIE,
-  REWRITE_REQUEST,
-  REWRITE_RESPONSE,
-  DEEP_HEADER_COOKIE,
-} = require('./matchers')
-
-const {
-  redactUrlMatcher,
-  redactUrlPasswordMatcher,
-  redactMatchers,
-} = require('./utils')
-
-const { serializeError } = require('./error')
-
-const { deepMap } = require('./deep-map')
-
-const _redact = redactMatchers(
-  NPM_SECRET,
-  AUTH_HEADER,
-  JSON_WEB_TOKEN,
-  DEEP_HEADER_AUTHORIZATION,
-  DEEP_HEADER_SET_COOKIE,
-  DEEP_HEADER_COOKIE,
-  REWRITE_REQUEST,
-  REWRITE_RESPONSE,
-  redactUrlMatcher(
-    redactUrlPasswordMatcher()
-  )
-)
-
-const redact = (input) => deepMap(input, (value, path) => _redact(value, { path }))
-
-/** takes an error returns new error keeping some custom properties */
-function redactError (input) {
-  const { message, ...data } = serializeError(input)
-  const output = new Error(redact(message))
-  return Object.assign(output, redact(data))
-}
-
-/** runs a function within try / catch and throws error wrapped in redactError */
-function redactThrow (func) {
-  if (typeof func !== 'function') {
-    throw new Error('redactThrow expects a function')
-  }
-  return async (...args) => {
-    try {
-      return await func(...args)
-    } catch (error) {
-      throw redactError(error)
-    }
-  }
-}
-
-module.exports = { redact, redactError, redactThrow }

package/dist/node_modules/@npmcli/redact/lib/utils.js

@@ -1,202 +0,0 @@
-const {
-  URL_MATCHER,
-  TYPE_URL,
-  TYPE_REGEX,
-  TYPE_PATH,
-} = require('./matchers')
-
-/**
- * creates a string of asterisks,
- * this forces a minimum asterisk for security purposes
- */
-const asterisk = (length = 0) => {
-  length = typeof length === 'string' ? length.length : length
-  if (length < 8) {
-    return '*'.repeat(8)
-  }
-  return '*'.repeat(length)
-}
-
-/**
- * escapes all special regex chars
- * @see https://stackoverflow.com/a/9310752
- * @see https://github.com/tc39/proposal-regex-escaping
- */
-const escapeRegExp = (text) => {
-  return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, `\\$&`)
-}
-
-/**
- * provieds a regex "or" of the url versions of a string
- */
-const urlEncodeRegexGroup = (value) => {
-  const decoded = decodeURIComponent(value)
-  const encoded = encodeURIComponent(value)
-  const union = [...new Set([encoded, decoded, value])].map(escapeRegExp).join('|')
-  return union
-}
-
-/**
- * a tagged template literal that returns a regex ensures all variables are excaped
- */
-const urlEncodeRegexTag = (strings, ...values) => {
-  let pattern = ''
-  for (let i = 0; i < values.length; i++) {
-    pattern += strings[i] + `(${urlEncodeRegexGroup(values[i])})`
-  }
-  pattern += strings[strings.length - 1]
-  return new RegExp(pattern)
-}
-
-/**
- * creates a matcher for redacting url hostname
- */
-const redactUrlHostnameMatcher = ({ hostname, replacement } = {}) => ({
-  type: TYPE_URL,
-  predicate: ({ url }) => url.hostname === hostname,
-  pattern: ({ url }) => {
-    return urlEncodeRegexTag`(^${url.protocol}//${url.username}:.+@)?${url.hostname}`
-  },
-  replacement: `$1${replacement || asterisk()}`,
-})
-
-/**
- * creates a matcher for redacting url search / query parameter values
- */
-const redactUrlSearchParamsMatcher = ({ param, replacement } = {}) => ({
-  type: TYPE_URL,
-  predicate: ({ url }) => url.searchParams.has(param),
-  pattern: ({ url }) => urlEncodeRegexTag`(${param}=)${url.searchParams.get(param)}`,
-  replacement: `$1${replacement || asterisk()}`,
-})
-
-/** creates a matcher for redacting the url password */
-const redactUrlPasswordMatcher = ({ replacement } = {}) => ({
-  type: TYPE_URL,
-  predicate: ({ url }) => url.password,
-  pattern: ({ url }) => urlEncodeRegexTag`(^${url.protocol}//${url.username}:)${url.password}`,
-  replacement: `$1${replacement || asterisk()}`,
-})
-
-const redactUrlReplacement = (...matchers) => (subValue) => {
-  try {
-    const url = new URL(subValue)
-    return redactMatchers(...matchers)(subValue, { url })
-  } catch (err) {
-    return subValue
-  }
-}
-
-/**
- * creates a matcher / submatcher for urls, this function allows you to first
- * collect all urls within a larger string and then pass those urls to a
- * submatcher
- *
- * @example
- * console.log("this will first match all urls, then pass those urls to the password patcher")
- * redactMatchers(redactUrlMatcher(redactUrlPasswordMatcher()))
- *
- * @example
- * console.log(
- *   "this will assume you are passing in a string that is a url, and will redact the password"
- * )
- * redactMatchers(redactUrlPasswordMatcher())
- *
- */
-const redactUrlMatcher = (...matchers) => {
-  return {
-    ...URL_MATCHER,
-    replacement: redactUrlReplacement(...matchers),
-  }
-}
-
-const matcherFunctions = {
-  [TYPE_REGEX]: (matcher) => (value) => {
-    if (typeof value === 'string') {
-      value = value.replace(matcher.pattern, matcher.replacement)
-    }
-    return value
-  },
-  [TYPE_URL]: (matcher) => (value, ctx) => {
-    if (typeof value === 'string') {
-      try {
-        const url = ctx?.url || new URL(value)
-        const { predicate, pattern } = matcher
-        const predicateValue = predicate({ url })
-        if (predicateValue) {
-          value = value.replace(pattern({ url }), matcher.replacement)
-        }
-      } catch (_e) {
-        return value
-      }
-    }
-    return value
-  },
-  [TYPE_PATH]: (matcher) => (value, ctx) => {
-    const rawPath = ctx?.path
-    const path = rawPath.join('.').toLowerCase()
-    const { predicate, replacement } = matcher
-    const replace = typeof replacement === 'function' ? replacement : () => replacement
-    const shouldRun = predicate({ rawPath, path })
-    if (shouldRun) {
-      value = replace(value, { rawPath, path })
-    }
-    return value
-  },
-}
-
-/** converts a matcher to a function */
-const redactMatcher = (matcher) => {
-  return matcherFunctions[matcher.type](matcher)
-}
-
-/** converts a series of matchers to a function */
-const redactMatchers = (...matchers) => (value, ctx) => {
-  const flatMatchers = matchers.flat()
-  return flatMatchers.reduce((result, matcher) => {
-    const fn = (typeof matcher === 'function') ? matcher : redactMatcher(matcher)
-    return fn(result, ctx)
-  }, value)
-}
-
-/**
- * replacement handler, keeping $1 (if it exists) and replacing the
- * rest of the string with asterisks, maintaining string length
- */
-const redactDynamicReplacement = () => (value, start) => {
-  if (typeof start === 'number') {
-    return asterisk(value)
-  }
-  return start + asterisk(value.substring(start.length).length)
-}
-
-/**
- * replacement handler, keeping $1 (if it exists) and replacing the
- * rest of the string with a fixed number of asterisks
- */
-const redactFixedReplacement = (length) => (_value, start) => {
-  if (typeof start === 'number') {
-    return asterisk(length)
-  }
-  return start + asterisk(length)
-}
-
-const redactUrlPassword = (value, replacement) => {
-  return redactMatchers(redactUrlPasswordMatcher({ replacement }))(value)
-}
-
-module.exports = {
-  asterisk,
-  escapeRegExp,
-  urlEncodeRegexGroup,
-  urlEncodeRegexTag,
-  redactUrlHostnameMatcher,
-  redactUrlSearchParamsMatcher,
-  redactUrlPasswordMatcher,
-  redactUrlMatcher,
-  redactUrlReplacement,
-  redactDynamicReplacement,
-  redactFixedReplacement,
-  redactMatchers,
-  redactUrlPassword,
-}