@pnpm/exe 11.0.6 → 11.0.8

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,
-}

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

@@ -1,52 +0,0 @@
-{
-  "name": "@npmcli/redact",
-  "version": "4.0.0",
-  "description": "Redact sensitive npm information from output",
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./server": "./lib/server.js",
-    "./package.json": "./package.json"
-  },
-  "scripts": {
-    "test": "tap",
-    "lint": "npm run eslint",
-    "postlint": "template-oss-check",
-    "template-oss-apply": "template-oss-apply --force",
-    "lintfix": "npm run eslint -- --fix",
-    "snap": "tap",
-    "posttest": "npm run lint",
-    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
-  },
-  "keywords": [],
-  "author": "GitHub Inc.",
-  "license": "ISC",
-  "files": [
-    "bin/",
-    "lib/"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/npm/redact.git"
-  },
-  "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/**"
-    ],
-    "timeout": 120
-  },
-  "devDependencies": {
-    "@npmcli/eslint-config": "^5.0.0",
-    "@npmcli/template-oss": "4.27.1",
-    "tap": "^16.3.10"
-  },
-  "engines": {
-    "node": "^20.17.0 || >=22.9.0"
-  }
-}

package/dist/node_modules/agent-base/LICENSE

@@ -1,22 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
-
-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/dist/node_modules/agent-base/dist/helpers.js

@@ -1,66 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.req = exports.json = exports.toBuffer = void 0;
-const http = __importStar(require("http"));
-const https = __importStar(require("https"));
-async function toBuffer(stream) {
-    let length = 0;
-    const chunks = [];
-    for await (const chunk of stream) {
-        length += chunk.length;
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks, length);
-}
-exports.toBuffer = toBuffer;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function json(stream) {
-    const buf = await toBuffer(stream);
-    const str = buf.toString('utf8');
-    try {
-        return JSON.parse(str);
-    }
-    catch (_err) {
-        const err = _err;
-        err.message += ` (input: ${str})`;
-        throw err;
-    }
-}
-exports.json = json;
-function req(url, opts = {}) {
-    const href = typeof url === 'string' ? url : url.href;
-    const req = (href.startsWith('https:') ? https : http).request(url, opts);
-    const promise = new Promise((resolve, reject) => {
-        req
-            .once('response', resolve)
-            .once('error', reject)
-            .end();
-    });
-    req.then = promise.then.bind(promise);
-    return req;
-}
-exports.req = req;
-//# sourceMappingURL=helpers.js.map