Add files using upload-large-folder tool

node/node_modules/npm/node_modules/@npmcli/agent/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@npmcli/agent",
+  "version": "4.0.0",
+  "description": "the http/https agent used by the npm cli",
+  "main": "lib/index.js",
+  "scripts": {
+    "gencerts": "bash scripts/create-cert.sh",
+    "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}\""
+  },
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/npm/agent/issues"
+  },
+  "homepage": "https://github.com/npm/agent#readme",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "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.0",
+    "publish": "true"
+  },
+  "dependencies": {
+    "agent-base": "^7.1.0",
+    "http-proxy-agent": "^7.0.0",
+    "https-proxy-agent": "^7.0.1",
+    "lru-cache": "^11.2.1",
+    "socks-proxy-agent": "^8.0.3"
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.0",
+    "@npmcli/template-oss": "4.25.0",
+    "minipass-fetch": "^4.0.1",
+    "nock": "^14.0.3",
+    "socksv5": "^0.0.6",
+    "tap": "^16.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/agent.git"
+  },
+  "tap": {
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  }
+}

node/node_modules/npm/node_modules/@npmcli/arborist/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.

node/node_modules/npm/node_modules/@npmcli/arborist/README.md

@@ -0,0 +1,315 @@
+# @npmcli/arborist
+
+[![npm version](https://img.shields.io/npm/v/@npmcli/arborist.svg)](https://npm.im/@npmcli/arborist)
+[![license](https://img.shields.io/npm/l/@npmcli/arborist.svg)](https://npm.im/@npmcli/arborist)
+[![CI - @npmcli/arborist](https://github.com/npm/cli/actions/workflows/ci-npmcli-arborist.yml/badge.svg)](https://github.com/npm/cli/actions/workflows/ci-npmcli-arborist.yml)
+
+Inspect and manage `node_modules` trees.
+
+![a tree with the word ARBORIST superimposed on it](https://raw.githubusercontent.com/npm/cli/latest/workspaces/arborist/docs/logo.svg?sanitize=true)
+
+There's more documentation [in the docs
+folder](https://github.com/npm/cli/tree/latest/workspaces/arborist/docs).
+
+## USAGE
+
+```js
+const Arborist = require('@npmcli/arborist')
+
+const arb = new Arborist({
+  // options object
+
+  // where we're doing stuff.  defaults to cwd.
+  path: '/path/to/package/root',
+
+  // url to the default registry.  defaults to npm's default registry
+  registry: 'https://registry.npmjs.org',
+
+  // scopes can be mapped to a different registry
+  '@foo:registry': 'https://registry.foo.com/',
+
+  // Auth can be provided in a couple of different ways.  If none are
+  // provided, then requests are anonymous, and private packages will 404.
+  // Arborist doesn't do anything with these, it just passes them down
+  // the chain to pacote and npm-registry-fetch.
+
+  // Safest: a bearer token provided by a registry:
+  // 1. an npm auth token, used with the default registry
+  token: 'deadbeefcafebad',
+  // 2. an alias for the same thing:
+  _authToken: 'deadbeefcafebad',
+
+  // insecure options:
+  // 3. basic auth, username:password, base64 encoded
+  auth: 'aXNhYWNzOm5vdCBteSByZWFsIHBhc3N3b3Jk',
+  // 4. username and base64 encoded password
+  username: 'isaacs',
+  password: 'bm90IG15IHJlYWwgcGFzc3dvcmQ=',
+
+  // auth configs can also be scoped to a given registry with this
+  // rather unusual pattern:
+  '//registry.foo.com:token': 'blahblahblah',
+  '//basic.auth.only.foo.com:_auth': 'aXNhYWNzOm5vdCBteSByZWFsIHBhc3N3b3Jk',
+  '//registry.foo.com:always-auth': true,
+})
+
+// READING
+
+// returns a promise.  reads the actual contents of node_modules
+arb.loadActual().then(tree => {
+  // tree is also stored at arb.virtualTree
+})
+
+// read just what the package-lock.json/npm-shrinkwrap says
+// This *also* loads the yarn.lock file, but that's only relevant
+// when building the ideal tree.
+arb.loadVirtual().then(tree => {
+  // tree is also stored at arb.virtualTree
+  // now arb.virtualTree is loaded
+  // this fails if there's no package-lock.json or package.json in the folder
+  // note that loading this way should only be done if there's no
+  // node_modules folder
+})
+
+// OPTIMIZING AND DESIGNING
+
+// build an ideal tree from the package.json and various lockfiles.
+arb.buildIdealTree(options).then(() => {
+  // next step is to reify that ideal tree onto disk.
+  // options can be:
+  // rm: array of package names to remove at top level
+  // add: Array of package specifiers to add at the top level.  Each of
+  //   these will be resolved with pacote.manifest if the name can't be
+  //   determined from the spec.  (Eg, `github:foo/bar` vs `foo@somespec`.)
+  //   The dep will be saved in the location where it already exists,
+  //   (or pkg.dependencies) unless a different saveType is specified.
+  // saveType: Save added packages in a specific dependency set.
+  //   - null (default) Wherever they exist already, or 'dependencies'
+  //   - prod: definitely in 'dependencies'
+  //   - optional: in 'optionalDependencies'
+  //   - dev: devDependencies
+  //   - peer: save in peerDependencies, and remove any optional flag from
+  //     peerDependenciesMeta if one exists
+  //   - peerOptional: save in peerDependencies, and add a
+  //     peerDepsMeta[name].optional flag
+  // saveBundle: add newly added deps to the bundleDependencies list
+  // update: Either `true` to just go ahead and update everything, or an
+  //   object with any or all of the following fields:
+  //   - all: boolean.  set to true to just update everything
+  //   - names: names of packages update (like `npm update foo`)
+  // prune: boolean, default true.  Prune extraneous nodes from the tree.
+  // preferDedupe: prefer to deduplicate packages if possible, rather than
+  //   choosing a newer version of a dependency.  Defaults to false, ie,
+  //   always try to get the latest and greatest deps.
+  // legacyBundling: Nest every dep under the node requiring it, npm v2 style.
+  //   No unnecessary deduplication.  Default false.
+
+  // At the end of this process, arb.idealTree is set.
+})
+
+// WRITING
+
+// Make the idealTree be the thing that's on disk
+arb.reify({
+  // write the lockfile(s) back to disk, and package.json with any updates
+  // defaults to 'true'
+  save: true,
+}).then(() => {
+  // node modules has been written to match the idealTree
+})
+```
+
+## DATA STRUCTURES
+
+A `node_modules` tree is a logical graph of dependencies overlaid on a
+physical tree of folders.
+
+A `Node` represents a package folder on disk, either at the root of the
+package, or within a `node_modules` folder.  The physical structure of the
+folder tree is represented by the `node.parent` reference to the containing
+folder, and `node.children` map of nodes within its `node_modules`
+folder, where the key in the map is the name of the folder in
+`node_modules`, and the value is the child node.
+
+A node without a parent is a top of tree.
+
+A `Link` represents a symbolic link to a package on disk.  This can be a
+symbolic link to a package folder within the current tree, or elsewhere on
+disk.  The `link.target` is a reference to the actual node.  Links differ
+from Nodes in that dependencies are resolved from the _target_ location,
+rather than from the link location.
+
+An `Edge` represents a dependency relationship.  Each node has an `edgesIn`
+set, and an `edgesOut` map.  Each edge has a `type` which specifies what
+kind of dependency it represents: `'prod'` for regular dependencies,
+`'peer'` for peerDependencies, `'dev'` for devDependencies, and
+`'optional'` for optionalDependencies.  `edge.from` is a reference to the
+node that has the dependency, and `edge.to` is a reference to the node that
+requires the dependency.
+
+As nodes are moved around in the tree, the graph edges are automatically
+updated to point at the new module resolution targets.  In other words,
+`edge.from`, `edge.name`, and `edge.spec` are immutable; `edge.to` is
+updated automatically when a node's parent changes.
+
+### class Node
+
+All arborist trees are `Node` objects.  A `Node` refers
+to a package folder, which may have children in `node_modules`.
+
+* `node.name` The name of this node's folder in `node_modules`.
+* `node.parent` Physical parent node in the tree.  The package in whose
+  `node_modules` folder this package lives.  Null if node is top of tree.
+
+    Setting `node.parent` will automatically update `node.location` and all
+    graph edges affected by the move.
+
+* `node.meta` A `Shrinkwrap` object which looks up `resolved` and
+  `integrity` values for all modules in this tree.  Only relevant on `root`
+  nodes.
+
+* `node.children` Map of packages located in the node's `node_modules`
+  folder.
+* `node.package` The contents of this node's `package.json` file.
+* `node.path` File path to this package.  If the node is a link, then this
+  is the path to the link, not to the link target.  If the node is _not_ a
+  link, then this matches `node.realpath`.
+* `node.realpath` The full real filepath on disk where this node lives.
+* `node.location` A slash-normalized relative path from the root node to
+  this node's path.
+* `node.isLink` Whether this represents a symlink.  Always `false` for Node
+  objects, always `true` for Link objects.
+* `node.isRoot` True if this node is a root node.  (Ie, if `node.root ===
+  node`.)
+* `node.root` The root node where we are working.  If not assigned to some
+  other value, resolves to the node itself.  (Ie, the root node's `root`
+  property refers to itself.)
+* `node.isTop` True if this node is the top of its tree (ie, has no
+  `parent`, false otherwise).
+* `node.top` The top node in this node's tree.  This will be equal to
+  `node.root` for simple trees, but link targets will frequently be outside
+  of (or nested somewhere within) a `node_modules` hierarchy, and so will
+  have a different `top`.
+* `node.dev`, `node.optional`, `node.devOptional`, `node.peer`, Indicators
+  as to whether this node is a dev, optional, and/or peer dependency.
+  These flags are relevant when pruning dependencies out of the tree or
+  deciding what to reify.  See **Package Dependency Flags** below for
+  explanations.
+* `node.edgesOut` Edges in the dependency graph indicating nodes that this
+  node depends on, which resolve its dependencies.
+* `node.edgesIn` Edges in the dependency graph indicating nodes that depend
+  on this node.
+
+* `extraneous` True if this package is not required by any other for any
+  reason.  False for top of tree.
+
+* `node.resolve(name)`  Identify the node that will be returned when code
+  in this package runs `require(name)`
+
+* `node.errors` Array of errors encountered while parsing package.json or
+  version specifiers.
+
+### class Link
+
+Link objects represent a symbolic link within the `node_modules` folder.
+They have most of the same properties and methods as `Node` objects, with a
+few differences.
+
+* `link.target` A Node object representing the package that the link
+  references.  If this is a Node already present within the tree, then it
+  will be the same object.  If it's outside of the tree, then it will be
+  treated as the top of its own tree.
+* `link.isLink` Always true.
+* `link.children` This is always an empty map, since links don't have their
+  own children directly.
+
+### class Edge
+
+Edge objects represent a dependency relationship a package node to the
+point in the tree where the dependency will be loaded.  As nodes are moved
+within the tree, Edges automatically update to point to the appropriate
+location.
+
+* `new Edge({ from, type, name, spec })`  Creates a new edge with the
+  specified fields.  After instantiation, none of the fields can be
+  changed directly.
+* `edge.from` The node that has the dependency.
+* `edge.type` The type of dependency.  One of `'prod'`, `'dev'`, `'peer'`,
+  or `'optional'`.
+* `edge.name` The name of the dependency.  Ie, the key in the
+  relevant `package.json` dependencies object.
+* `edge.spec` The specifier that is required.  This can be a version,
+  range, tag name, git url, or tarball URL.  Any specifier allowed by npm
+  is supported.
+* `edge.to` Automatically set to the node in the tree that matches the
+  `name` field.
+* `edge.valid` True if `edge.to` satisfies the specifier.
+* `edge.error` A string indicating the type of error if there is a problem,
+  or `null` if it's valid.  Values, in order of precedence:
+    * `DETACHED` Indicates that the edge has been detached from its
+      `edge.from` node, typically because a new edge was created when a
+      dependency specifier was modified.
+    * `MISSING` Indicates that the dependency is unmet.  Note that this is
+      _not_ set for unmet dependencies of the `optional` type.
+    * `PEER LOCAL` Indicates that a `peerDependency` is found in the
+      node's local `node_modules` folder, and the node is not the top of
+      the tree.  This violates the `peerDependency` contract, because it
+      means that the dependency is not a peer.
+    * `INVALID` Indicates that the dependency does not satisfy `edge.spec`.
+* `edge.reload()` Re-resolve to find the appropriate value for `edge.to`.
+  Called automatically from the `Node` class when the tree is mutated.
+
+### Package Dependency Flags
+
+The dependency type of a node can be determined efficiently by looking at
+the `dev`, `optional`, and `devOptional` flags on the node object.  These
+are updated by arborist when necessary whenever the tree is modified in
+such a way that the dependency graph can change, and are relevant when
+pruning nodes from the tree.
+
+| extraneous | peer | dev | optional | devOptional      | meaning                                                                                          | prune?                                                 |
+|:----------:|:----:|:---:|:--------:|:----------------:|:-------------------------------------------------------------------------------------------------|:-------------------------------------------------------|
+|            |      |     |          |                  | production dep                                                                                   | never                                                  |
+|   X        | N/A  | N/A |   N/A    |     N/A          | nothing depends on this, it is trash                                                             | always                                                 |
+|            |      |  X  |          | X<br>not in lock | devDependency, or only depended<br>on by devDependencies                                         | if pruning dev                                         |
+|            |      |     |    X     | X<br>not in lock | optionalDependency, or only depended<br>on by optionalDeps                                       | if pruning optional                                    |
+|            |      |  X  |    X     | X<br>not in lock | Optional dependency of dep(s) in the<br>dev hierarchy                                            | if pruning EITHER<br>dev OR optional                   |
+|            |      |     |          | X<br>in lock     | BOTH a non-optional  dep within the<br>dev hierarchy, AND a dep within<br>the optional hierarchy | if pruning BOTH<br>dev AND optional                    |
+|            |  X   |     |          |                  | peer dependency, or only depended<br>on by peer dependencies                                     | if pruning peers                                       |
+|            |  X   |  X  |          | X<br>not in lock | peer dependency of dev node hierarchy                                                            | if pruning peer OR<br>dev deps                         |
+|            |  X   |     |    X     | X<br>not in lock | peer dependency of optional nodes, or<br>peerOptional dep                                        | if pruning peer OR<br>optional deps                    |
+|            |  X   |  X  |    X     | X<br>not in lock | peer optional deps of the dev dep hierarchy                                                      | if pruning peer OR<br>optional OR dev                  |
+|            |  X   |     |          | X<br>in lock     | BOTH a non-optional peer dep within the<br>dev hierarchy, AND a peer optional dep                | if pruning peer deps OR:<br>BOTH optional AND dev deps |
+
+* If none of these flags are set, then the node is required by the
+  dependency and/or peerDependency hierarchy.  It should not be pruned.
+* If _both_ `node.dev` and `node.optional` are set, then the node is an
+  optional dependency of one of the packages in the devDependency
+  hierarchy.  It should be pruned if _either_ dev or optional deps are
+  being removed.
+* If `node.dev` is set, but `node.optional` is not, then the node is
+  required in the devDependency hierarchy.  It should be pruned if dev
+  dependencies are being removed.
+* If `node.optional` is set, but `node.dev` is not, then the node is
+  required in the optionalDependency hierarchy.  It should be pruned if
+  optional dependencies are being removed.
+* If `node.devOptional` is set, then the node is a (non-optional)
+  dependency within the devDependency hierarchy, _and_ a dependency
+  within the `optionalDependency` hierarchy.  It should be pruned if
+  _both_ dev and optional dependencies are being removed.
+* If `node.peer` is set, then all the same semantics apply as above, except
+  that the dep is brought in by a peer dep at some point, rather than a
+  normal non-peer dependency.
+
+Note: `devOptional` is only set in the shrinkwrap/package-lock file if
+_neither_ `dev` nor `optional` are set, as it would be redundant.
+
+## BIN
+
+Arborist ships with a cli that can be used to run arborist specific commands outside of the context of the npm CLI. This script is currently not part of the public API and is subject to breaking changes outside of major version bumps.
+
+To see the usage run:
+
+```
+npx @npmcli/arborist --help
+```

node/node_modules/npm/node_modules/@npmcli/arborist/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@npmcli/arborist",
+  "version": "9.4.3",
+  "description": "Manage node_modules trees",
+  "dependencies": {
+    "@gar/promise-retry": "^1.0.0",
+    "@isaacs/string-locale-compare": "^1.1.0",
+    "@npmcli/fs": "^5.0.0",
+    "@npmcli/installed-package-contents": "^4.0.0",
+    "@npmcli/map-workspaces": "^5.0.0",
+    "@npmcli/metavuln-calculator": "^9.0.2",
+    "@npmcli/name-from-folder": "^4.0.0",
+    "@npmcli/node-gyp": "^5.0.0",
+    "@npmcli/package-json": "^7.0.0",
+    "@npmcli/query": "^5.0.0",
+    "@npmcli/redact": "^4.0.0",
+    "@npmcli/run-script": "^10.0.0",
+    "bin-links": "^6.0.0",
+    "cacache": "^20.0.1",
+    "common-ancestor-path": "^2.0.0",
+    "hosted-git-info": "^9.0.0",
+    "json-stringify-nice": "^1.1.4",
+    "lru-cache": "^11.2.1",
+    "minimatch": "^10.0.3",
+    "nopt": "^9.0.0",
+    "npm-install-checks": "^8.0.0",
+    "npm-package-arg": "^13.0.0",
+    "npm-pick-manifest": "^11.0.1",
+    "npm-registry-fetch": "^19.0.0",
+    "pacote": "^21.0.2",
+    "parse-conflict-json": "^5.0.1",
+    "proc-log": "^6.0.0",
+    "proggy": "^4.0.0",
+    "promise-all-reject-late": "^1.0.0",
+    "promise-call-limit": "^3.0.1",
+    "semver": "^7.3.7",
+    "ssri": "^13.0.0",
+    "treeverse": "^3.0.0",
+    "walk-up-path": "^4.0.0"
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.1",
+    "@npmcli/mock-registry": "^1.0.0",
+    "@npmcli/template-oss": "4.29.0",
+    "benchmark": "^2.1.4",
+    "minify-registry-metadata": "^4.0.0",
+    "nock": "^13.3.3",
+    "tap": "^16.3.8",
+    "tar-stream": "^3.0.0",
+    "tcompare": "^5.0.6"
+  },
+  "scripts": {
+    "test": "tap",
+    "posttest": "npm run lint",
+    "snap": "tap",
+    "test-proxy": "ARBORIST_TEST_PROXY=1 tap --snapshot",
+    "lint": "npm run eslint",
+    "lintfix": "npm run eslint -- --fix",
+    "benchmark": "node scripts/benchmark.js",
+    "benchclean": "rm -rf scripts/benchmark/*/",
+    "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/cli.git",
+    "directory": "workspaces/arborist"
+  },
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "main": "lib/index.js",
+  "bin": {
+    "arborist": "bin/index.js"
+  },
+  "tap": {
+    "after": "test/fixtures/cleanup.js",
+    "test-env": [
+      "LC_ALL=sk"
+    ],
+    "timeout": "720",
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "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.29.0",
+    "content": "../../scripts/template-oss/index.js"
+  }
+}

node/node_modules/npm/node_modules/@npmcli/config/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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.

node/node_modules/npm/node_modules/@npmcli/config/README.md

@@ -0,0 +1,226 @@
+# `@npmcli/config`
+
+Configuration management for the npm cli.
+
+This module is the spiritual descendant of [`npmconf`](http://npm.im/npmconf), and the code that once lived in npm's
+`lib/config/` folder.
+
+It does the management of configuration files that npm uses, but importantly, does _not_ define all the configuration defaults or types, as those parts make more sense to live within the npm CLI itself.
+
+The only exceptions:
+
+- The `prefix` config value has some special semantics, setting the local prefix if specified on the CLI options and not in global mode, or the global prefix otherwise.
+- The `project` config file is loaded based on the local prefix (which can only be set by the CLI config options, and otherwise defaults to a walk up the folder tree to the first parent containing a `node_modules` folder, `package.json` file, or `package-lock.json` file.)
+- The `userconfig` value, as set by the environment and CLI (defaulting to
+  `~/.npmrc`, is used to load user configs.
+- The `globalconfig` value, as set by the environment, CLI, and
+  `userconfig` file (defaulting to `$PREFIX/etc/npmrc`) is used to load global configs.
+- A `builtin` config, read from a `npmrc` file in the root of the npm project itself, overrides all defaults.
+
+The resulting hierarchy of configs:
+
+- CLI switches.
+  eg `--some-key=some-value` on the command line.
+  These are parsed by [`nopt`](http://npm.im/nopt), which is not a great choice, but it's the one that npm has used forever, and changing it will be difficult.
+- Environment variables.
+  eg `npm_config_some_key=some_value` in the environment.
+  There is no way at this time to modify this prefix.
+- INI-formatted project configs.
+  eg `some-key = some-value` in the
+  `localPrefix` folder (ie, the `cwd`, or its nearest parent that contains either a `node_modules` folder or `package.json` file.)
+- INI-formatted userconfig file.
+  eg `some-key = some-value` in `~/.npmrc`.
+  The `userconfig` config value can be overridden by the `cli`, `env`, or
+  `project` configs to change this value.
+- INI-formatted globalconfig file.
+  eg `some-key = some-value` in the `globalPrefix` folder, which is inferred by looking at the location of the node executable, or the `prefix` setting in the `cli`, `env`, `project`, or `userconfig`.
+  The `globalconfig` value at any of those levels can override this.
+- INI-formatted builtin config file.
+  eg `some-key = some-value` in `/usr/local/lib/node_modules/npm/npmrc`.
+  This is not configurable, and is determined by looking in the `npmPath` folder.
+- Default values (passed in by npm when it loads this module).
+
+## USAGE
+
+```js
+const Config = require('@npmcli/config')
+const { shorthands, definitions, flatten } = require('@npmcli/config/lib/definitions')
+
+const conf = new Config({
+  // path to the npm module being run
+  npmPath: resolve(__dirname, '..'),
+  definitions,
+  shorthands,
+  flatten,
+  // optional, defaults to process.argv
+  // argv: [] <- if you are using this package in your own cli
+  //             and don't want to have colliding argv
+  argv: process.argv,
+  // optional, defaults to process.env
+  env: process.env,
+  // optional, defaults to process.execPath
+  execPath: process.execPath,
+  // optional, defaults to process.platform
+  platform: process.platform,
+  // optional, defaults to process.cwd()
+  cwd: process.cwd(),
+})
+
+// emits log events on the process object
+// see `proc-log` for more info
+process.on('log', (level, ...args) => {
+  console.log(level, ...args)
+})
+
+// returns a promise that fails if config loading fails, and
+// resolves when the config object is ready for action
+conf.load().then(() => {
+  conf.validate()
+  console.log('loaded ok! some-key = ' + conf.get('some-key'))
+}).catch(er => {
+  console.error('error loading configs!', er)
+})
+```
+
+## API
+
+The `Config` class is the sole export.
+
+```js
+const Config = require('@npmcli/config')
+```
+
+### static `Config.typeDefs`
+
+The type definitions passed to `nopt` for CLI option parsing and known configuration validation.
+
+### constructor `new Config(options)`
+
+Options:
+
+- `types` Types of all known config values.
+Note that some are effectively given semantic value in the config loading process itself.
+- `shorthands` An object mapping a shorthand value to an array of CLI arguments that replace it.
+- `defaults` Default values for each of the known configuration keys.
+  These should be defined for all configs given a type, and must be valid.
+- `npmPath` The path to the `npm` module, for loading the `builtin` config file.
+- `cwd` Optional, defaults to `process.cwd()`, used for inferring the
+  `localPrefix` and loading the `project` config.
+- `platform` Optional, defaults to `process.platform`.
+Used when inferring the `globalPrefix` from the `execPath`, since this is done differently on Windows.
+- `execPath` Optional, defaults to `process.execPath`.
+Used to infer the
+  `globalPrefix`.
+- `env` Optional, defaults to `process.env`.
+Source of the environment variables for configuration.
+- `argv` Optional, defaults to `process.argv`.
+Source of the CLI options used for configuration.
+
+Returns a `config` object, which is not yet loaded.
+
+Fields:
+
+- `config.globalPrefix` The prefix for `global` operations.
+Set by the
+  `prefix` config value, or defaults based on the location of the
+  `execPath` option.
+- `config.localPrefix` The prefix for `local` operations.
+Set by the
+  `prefix` config value on the CLI only, or defaults to either the `cwd` or its nearest ancestor containing a `node_modules` folder or `package.json` file.
+- `config.sources` A read-only `Map` of the file (or a comment, if no file found, or relevant) to the config level loaded from that source.
+- `config.data` A `Map` of config level to `ConfigData` objects.
+These objects should not be modified directly under any circumstances.
+  - `source` The source where this data was loaded from.
+  - `raw` The raw data used to generate this config data, as it was parsed initially from the environment, config file, or CLI options.
+  - `data` The data object reflecting the inheritance of configs up to this point in the chain.
+  - `loadError` Any errors encountered that prevented the loading of this config data.
+- `config.list` A list sorted in priority of all the config data objects in the prototype chain.
+`config.list[0]` is the `cli` level,
+  `config.list[1]` is the `env` level, and so on.
+- `cwd` The `cwd` param
+- `env` The `env` param
+- `argv` The `argv` param
+- `execPath` The `execPath` param
+- `platform` The `platform` param
+- `defaults` The `defaults` param
+- `shorthands` The `shorthands` param
+- `types` The `types` param
+- `npmPath` The `npmPath` param
+- `globalPrefix` The effective `globalPrefix`
+- `localPrefix` The effective `localPrefix`
+- `prefix` If `config.get('global')` is true, then `globalPrefix`, otherwise `localPrefix`
+- `home` The user's home directory, found by looking at `env.HOME` or calling `os.homedir()`.
+- `loaded` A boolean indicating whether or not configs are loaded
+- `valid` A getter that returns `true` if all the config objects are valid.
+  Any data objects that have been modified with `config.set(...)` will be re-evaluated when `config.valid` is read.
+
+### `config.load()`
+
+Load configuration from the various sources of information.
+
+Returns a `Promise` that resolves when configuration is loaded, and fails if a fatal error is encountered.
+
+### `config.find(key)`
+
+Find the effective place in the configuration levels a given key is set.
+Returns one of: `cli`, `env`, `project`, `user`, `global`, `builtin`, or
+`default`.
+
+Returns `null` if the key is not set.
+
+### `config.get(key, where = 'cli')`
+
+Load the given key from the config stack.
+
+### `config.set(key, value, where = 'cli')`
+
+Set the key to the specified value, at the specified level in the config stack.
+
+### `config.delete(key, where = 'cli')`
+
+Delete the configuration key from the specified level in the config stack.
+
+### `config.validate(where)`
+
+Verify that all known configuration options are set to valid values, and log a warning if they are invalid.
+
+Invalid auth options will cause this method to throw an error with a `code` property of `ERR_INVALID_AUTH`, and a `problems` property listing the specific concerns with the current configuration.
+
+If `where` is not set, then all config objects are validated.
+
+Returns `true` if all configs are valid.
+
+Note that it's usually enough (and more efficient) to just check
+`config.valid`, since each data object is marked for re-evaluation on every
+`config.set()` operation.
+
+### `config.repair(problems)`
+
+Accept an optional array of problems (as thrown by `config.validate()`) and perform the necessary steps to resolve them.
+If no problems are provided, this method will call `config.validate()` internally to retrieve them.
+
+Note that you must `await config.save('user')` in order to persist the changes.
+
+### `config.isDefault(key)`
+
+Returns `true` if the value is coming directly from the default definitions, if the current value for the key config is coming from any other source, returns `false`.
+
+This method can be used for avoiding or tweaking default values, e.g:
+
+>  Given a global default definition of foo='foo' it's possible to read that value such as:
+>
+>  ```js
+>     const save = config.get('foo')
+>  ```
+>
+>  Now in a different place of your app it's possible to avoid using the `foo` default value, by checking to see if the current config value is currently one that was defined by the default definitions:
+>
+>  ```js
+>     const save = config.isDefault('foo') ? 'bar' : config.get('foo')
+>  ```
+
+### `config.save(where)`
+
+Save the config file specified by the `where` param.
+Must be one of
+`project`, `user`, `global`, `builtin`.

node/node_modules/npm/node_modules/@npmcli/config/lib/env-replace.js

@@ -0,0 +1,16 @@
+// replace any ${ENV} values with the appropriate environ.
+// optional "?" modifier can be used like this: ${ENV?} so in case of the variable being not defined, it evaluates into empty string.
+
+const envExpr = /(?<!\\)(\\*)\$\{([^${}?]+)(\?)?\}/g
+
+module.exports = (f, env) => f.replace(envExpr, (orig, esc, name, modifier) => {
+  const fallback = modifier === '?' ? '' : `$\{${name}}`
+  const val = env[name] !== undefined ? env[name] : fallback
+
+  // consume the escape chars that are relevant.
+  if (esc.length % 2) {
+    return orig.slice((esc.length + 1) / 2)
+  }
+
+  return (esc.slice(esc.length / 2)) + val
+})

node/node_modules/npm/node_modules/@npmcli/config/lib/errors.js

@@ -0,0 +1,23 @@
+'use strict'
+
+class ErrInvalidAuth extends Error {
+  constructor (problems) {
+    let message = 'Invalid auth configuration found: '
+    message += problems.map((problem) => {
+      // istanbul ignore else
+      if (problem.action === 'delete') {
+        return `\`${problem.key}\` is not allowed in ${problem.where} config`
+      } else if (problem.action === 'rename') {
+        return `\`${problem.from}\` must be renamed to \`${problem.to}\` in ${problem.where} config`
+      }
+    }).join(', ')
+    message += '\nPlease run `npm config fix` to repair your configuration.`'
+    super(message)
+    this.code = 'ERR_INVALID_AUTH'
+    this.problems = problems
+  }
+}
+
+module.exports = {
+  ErrInvalidAuth,
+}

node/node_modules/npm/node_modules/@npmcli/config/lib/index.js

@@ -0,0 +1,1034 @@
+// TODO: set the scope config from package.json or explicit cli config
+const { walkUp } = require('walk-up-path')
+const ini = require('ini')
+const nopt = require('nopt')
+const { log, time } = require('proc-log')
+
+const { resolve, dirname, join } = require('node:path')
+const { homedir } = require('node:os')
+const {
+  readFile,
+  writeFile,
+  chmod,
+  unlink,
+  stat,
+  mkdir,
+} = require('node:fs/promises')
+
+// TODO global-prefix and local-prefix are set by lib/set-envs.js.  This may not be the best way to persist those, if we even want to persist them (see set-envs.js)
+const internalEnv = [
+  'npm-version',
+  'global-prefix',
+  'local-prefix',
+]
+
+const fileExists = (...p) => stat(resolve(...p))
+  .then((st) => st.isFile())
+  .catch(() => false)
+
+const dirExists = (...p) => stat(resolve(...p))
+  .then((st) => st.isDirectory())
+  .catch(() => false)
+
+const hasOwnProperty = (obj, key) =>
+  Object.prototype.hasOwnProperty.call(obj, key)
+
+const typeDefs = require('./type-defs.js')
+const nerfDart = require('./nerf-dart.js')
+const envReplace = require('./env-replace.js')
+const parseField = require('./parse-field.js')
+const setEnvs = require('./set-envs.js')
+
+// types that can be saved back to
+const confFileTypes = new Set([
+  'global',
+  'user',
+  'project',
+])
+
+const confTypes = new Set([
+  'default',
+  'builtin',
+  ...confFileTypes,
+  'env',
+  'cli',
+])
+
+class Config {
+  #loaded = false
+  #flatten
+  // populated the first time we flatten the object
+  #flatOptions = null
+  #warnings = []
+
+  static get typeDefs () {
+    return typeDefs
+  }
+
+  constructor ({
+    definitions,
+    shorthands,
+    flatten,
+    nerfDarts = [],
+    npmPath,
+
+    // options just to override in tests, mostly
+    env = process.env,
+    argv = process.argv,
+    platform = process.platform,
+    execPath = process.execPath,
+    cwd = process.cwd(),
+    excludeNpmCwd = false,
+    warn = true,
+  }) {
+    this.nerfDarts = nerfDarts
+    this.definitions = definitions
+    // turn the definitions into nopt's weirdo syntax
+    const { types, defaults, deprecated } = getTypesFromDefinitions(definitions)
+    this.deprecated = deprecated
+
+    this.#flatten = flatten
+    this.types = types
+    this.shorthands = shorthands
+    this.defaults = defaults
+
+    this.npmPath = npmPath
+    this.npmBin = join(this.npmPath, 'bin/npm-cli.js')
+    this.argv = argv
+    this.env = env
+    this.execPath = execPath
+    this.platform = platform
+    this.cwd = cwd
+    this.excludeNpmCwd = excludeNpmCwd
+
+    // set when we load configs
+    this.globalPrefix = null
+    this.localPrefix = null
+    this.localPackage = null
+
+    // defaults to env.HOME, but will always be *something*
+    this.home = null
+
+    // set up the prototype chain of config objects
+    const wheres = [...confTypes]
+    this.data = new Map()
+    let parent = null
+    for (const where of wheres) {
+      this.data.set(where, parent = new ConfigData(parent))
+    }
+
+    this.data.set = () => {
+      throw new Error('cannot change internal config data structure')
+    }
+    this.data.delete = () => {
+      throw new Error('cannot change internal config data structure')
+    }
+
+    this.sources = new Map([])
+
+    for (const { data } of this.data.values()) {
+      this.list.unshift(data)
+    }
+
+    this.#loaded = false
+    this.warn = warn
+  }
+
+  get list () {
+    const list = []
+    for (const { data } of this.data.values()) {
+      list.unshift(data)
+    }
+    return list
+  }
+
+  get loaded () {
+    return this.#loaded
+  }
+
+  get prefix () {
+    return this.#get('global') ? this.globalPrefix : this.localPrefix
+  }
+
+  // return the location where key is found.
+  find (key) {
+    if (!this.loaded) {
+      throw new Error('call config.load() before reading values')
+    }
+
+    // have to look in reverse order
+    const entries = [...this.data.entries()]
+    for (let i = entries.length - 1; i > -1; i--) {
+      const [where, { data }] = entries[i]
+      if (hasOwnProperty(data, key)) {
+        return where
+      }
+    }
+    return null
+  }
+
+  get (key, where) {
+    if (!this.loaded) {
+      throw new Error('call config.load() before reading values')
+    }
+    return this.#get(key, where)
+  }
+
+  // we need to get values sometimes, so use this internal one to do so
+  // while in the process of loading.
+  #get (key, where = null) {
+    if (where !== null && !confTypes.has(where)) {
+      throw new Error('invalid config location param: ' + where)
+    }
+    const { data } = this.data.get(where || 'cli')
+    return where === null || hasOwnProperty(data, key) ? data[key] : undefined
+  }
+
+  set (key, val, where = 'cli') {
+    if (!this.loaded) {
+      throw new Error('call config.load() before setting values')
+    }
+    if (!confTypes.has(where)) {
+      throw new Error('invalid config location param: ' + where)
+    }
+    this.#checkDeprecated(key)
+    const { data, raw } = this.data.get(where)
+    data[key] = val
+    if (['global', 'user', 'project'].includes(where)) {
+      raw[key] = val
+    }
+
+    // this is now dirty, the next call to this.valid will have to check it
+    this.data.get(where)[_valid] = null
+
+    // the flat options are invalidated, regenerate next time they're needed
+    this.#flatOptions = null
+  }
+
+  get flat () {
+    if (this.#flatOptions) {
+      return this.#flatOptions
+    }
+
+    // create the object for flat options passed to deps
+    const timeEnd = time.start('config:load:flatten')
+    this.#flatOptions = {}
+    // walk from least priority to highest
+    for (const { data } of this.data.values()) {
+      this.#flatten(data, this.#flatOptions)
+    }
+    this.#flatOptions.nodeBin = this.execPath
+    this.#flatOptions.npmBin = this.npmBin
+    timeEnd()
+
+    return this.#flatOptions
+  }
+
+  delete (key, where = 'cli') {
+    if (!this.loaded) {
+      throw new Error('call config.load() before deleting values')
+    }
+    if (!confTypes.has(where)) {
+      throw new Error('invalid config location param: ' + where)
+    }
+    const { data, raw } = this.data.get(where)
+    delete data[key]
+    if (['global', 'user', 'project'].includes(where)) {
+      delete raw[key]
+    }
+  }
+
+  async load () {
+    if (this.loaded) {
+      throw new Error('attempting to load npm config multiple times')
+    }
+
+    // first load the defaults, which sets the global prefix
+    this.loadDefaults()
+
+    // next load the builtin config, as this sets new effective defaults
+    await this.loadBuiltinConfig()
+
+    // cli and env are not async, and can set the prefix, relevant to project
+    this.loadCLI()
+    this.loadEnv()
+
+    // next project config, which can affect userconfig location
+    await this.loadProjectConfig()
+
+    // then user config, which can affect globalconfig location
+    await this.loadUserConfig()
+
+    // last but not least, global config file
+    await this.loadGlobalConfig()
+
+    // set this before calling setEnvs, so that we don't have to share
+    // private attributes, as that module also does a bunch of get operations
+    this.#loaded = true
+
+    // set proper globalPrefix now that everything is loaded
+    this.globalPrefix = this.get('prefix')
+
+    this.setEnvs()
+  }
+
+  loadDefaults () {
+    this.loadGlobalPrefix()
+    this.loadHome()
+
+    const defaultsObject = {
+      ...this.defaults,
+      prefix: this.globalPrefix,
+    }
+
+    try {
+      // This does not have an actual definition because this is not user definable
+      defaultsObject['npm-version'] = require(join(this.npmPath, 'package.json')).version
+    } catch {
+      // in some weird state where the passed in npmPath does not have a package.json
+      // this will never happen in npm, but is guarded here in case this is consumed
+      // in other ways + tests
+    }
+
+    this.#loadObject(defaultsObject, 'default', 'default values')
+
+    const { data } = this.data.get('default')
+
+    // if the prefix is set on cli, env, or userconfig, then we need to
+    // default the globalconfig file to that location, instead of the default
+    // global prefix.  It's weird that `npm get globalconfig --prefix=/foo`
+    // returns `/foo/etc/npmrc`, but better to not change it at this point.
+    // define a custom getter, but turn into a normal prop
+    // if we set it.  otherwise it can't be set on child objects
+    Object.defineProperty(data, 'globalconfig', {
+      get: () => resolve(this.#get('prefix'), 'etc/npmrc'),
+      set (value) {
+        Object.defineProperty(data, 'globalconfig', {
+          value,
+          configurable: true,
+          writable: true,
+          enumerable: true,
+        })
+      },
+      configurable: true,
+      enumerable: true,
+    })
+  }
+
+  loadHome () {
+    this.home = this.env.HOME || homedir()
+  }
+
+  loadGlobalPrefix () {
+    if (this.globalPrefix) {
+      throw new Error('cannot load default global prefix more than once')
+    }
+
+    if (this.env.PREFIX) {
+      this.globalPrefix = this.env.PREFIX
+    } else if (this.platform === 'win32') {
+      // c:\node\node.exe --> prefix=c:\node\
+      this.globalPrefix = dirname(this.execPath)
+    } else {
+      // /usr/local/bin/node --> prefix=/usr/local
+      this.globalPrefix = dirname(dirname(this.execPath))
+
+      // destdir only is respected on Unix
+      if (this.env.DESTDIR) {
+        this.globalPrefix = join(this.env.DESTDIR, this.globalPrefix)
+      }
+    }
+  }
+
+  loadEnv () {
+    const conf = Object.create(null)
+    for (const [envKey, envVal] of Object.entries(this.env)) {
+      if (!/^npm_config_/i.test(envKey) || envVal === '') {
+        continue
+      }
+      let key = envKey.slice('npm_config_'.length)
+      if (!key.startsWith('//')) { // don't normalize nerf-darted keys
+        key = key.replace(/(?!^)_/g, '-') // don't replace _ at the start of the key
+          .toLowerCase()
+      }
+      conf[key] = envVal
+    }
+    this.#loadObject(conf, 'env', 'environment')
+  }
+
+  loadCLI () {
+    for (const s of Object.keys(this.shorthands)) {
+      if (s.length > 1 && this.argv.includes(`-${s}`)) {
+        log.warn(`-${s} is not a valid single-hyphen cli flag and will be removed in the future`)
+      }
+    }
+    nopt.invalidHandler = (k, val, type) =>
+      this.invalidHandler(k, val, type, 'command line options', 'cli')
+    nopt.unknownHandler = (k, next) => this.unknownHandler(k, next)
+    nopt.abbrevHandler = this.abbrevHandler
+    const conf = nopt(this.types, this.shorthands, this.argv)
+    nopt.invalidHandler = null
+    nopt.unknownHandler = null
+    this.parsedArgv = conf.argv
+    delete conf.argv
+    this.#loadObject(conf, 'cli', 'command line options')
+  }
+
+  get valid () {
+    for (const [where, { valid }] of this.data.entries()) {
+      if (valid === false || valid === null && !this.validate(where)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  validate (where) {
+    if (!where) {
+      let valid = true
+      const authProblems = []
+
+      for (const entryWhere of this.data.keys()) {
+        // no need to validate our defaults, we know they're fine
+        // cli was already validated when parsed the first time
+        if (entryWhere === 'default' || entryWhere === 'builtin' || entryWhere === 'cli') {
+          continue
+        }
+        const ret = this.validate(entryWhere)
+        valid = valid && ret
+
+        if (['global', 'user', 'project'].includes(entryWhere)) {
+          // after validating everything else, we look for old auth configs we no longer support
+          // if these keys are found, we build up a list of them and the appropriate action and
+          // attach it as context on the thrown error
+
+          // first, keys that should be removed
+          for (const key of ['_authtoken', '-authtoken']) {
+            if (this.get(key, entryWhere)) {
+              authProblems.push({ action: 'delete', key, where: entryWhere })
+            }
+          }
+
+          // NOTE we pull registry without restricting to the current 'where' because we want to
+          // suggest scoping things to the registry they would be applied to, which is the default
+          // regardless of where it was defined
+          const nerfedReg = nerfDart(this.get('registry'))
+          // keys that should be nerfed but currently are not
+          for (const key of ['_auth', '_authToken', 'username', '_password']) {
+            if (this.get(key, entryWhere)) {
+              // username and _password must both exist in the same file to be recognized correctly
+              if (key === 'username' && !this.get('_password', entryWhere)) {
+                authProblems.push({ action: 'delete', key, where: entryWhere })
+              } else if (key === '_password' && !this.get('username', entryWhere)) {
+                authProblems.push({ action: 'delete', key, where: entryWhere })
+              } else {
+                authProblems.push({
+                  action: 'rename',
+                  from: key,
+                  to: `${nerfedReg}:${key}`,
+                  where: entryWhere,
+                })
+              }
+            }
+          }
+        }
+      }
+
+      if (authProblems.length) {
+        const { ErrInvalidAuth } = require('./errors.js')
+        throw new ErrInvalidAuth(authProblems)
+      }
+
+      return valid
+    } else {
+      const obj = this.data.get(where)
+      obj[_valid] = true
+
+      nopt.invalidHandler = (k, val, type) =>
+        this.invalidHandler(k, val, type, obj.source, where)
+
+      nopt.clean(obj.data, this.types, typeDefs)
+
+      nopt.invalidHandler = null
+      return obj[_valid]
+    }
+  }
+
+  // fixes problems identified by validate(), accepts the 'problems' property from a thrown
+  // ErrInvalidAuth to avoid having to check everything again
+  repair (problems) {
+    if (!problems) {
+      try {
+        this.validate()
+      } catch (err) {
+        // coverage skipped here because we don't need to test re-throwing an error
+        // istanbul ignore next
+        if (err.code !== 'ERR_INVALID_AUTH') {
+          throw err
+        }
+
+        problems = err.problems
+      } finally {
+        if (!problems) {
+          problems = []
+        }
+      }
+    }
+
+    for (const problem of problems) {
+      // coverage disabled for else branch because it doesn't do anything and shouldn't
+      // istanbul ignore else
+      if (problem.action === 'delete') {
+        this.delete(problem.key, problem.where)
+      } else if (problem.action === 'rename') {
+        const raw = this.data.get(problem.where).raw?.[problem.from]
+        const calculated = this.get(problem.from, problem.where)
+        this.set(problem.to, raw || calculated, problem.where)
+        this.delete(problem.from, problem.where)
+      }
+    }
+  }
+
+  // Returns true if the value is coming directly from the source defined
+  // in default definitions, if the current value for the key config is
+  // coming from any other different source, returns false
+  isDefault (key) {
+    const [defaultType, ...types] = [...confTypes]
+    const defaultData = this.data.get(defaultType).data
+
+    return hasOwnProperty(defaultData, key)
+      && types.every(type => {
+        const typeData = this.data.get(type).data
+        return !hasOwnProperty(typeData, key)
+      })
+  }
+
+  invalidHandler (k, val, type, source, where) {
+    const typeDescription = require('./type-description.js')
+    log.warn(
+      'invalid config',
+      k + '=' + JSON.stringify(val),
+      `set in ${source}`
+    )
+    this.data.get(where)[_valid] = false
+
+    if (Array.isArray(type)) {
+      if (type.includes(typeDefs.url.type)) {
+        type = typeDefs.url.type
+      } else {
+        /* istanbul ignore if - no actual configs matching this, but
+         * path types SHOULD be handled this way, like URLs, for the
+         * same reason */
+        if (type.includes(typeDefs.path.type)) {
+          type = typeDefs.path.type
+        }
+      }
+    }
+
+    const typeDesc = typeDescription(type)
+    const mustBe = typeDesc
+      .filter(m => m !== undefined && m !== Array)
+    const msg = 'Must be' + this.#getOneOfKeywords(mustBe, typeDesc)
+    const desc = mustBe.length === 1 ? mustBe[0]
+      : [...new Set(mustBe.map(n => typeof n === 'string' ? n : JSON.stringify(n)))].join(', ')
+    log.warn('invalid config', msg, desc)
+  }
+
+  abbrevHandler (short, long) {
+    log.warn(`Expanding --${short} to --${long}. This will stop working in the next major version of npm.`)
+  }
+
+  unknownHandler (key, next) {
+    if (next) {
+      this.queueWarning(`unknown:${next}`, `"${next}" is being parsed as a normal command line argument.`)
+    }
+  }
+
+  #getOneOfKeywords (mustBe, typeDesc) {
+    let keyword
+    if (mustBe.length === 1 && typeDesc.includes(Array)) {
+      keyword = ' one or more'
+    } else if (mustBe.length > 1 && typeDesc.includes(Array)) {
+      keyword = ' one or more of:'
+    } else if (mustBe.length > 1) {
+      keyword = ' one of:'
+    } else {
+      keyword = ''
+    }
+    return keyword
+  }
+
+  #loadObject (obj, where, source, er = null) {
+    // obj is the raw data read from the file
+    const conf = this.data.get(where)
+    if (conf.source) {
+      const m = `double-loading "${where}" configs from ${source}, ` +
+        `previously loaded from ${conf.source}`
+      throw new Error(m)
+    }
+
+    if (this.sources.has(source)) {
+      const m = `double-loading config "${source}" as "${where}", ` +
+        `previously loaded as "${this.sources.get(source)}"`
+      throw new Error(m)
+    }
+
+    conf.source = source
+    this.sources.set(source, where)
+    if (er) {
+      conf.loadError = er
+      if (er.code !== 'ENOENT') {
+        log.verbose('config', `error loading ${where} config`, er)
+      }
+    } else {
+      conf.raw = obj
+      outer: for (const [key, value] of Object.entries(obj)) {
+        const k = envReplace(key, this.env)
+        const v = this.parseField(value, k)
+        if (where !== 'default') {
+          this.#checkDeprecated(k)
+          if (this.definitions[key]?.exclusive) {
+            for (const exclusive of this.definitions[key].exclusive) {
+              if (!this.isDefault(exclusive)) {
+                // when loading from env, skip only if sibling was explicitly set via CLI
+                if (where === 'env') {
+                  const cliData = this.data.get('cli').data
+                  if (Object.hasOwn(cliData, exclusive)) {
+                    continue outer
+                  }
+                }
+                throw new TypeError(`--${key} cannot be provided when using --${exclusive}`)
+              }
+            }
+          }
+        }
+        if (where !== 'default' || key === 'npm-version') {
+          this.checkUnknown(where, key)
+        }
+        conf.data[k] = v
+      }
+    }
+  }
+
+  checkUnknown (where, key) {
+    if (!this.definitions[key]) {
+      if (internalEnv.includes(key)) {
+        return
+      }
+      const hint = where !== 'cli'
+        ? ' See `npm help npmrc` for supported config options.'
+        : ''
+      if (!key.includes(':')) {
+        this.queueWarning(key, `Unknown ${where} config "${where === 'cli' ? '--' : ''}${key}". This will stop working in the next major version of npm.${hint}`)
+        return
+      }
+      const baseKey = key.split(':').pop()
+      if (!this.definitions[baseKey] && !this.nerfDarts.includes(baseKey)) {
+        this.queueWarning(baseKey, `Unknown ${where} config "${baseKey}" (${key}). This will stop working in the next major version of npm.${hint}`)
+      }
+    }
+  }
+
+  #checkDeprecated (key) {
+    if (this.deprecated[key]) {
+      log.warn('config', key, this.deprecated[key])
+    }
+  }
+
+  // Parse a field, coercing it to the best type available.
+  parseField (f, key, listElement = false) {
+    return parseField(f, key, this, listElement)
+  }
+
+  async #loadFile (file, type) {
+    // only catch the error from readFile, not from the loadObject call
+    log.silly('config', `load:file:${file}`)
+    await readFile(file, 'utf8').then(
+      data => {
+        const parsedConfig = ini.parse(data)
+        if (type === 'project' && parsedConfig.prefix) {
+          // Log error if prefix is mentioned in project .npmrc
+          /* eslint-disable-next-line max-len */
+          log.error('config', `prefix cannot be changed from project config: ${file}.`)
+        }
+        return this.#loadObject(parsedConfig, type, file)
+      },
+      er => this.#loadObject(null, type, file, er)
+    )
+  }
+
+  loadBuiltinConfig () {
+    return this.#loadFile(resolve(this.npmPath, 'npmrc'), 'builtin')
+  }
+
+  async loadProjectConfig () {
+    // the localPrefix can be set by the CLI config, but otherwise is
+    // found by walking up the folder tree. either way, we load it before
+    // we return to make sure localPrefix is set
+    await this.loadLocalPrefix()
+
+    // if we have not detected a local package json yet, try now that we
+    // have a local prefix
+    if (this.localPackage == null) {
+      this.localPackage = await fileExists(this.localPrefix, 'package.json')
+    }
+
+    if (this.#get('global') === true || this.#get('location') === 'global') {
+      this.data.get('project').source = '(global mode enabled, ignored)'
+      this.sources.set(this.data.get('project').source, 'project')
+      return
+    }
+
+    const projectFile = resolve(this.localPrefix, '.npmrc')
+    // if we're in the ~ directory, and there happens to be a node_modules
+    // folder (which is not TOO uncommon, it turns out), then we can end
+    // up loading the "project" config where the "userconfig" will be,
+    // which causes some calamities.  So, we only load project config if
+    // it doesn't match what the userconfig will be.
+    if (projectFile !== this.#get('userconfig')) {
+      return this.#loadFile(projectFile, 'project')
+    } else {
+      this.data.get('project').source = '(same as "user" config, ignored)'
+      this.sources.set(this.data.get('project').source, 'project')
+    }
+  }
+
+  async loadLocalPrefix () {
+    const cliPrefix = this.#get('prefix', 'cli')
+    if (cliPrefix) {
+      this.localPrefix = cliPrefix
+      return
+    }
+
+    const cliWorkspaces = this.#get('workspaces', 'cli')
+    const isGlobal = this.#get('global') || this.#get('location') === 'global'
+
+    for (const p of walkUp(this.cwd)) {
+      // HACK: this is an option set in tests to stop the local prefix from being set
+      // on tests that are created inside the npm repo
+      if (this.excludeNpmCwd && p === this.npmPath) {
+        break
+      }
+
+      const hasPackageJson = await fileExists(p, 'package.json')
+
+      if (!this.localPrefix && (hasPackageJson || await dirExists(p, 'node_modules'))) {
+        this.localPrefix = p
+        this.localPackage = hasPackageJson
+
+        // if workspaces are disabled, or we're in global mode, return now
+        if (cliWorkspaces === false || isGlobal) {
+          return
+        }
+
+        // otherwise, continue the loop
+        continue
+      }
+
+      if (this.localPrefix && hasPackageJson) {
+        const pkgJson = require('@npmcli/package-json')
+        // if we already set localPrefix but this dir has a package.json
+        // then we need to see if `p` is a workspace root by reading its package.json
+        // however, if reading it fails then we should just move on
+        const { content: pkg } = await pkgJson.normalize(p).catch(() => ({ content: {} }))
+        if (!pkg?.workspaces) {
+          continue
+        }
+
+        const mapWorkspaces = require('@npmcli/map-workspaces')
+        const workspaces = await mapWorkspaces({ cwd: p, pkg })
+        for (const w of workspaces.values()) {
+          if (w === this.localPrefix) {
+            // see if there's a .npmrc file in the workspace, if so log a warning
+            if (await fileExists(this.localPrefix, '.npmrc')) {
+              log.warn('config', `ignoring workspace config at ${this.localPrefix}/.npmrc`)
+            }
+
+            // set the workspace in the default layer, which allows it to be overridden easily
+            const { data } = this.data.get('default')
+            data.workspace = [this.localPrefix]
+            this.localPrefix = p
+            this.localPackage = hasPackageJson
+            log.info('config', `found workspace root at ${this.localPrefix}`)
+            // we found a root, so we return now
+            return
+          }
+        }
+      }
+    }
+
+    if (!this.localPrefix) {
+      this.localPrefix = this.cwd
+    }
+  }
+
+  loadUserConfig () {
+    return this.#loadFile(this.#get('userconfig'), 'user')
+  }
+
+  loadGlobalConfig () {
+    return this.#loadFile(this.#get('globalconfig'), 'global')
+  }
+
+  async save (where) {
+    if (!this.loaded) {
+      throw new Error('call config.load() before saving')
+    }
+    if (!confFileTypes.has(where)) {
+      throw new Error('invalid config location param: ' + where)
+    }
+
+    const conf = this.data.get(where)
+    conf[_loadError] = null
+
+    if (where === 'user') {
+      // if email is nerfed, then we want to de-nerf it
+      const nerfed = nerfDart(this.get('registry'))
+      const email = this.get(`${nerfed}:email`, 'user')
+      if (email) {
+        this.delete(`${nerfed}:email`, 'user')
+        this.set('email', email, 'user')
+      }
+    }
+
+    // We need the actual raw data before we called parseField so that we are
+    // saving the same content back to the file
+    const iniData = ini.stringify(conf.raw).trim() + '\n'
+    if (!iniData.trim()) {
+      // ignore the unlink error (eg, if file doesn't exist)
+      await unlink(conf.source).catch(() => {})
+      return
+    }
+    const dir = dirname(conf.source)
+    await mkdir(dir, { recursive: true })
+    await writeFile(conf.source, iniData, 'utf8')
+    const mode = where === 'user' ? 0o600 : 0o666
+    await chmod(conf.source, mode)
+  }
+
+  clearCredentialsByURI (uri, level = 'user') {
+    const nerfed = nerfDart(uri)
+    const def = nerfDart(this.get('registry'))
+    if (def === nerfed) {
+      this.delete(`-authtoken`, level)
+      this.delete(`_authToken`, level)
+      this.delete(`_authtoken`, level)
+      this.delete(`_auth`, level)
+      this.delete(`_password`, level)
+      this.delete(`username`, level)
+      // de-nerf email if it's nerfed to the default registry
+      const email = this.get(`${nerfed}:email`, level)
+      if (email) {
+        this.set('email', email, level)
+      }
+    }
+    this.delete(`${nerfed}:_authToken`, level)
+    this.delete(`${nerfed}:_auth`, level)
+    this.delete(`${nerfed}:_password`, level)
+    this.delete(`${nerfed}:username`, level)
+    this.delete(`${nerfed}:email`, level)
+    this.delete(`${nerfed}:certfile`, level)
+    this.delete(`${nerfed}:keyfile`, level)
+  }
+
+  setCredentialsByURI (uri, { token, username, password, certfile, keyfile }) {
+    const nerfed = nerfDart(uri)
+
+    // field that hasn't been used as documented for a LONG time,
+    // and as of npm 7.10.0, isn't used at all.  We just always
+    // send auth if we have it, only to the URIs under the nerf dart.
+    this.delete(`${nerfed}:always-auth`, 'user')
+
+    this.delete(`${nerfed}:email`, 'user')
+    if (certfile && keyfile) {
+      this.set(`${nerfed}:certfile`, certfile, 'user')
+      this.set(`${nerfed}:keyfile`, keyfile, 'user')
+      // cert/key may be used in conjunction with other credentials, thus no `else`
+    }
+    if (token) {
+      this.set(`${nerfed}:_authToken`, token, 'user')
+      this.delete(`${nerfed}:_password`, 'user')
+      this.delete(`${nerfed}:username`, 'user')
+    } else if (username || password) {
+      if (!username) {
+        throw new Error('must include username')
+      }
+      if (!password) {
+        throw new Error('must include password')
+      }
+      this.delete(`${nerfed}:_authToken`, 'user')
+      this.set(`${nerfed}:username`, username, 'user')
+      // note: not encrypted, no idea why we bothered to do this, but oh well
+      // protects against shoulder-hacks if password is memorable, I guess?
+      const encoded = Buffer.from(password, 'utf8').toString('base64')
+      this.set(`${nerfed}:_password`, encoded, 'user')
+    } else if (!certfile || !keyfile) {
+      throw new Error('No credentials to set.')
+    }
+  }
+
+  // this has to be a bit more complicated to support legacy data of all forms
+  getCredentialsByURI (uri) {
+    const nerfed = nerfDart(uri)
+    const def = nerfDart(this.get('registry'))
+    const creds = {}
+
+    // email is handled differently, it used to always be nerfed and now it never should be
+    // if it's set nerfed to the default registry, then we copy it to the unnerfed key
+    // TODO: evaluate removing 'email' from the credentials object returned here
+    const email = this.get(`${nerfed}:email`) || this.get('email')
+    if (email) {
+      if (nerfed === def) {
+        this.set('email', email, 'user')
+      }
+      creds.email = email
+    }
+
+    const certfileReg = this.get(`${nerfed}:certfile`)
+    const keyfileReg = this.get(`${nerfed}:keyfile`)
+    if (certfileReg && keyfileReg) {
+      creds.certfile = certfileReg
+      creds.keyfile = keyfileReg
+      // cert/key may be used in conjunction with other credentials, thus no `return`
+    }
+
+    const tokenReg = this.get(`${nerfed}:_authToken`)
+    if (tokenReg) {
+      creds.token = tokenReg
+      return creds
+    }
+
+    const userReg = this.get(`${nerfed}:username`)
+    const passReg = this.get(`${nerfed}:_password`)
+    if (userReg && passReg) {
+      creds.username = userReg
+      creds.password = Buffer.from(passReg, 'base64').toString('utf8')
+      const auth = `${creds.username}:${creds.password}`
+      creds.auth = Buffer.from(auth, 'utf8').toString('base64')
+      return creds
+    }
+
+    const authReg = this.get(`${nerfed}:_auth`)
+    if (authReg) {
+      const authDecode = Buffer.from(authReg, 'base64').toString('utf8')
+      const authSplit = authDecode.split(':')
+      creds.username = authSplit.shift()
+      creds.password = authSplit.join(':')
+      creds.auth = authReg
+      return creds
+    }
+
+    // at this point, nothing else is usable so just return what we do have
+    return creds
+  }
+
+  // set up the environment object we have with npm_config_* environs
+  // for all configs that are different from their default values, and
+  // set EDITOR and HOME.
+  setEnvs () {
+    setEnvs(this)
+  }
+
+  removeWarning (key) {
+    this.#warnings = this.#warnings.filter(w => w.type !== key)
+  }
+
+  getUnknownPositionals () {
+    return this.#warnings
+      .filter(w => w.type.startsWith('unknown:'))
+      .map(w => w.type.slice('unknown:'.length))
+  }
+
+  removeUnknownPositional (value) {
+    this.removeWarning(`unknown:${value}`)
+  }
+
+  queueWarning (type, ...args) {
+    if (!this.warn) {
+      this.#warnings.push({ type, args })
+    } else {
+      log.warn(...args)
+    }
+  }
+
+  logWarnings () {
+    for (const warning of this.#warnings) {
+      log.warn(...warning.args)
+    }
+    this.#warnings = []
+  }
+}
+
+const _loadError = Symbol('loadError')
+const _valid = Symbol('valid')
+
+class ConfigData {
+  #data
+  #source = null
+  #raw = null
+  constructor (parent) {
+    this.#data = Object.create(parent && parent.data)
+    this.#raw = {}
+    this[_valid] = true
+  }
+
+  get data () {
+    return this.#data
+  }
+
+  get valid () {
+    return this[_valid]
+  }
+
+  set source (s) {
+    if (this.#source) {
+      throw new Error('cannot set ConfigData source more than once')
+    }
+    this.#source = s
+  }
+
+  get source () {
+    return this.#source
+  }
+
+  set loadError (e) {
+    if (this[_loadError] || (Object.keys(this.#raw).length)) {
+      throw new Error('cannot set ConfigData loadError after load')
+    }
+    this[_loadError] = e
+  }
+
+  get loadError () {
+    return this[_loadError]
+  }
+
+  set raw (r) {
+    if (Object.keys(this.#raw).length || this[_loadError]) {
+      throw new Error('cannot set ConfigData raw after load')
+    }
+    this.#raw = r
+  }
+
+  get raw () {
+    return this.#raw
+  }
+}
+
+const getTypesFromDefinitions = (definitions) => {
+  const types = {}
+  const defaults = {}
+  const deprecated = {}
+
+  for (const [key, def] of Object.entries(definitions)) {
+    defaults[key] = def.default
+    types[key] = def.type
+    if (def.deprecated) {
+      deprecated[key] = def.deprecated.trim().replace(/\n +/, '\n')
+    }
+  }
+
+  return { types, defaults, deprecated }
+}
+
+module.exports = Config
+module.exports.getTypesFromDefinitions = getTypesFromDefinitions

node/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
+}

node/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

node/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

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

@@ -0,0 +1,57 @@
+{
+  "name": "@npmcli/config",
+  "version": "10.8.1",
+  "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.29.0",
+    "tap": "^16.3.8"
+  },
+  "dependencies": {
+    "@npmcli/map-workspaces": "^5.0.0",
+    "@npmcli/package-json": "^7.0.0",
+    "ci-info": "^4.0.0",
+    "ini": "^6.0.0",
+    "nopt": "^9.0.0",
+    "proc-log": "^6.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.29.0",
+    "content": "../../scripts/template-oss/index.js"
+  }
+}

node/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.

node/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

node/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,
+}

node/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.

node/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}`
+  }
+}

node/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

node/node_modules/npm/node_modules/@npmcli/fs/lib/cp/polyfill.js

@@ -0,0 +1,428 @@
+// this file is a modified version of the code in node 17.2.0
+// which is, in turn, a modified version of the fs-extra module on npm
+// node core changes:
+// - Use of the assert module has been replaced with core's error system.
+// - All code related to the glob dependency has been removed.
+// - Bring your own custom fs module is not currently supported.
+// - Some basic code cleanup.
+// changes here:
+// - remove all callback related code
+// - drop sync support
+// - change assertions back to non-internal methods (see options.js)
+// - throws ENOTDIR when rmdir gets an ENOENT for a path that exists in Windows
+'use strict'
+
+const {
+  ERR_FS_CP_DIR_TO_NON_DIR,
+  ERR_FS_CP_EEXIST,
+  ERR_FS_CP_EINVAL,
+  ERR_FS_CP_FIFO_PIPE,
+  ERR_FS_CP_NON_DIR_TO_DIR,
+  ERR_FS_CP_SOCKET,
+  ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY,
+  ERR_FS_CP_UNKNOWN,
+  ERR_FS_EISDIR,
+  ERR_INVALID_ARG_TYPE,
+} = require('./errors.js')
+const {
+  constants: {
+    errno: {
+      EEXIST,
+      EISDIR,
+      EINVAL,
+      ENOTDIR,
+    },
+  },
+} = require('os')
+const {
+  chmod,
+  copyFile,
+  lstat,
+  mkdir,
+  readdir,
+  readlink,
+  stat,
+  symlink,
+  unlink,
+  utimes,
+} = require('fs/promises')
+const {
+  dirname,
+  isAbsolute,
+  join,
+  parse,
+  resolve,
+  sep,
+  toNamespacedPath,
+} = require('path')
+const { fileURLToPath } = require('url')
+
+const defaultOptions = {
+  dereference: false,
+  errorOnExist: false,
+  filter: undefined,
+  force: true,
+  preserveTimestamps: false,
+  recursive: false,
+}
+
+async function cp (src, dest, opts) {
+  if (opts != null && typeof opts !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE('options', ['Object'], opts)
+  }
+  return cpFn(
+    toNamespacedPath(getValidatedPath(src)),
+    toNamespacedPath(getValidatedPath(dest)),
+    { ...defaultOptions, ...opts })
+}
+
+function getValidatedPath (fileURLOrPath) {
+  const path = fileURLOrPath != null && fileURLOrPath.href
+      && fileURLOrPath.origin
+    ? fileURLToPath(fileURLOrPath)
+    : fileURLOrPath
+  return path
+}
+
+async function cpFn (src, dest, opts) {
+  // Warn about using preserveTimestamps on 32-bit node
+  // istanbul ignore next
+  if (opts.preserveTimestamps && process.arch === 'ia32') {
+    const warning = 'Using the preserveTimestamps option in 32-bit ' +
+      'node is not recommended'
+    process.emitWarning(warning, 'TimestampPrecisionWarning')
+  }
+  const stats = await checkPaths(src, dest, opts)
+  const { srcStat, destStat } = stats
+  await checkParentPaths(src, srcStat, dest)
+  if (opts.filter) {
+    return handleFilter(checkParentDir, destStat, src, dest, opts)
+  }
+  return checkParentDir(destStat, src, dest, opts)
+}
+
+async function checkPaths (src, dest, opts) {
+  const { 0: srcStat, 1: destStat } = await getStats(src, dest, opts)
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      throw new ERR_FS_CP_EINVAL({
+        message: 'src and dest cannot be the same',
+        path: dest,
+        syscall: 'cp',
+        errno: EINVAL,
+      })
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new ERR_FS_CP_DIR_TO_NON_DIR({
+        message: `cannot overwrite directory ${src} ` +
+            `with non-directory ${dest}`,
+        path: dest,
+        syscall: 'cp',
+        errno: EISDIR,
+      })
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new ERR_FS_CP_NON_DIR_TO_DIR({
+        message: `cannot overwrite non-directory ${src} ` +
+            `with directory ${dest}`,
+        path: dest,
+        syscall: 'cp',
+        errno: ENOTDIR,
+      })
+    }
+  }
+
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new ERR_FS_CP_EINVAL({
+      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  }
+  return { srcStat, destStat }
+}
+
+function areIdentical (srcStat, destStat) {
+  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino &&
+    destStat.dev === srcStat.dev
+}
+
+function getStats (src, dest, opts) {
+  const statFunc = opts.dereference ?
+    (file) => stat(file, { bigint: true }) :
+    (file) => lstat(file, { bigint: true })
+  return Promise.all([
+    statFunc(src),
+    statFunc(dest).catch((err) => {
+      // istanbul ignore next: unsure how to cover.
+      if (err.code === 'ENOENT') {
+        return null
+      }
+      // istanbul ignore next: unsure how to cover.
+      throw err
+    }),
+  ])
+}
+
+async function checkParentDir (destStat, src, dest, opts) {
+  const destParent = dirname(dest)
+  const dirExists = await pathExists(destParent)
+  if (dirExists) {
+    return getStatsForCopy(destStat, src, dest, opts)
+  }
+  await mkdir(destParent, { recursive: true })
+  return getStatsForCopy(destStat, src, dest, opts)
+}
+
+function pathExists (dest) {
+  return stat(dest).then(
+    () => true,
+    // istanbul ignore next: not sure when this would occur
+    (err) => (err.code === 'ENOENT' ? false : Promise.reject(err)))
+}
+
+// Recursively check if dest parent is a subdirectory of src.
+// It works for all file types including symlinks since it
+// checks the src and dest inodes. It starts from the deepest
+// parent and stops once it reaches the src parent or the root path.
+async function checkParentPaths (src, srcStat, dest) {
+  const srcParent = resolve(dirname(src))
+  const destParent = resolve(dirname(dest))
+  if (destParent === srcParent || destParent === parse(destParent).root) {
+    return
+  }
+  let destStat
+  try {
+    destStat = await stat(destParent, { bigint: true })
+  } catch (err) {
+    // istanbul ignore else: not sure when this would occur
+    if (err.code === 'ENOENT') {
+      return
+    }
+    // istanbul ignore next: not sure when this would occur
+    throw err
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new ERR_FS_CP_EINVAL({
+      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  }
+  return checkParentPaths(src, srcStat, destParent)
+}
+
+const normalizePathToArray = (path) =>
+  resolve(path).split(sep).filter(Boolean)
+
+// Return true if dest is a subdir of src, otherwise false.
+// It only checks the path strings.
+function isSrcSubdir (src, dest) {
+  const srcArr = normalizePathToArray(src)
+  const destArr = normalizePathToArray(dest)
+  return srcArr.every((cur, i) => destArr[i] === cur)
+}
+
+async function handleFilter (onInclude, destStat, src, dest, opts, cb) {
+  const include = await opts.filter(src, dest)
+  if (include) {
+    return onInclude(destStat, src, dest, opts, cb)
+  }
+}
+
+function startCopy (destStat, src, dest, opts) {
+  if (opts.filter) {
+    return handleFilter(getStatsForCopy, destStat, src, dest, opts)
+  }
+  return getStatsForCopy(destStat, src, dest, opts)
+}
+
+async function getStatsForCopy (destStat, src, dest, opts) {
+  const statFn = opts.dereference ? stat : lstat
+  const srcStat = await statFn(src)
+  // istanbul ignore else: can't portably test FIFO
+  if (srcStat.isDirectory() && opts.recursive) {
+    return onDir(srcStat, destStat, src, dest, opts)
+  } else if (srcStat.isDirectory()) {
+    throw new ERR_FS_EISDIR({
+      message: `${src} is a directory (not copied)`,
+      path: src,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  } else if (srcStat.isFile() ||
+            srcStat.isCharacterDevice() ||
+            srcStat.isBlockDevice()) {
+    return onFile(srcStat, destStat, src, dest, opts)
+  } else if (srcStat.isSymbolicLink()) {
+    return onLink(destStat, src, dest)
+  } else if (srcStat.isSocket()) {
+    throw new ERR_FS_CP_SOCKET({
+      message: `cannot copy a socket file: ${dest}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  } else if (srcStat.isFIFO()) {
+    throw new ERR_FS_CP_FIFO_PIPE({
+      message: `cannot copy a FIFO pipe: ${dest}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  }
+  // istanbul ignore next: should be unreachable
+  throw new ERR_FS_CP_UNKNOWN({
+    message: `cannot copy an unknown file type: ${dest}`,
+    path: dest,
+    syscall: 'cp',
+    errno: EINVAL,
+  })
+}
+
+function onFile (srcStat, destStat, src, dest, opts) {
+  if (!destStat) {
+    return _copyFile(srcStat, src, dest, opts)
+  }
+  return mayCopyFile(srcStat, src, dest, opts)
+}
+
+async function mayCopyFile (srcStat, src, dest, opts) {
+  if (opts.force) {
+    await unlink(dest)
+    return _copyFile(srcStat, src, dest, opts)
+  } else if (opts.errorOnExist) {
+    throw new ERR_FS_CP_EEXIST({
+      message: `${dest} already exists`,
+      path: dest,
+      syscall: 'cp',
+      errno: EEXIST,
+    })
+  }
+}
+
+async function _copyFile (srcStat, src, dest, opts) {
+  await copyFile(src, dest)
+  if (opts.preserveTimestamps) {
+    return handleTimestampsAndMode(srcStat.mode, src, dest)
+  }
+  return setDestMode(dest, srcStat.mode)
+}
+
+async function handleTimestampsAndMode (srcMode, src, dest) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) {
+    await makeFileWritable(dest, srcMode)
+    return setDestTimestampsAndMode(srcMode, src, dest)
+  }
+  return setDestTimestampsAndMode(srcMode, src, dest)
+}
+
+function fileIsNotWritable (srcMode) {
+  return (srcMode & 0o200) === 0
+}
+
+function makeFileWritable (dest, srcMode) {
+  return setDestMode(dest, srcMode | 0o200)
+}
+
+async function setDestTimestampsAndMode (srcMode, src, dest) {
+  await setDestTimestamps(src, dest)
+  return setDestMode(dest, srcMode)
+}
+
+function setDestMode (dest, srcMode) {
+  return chmod(dest, srcMode)
+}
+
+async function setDestTimestamps (src, dest) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  const updatedSrcStat = await stat(src)
+  return utimes(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
+}
+
+function onDir (srcStat, destStat, src, dest, opts) {
+  if (!destStat) {
+    return mkDirAndCopy(srcStat.mode, src, dest, opts)
+  }
+  return copyDir(src, dest, opts)
+}
+
+async function mkDirAndCopy (srcMode, src, dest, opts) {
+  await mkdir(dest)
+  await copyDir(src, dest, opts)
+  return setDestMode(dest, srcMode)
+}
+
+async function copyDir (src, dest, opts) {
+  const dir = await readdir(src)
+  for (let i = 0; i < dir.length; i++) {
+    const item = dir[i]
+    const srcItem = join(src, item)
+    const destItem = join(dest, item)
+    const { destStat } = await checkPaths(srcItem, destItem, opts)
+    await startCopy(destStat, srcItem, destItem, opts)
+  }
+}
+
+async function onLink (destStat, src, dest) {
+  let resolvedSrc = await readlink(src)
+  if (!isAbsolute(resolvedSrc)) {
+    resolvedSrc = resolve(dirname(src), resolvedSrc)
+  }
+  if (!destStat) {
+    return symlink(resolvedSrc, dest)
+  }
+  let resolvedDest
+  try {
+    resolvedDest = await readlink(dest)
+  } catch (err) {
+    // Dest exists and is a regular file or directory,
+    // Windows may throw UNKNOWN error. If dest already exists,
+    // fs throws error anyway, so no need to guard against it here.
+    // istanbul ignore next: can only test on windows
+    if (err.code === 'EINVAL' || err.code === 'UNKNOWN') {
+      return symlink(resolvedSrc, dest)
+    }
+    // istanbul ignore next: should not be possible
+    throw err
+  }
+  if (!isAbsolute(resolvedDest)) {
+    resolvedDest = resolve(dirname(dest), resolvedDest)
+  }
+  if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+    throw new ERR_FS_CP_EINVAL({
+      message: `cannot copy ${resolvedSrc} to a subdirectory of self ` +
+            `${resolvedDest}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  }
+  // Do not copy if src is a subdir of dest since unlinking
+  // dest in this case would result in removing src contents
+  // and therefore a broken symlink would be created.
+  const srcStat = await stat(src)
+  if (srcStat.isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+    throw new ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY({
+      message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
+      path: dest,
+      syscall: 'cp',
+      errno: EINVAL,
+    })
+  }
+  return copyLink(resolvedSrc, dest)
+}
+
+async function copyLink (resolvedSrc, dest) {
+  await unlink(dest)
+  return symlink(resolvedSrc, dest)
+}
+
+module.exports = cp

node/node_modules/npm/node_modules/@npmcli/fs/lib/index.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const cp = require('./cp/index.js')
+const withTempDir = require('./with-temp-dir.js')
+const readdirScoped = require('./readdir-scoped.js')
+const moveFile = require('./move-file.js')
+
+module.exports = {
+  cp,
+  withTempDir,
+  readdirScoped,
+  moveFile,
+}

node/node_modules/npm/node_modules/@npmcli/fs/lib/move-file.js

@@ -0,0 +1,78 @@
+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

node/node_modules/npm/node_modules/@npmcli/fs/lib/readdir-scoped.js

@@ -0,0 +1,20 @@
+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

node/node_modules/npm/node_modules/@npmcli/fs/lib/with-temp-dir.js

@@ -0,0 +1,39 @@
+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

node/node_modules/npm/node_modules/@npmcli/fs/package.json

@@ -0,0 +1,54 @@
+{
+  "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/**"
+    ]
+  }
+}

node/node_modules/npm/node_modules/@npmcli/git/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 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 THE NPM DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE 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.

node/node_modules/npm/node_modules/@npmcli/git/lib/clone.js

@@ -0,0 +1,172 @@
+// The goal here is to minimize both git workload and
+// the number of refs we download over the network.
+//
+// Every method ends up with the checked out working dir
+// at the specified ref, and resolves with the git sha.
+
+// Only certain whitelisted hosts get shallow cloning.
+// Many hosts (including GHE) don't always support it.
+// A failed shallow fetch takes a LOT longer than a full
+// fetch in most cases, so we skip it entirely.
+// Set opts.gitShallow = true/false to force this behavior
+// one way or the other.
+const shallowHosts = new Set([
+  'github.com',
+  'gist.github.com',
+  'gitlab.com',
+  'bitbucket.com',
+  'bitbucket.org',
+])
+// we have to use url.parse until we add the same shim that hosted-git-info has
+// to handle scp:// urls
+const { parse } = require('url') // eslint-disable-line node/no-deprecated-api
+const path = require('path')
+
+const getRevs = require('./revs.js')
+const spawn = require('./spawn.js')
+const { isWindows } = require('./utils.js')
+
+const pickManifest = require('npm-pick-manifest')
+const fs = require('fs/promises')
+
+module.exports = (repo, ref = 'HEAD', target = null, opts = {}) =>
+  getRevs(repo, opts).then(revs => clone(
+    repo,
+    revs,
+    ref,
+    resolveRef(revs, ref, opts),
+    target || defaultTarget(repo, opts.cwd),
+    opts
+  ))
+
+const maybeShallow = (repo, opts) => {
+  if (opts.gitShallow === false || opts.gitShallow) {
+    return opts.gitShallow
+  }
+  return shallowHosts.has(parse(repo).host)
+}
+
+const defaultTarget = (repo, /* istanbul ignore next */ cwd = process.cwd()) =>
+  path.resolve(cwd, path.basename(repo.replace(/[/\\]?\.git$/, '')))
+
+const clone = (repo, revs, ref, revDoc, target, opts) => {
+  if (!revDoc) {
+    return unresolved(repo, ref, target, opts)
+  }
+  if (revDoc.sha === revs.refs.HEAD.sha) {
+    return plain(repo, revDoc, target, opts)
+  }
+  if (revDoc.type === 'tag' || revDoc.type === 'branch') {
+    return branch(repo, revDoc, target, opts)
+  }
+  return other(repo, revDoc, target, opts)
+}
+
+const resolveRef = (revs, ref, opts) => {
+  const { spec = {} } = opts
+  ref = spec.gitCommittish || ref
+  /* istanbul ignore next - will fail anyway, can't pull */
+  if (!revs) {
+    return null
+  }
+  if (spec.gitRange) {
+    return pickManifest(revs, spec.gitRange, opts)
+  }
+  if (!ref) {
+    return revs.refs.HEAD
+  }
+  if (revs.refs[ref]) {
+    return revs.refs[ref]
+  }
+  if (revs.shas[ref]) {
+    return revs.refs[revs.shas[ref][0]]
+  }
+  return null
+}
+
+// pull request or some other kind of advertised ref
+const other = (repo, revDoc, target, opts) => {
+  const shallow = maybeShallow(repo, opts)
+
+  const fetchOrigin = ['fetch', 'origin', revDoc.rawRef]
+    .concat(shallow ? ['--depth=1'] : [])
+
+  const git = (args) => spawn(args, { ...opts, cwd: target })
+  return fs.mkdir(target, { recursive: true })
+    .then(() => git(['init']))
+    .then(() => isWindows(opts)
+      ? git(['config', '--local', '--add', 'core.longpaths', 'true'])
+      : null)
+    .then(() => git(['remote', 'add', 'origin', repo]))
+    .then(() => git(fetchOrigin))
+    .then(() => git(['checkout', revDoc.sha]))
+    .then(() => updateSubmodules(target, opts))
+    .then(() => revDoc.sha)
+}
+
+// tag or branches.  use -b
+const branch = (repo, revDoc, target, opts) => {
+  const args = [
+    'clone',
+    '-b',
+    revDoc.ref,
+    repo,
+    target,
+    '--recurse-submodules',
+  ]
+  if (maybeShallow(repo, opts)) {
+    args.push('--depth=1')
+  }
+  if (isWindows(opts)) {
+    args.push('--config', 'core.longpaths=true')
+  }
+  return spawn(args, opts).then(() => revDoc.sha)
+}
+
+// just the head.  clone it
+const plain = (repo, revDoc, target, opts) => {
+  const args = [
+    'clone',
+    repo,
+    target,
+    '--recurse-submodules',
+  ]
+  if (maybeShallow(repo, opts)) {
+    args.push('--depth=1')
+  }
+  if (isWindows(opts)) {
+    args.push('--config', 'core.longpaths=true')
+  }
+  return spawn(args, opts).then(() => revDoc.sha)
+}
+
+const updateSubmodules = async (target, opts) => {
+  const hasSubmodules = await fs.stat(`${target}/.gitmodules`)
+    .then(() => true)
+    .catch(() => false)
+  if (!hasSubmodules) {
+    return null
+  }
+  return spawn([
+    'submodule',
+    'update',
+    '-q',
+    '--init',
+    '--recursive',
+  ], { ...opts, cwd: target })
+}
+
+const unresolved = (repo, ref, target, opts) => {
+  // can't do this one shallowly, because the ref isn't advertised
+  // but we can avoid checking out the working dir twice, at least
+  const lp = isWindows(opts) ? ['--config', 'core.longpaths=true'] : []
+  const cloneArgs = ['clone', '--mirror', '-q', repo, target + '/.git']
+  const git = (args) => spawn(args, { ...opts, cwd: target })
+  return fs.mkdir(target, { recursive: true })
+    .then(() => git(cloneArgs.concat(lp)))
+    .then(() => git(['init']))
+    .then(() => git(['checkout', ref]))
+    .then(() => updateSubmodules(target, opts))
+    .then(() => git(['rev-parse', '--revs-only', 'HEAD']))
+    .then(({ stdout }) => stdout.trim())
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/errors.js

@@ -0,0 +1,36 @@
+
+const maxRetry = 3
+
+class GitError extends Error {
+  shouldRetry () {
+    return false
+  }
+}
+
+class GitConnectionError extends GitError {
+  constructor () {
+    super('A git connection error occurred')
+  }
+
+  shouldRetry (number) {
+    return number < maxRetry
+  }
+}
+
+class GitPathspecError extends GitError {
+  constructor () {
+    super('The git reference could not be found')
+  }
+}
+
+class GitUnknownError extends GitError {
+  constructor () {
+    super('An unknown git error occurred')
+  }
+}
+
+module.exports = {
+  GitConnectionError,
+  GitPathspecError,
+  GitUnknownError,
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/find.js

@@ -0,0 +1,15 @@
+const is = require('./is.js')
+const { dirname } = require('path')
+
+module.exports = async ({ cwd = process.cwd(), root } = {}) => {
+  while (true) {
+    if (await is({ cwd })) {
+      return cwd
+    }
+    const next = dirname(cwd)
+    if (cwd === root || cwd === next) {
+      return null
+    }
+    cwd = next
+  }
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/index.js

@@ -0,0 +1,9 @@
+module.exports = {
+  clone: require('./clone.js'),
+  revs: require('./revs.js'),
+  spawn: require('./spawn.js'),
+  is: require('./is.js'),
+  find: require('./find.js'),
+  isClean: require('./is-clean.js'),
+  errors: require('./errors.js'),
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/is-clean.js

@@ -0,0 +1,6 @@
+const spawn = require('./spawn.js')
+
+module.exports = (opts = {}) =>
+  spawn(['status', '--porcelain=v1', '-uno'], opts)
+    .then(res => !res.stdout.trim().split(/\r?\n+/)
+      .map(l => l.trim()).filter(l => l).length)

node/node_modules/npm/node_modules/@npmcli/git/lib/is.js

@@ -0,0 +1,4 @@
+// not an airtight indicator, but a good gut-check to even bother trying
+const { stat } = require('fs/promises')
+module.exports = ({ cwd = process.cwd() } = {}) =>
+  stat(cwd + '/.git').then(() => true, () => false)

node/node_modules/npm/node_modules/@npmcli/git/lib/lines-to-revs.js

@@ -0,0 +1,147 @@
+// turn an array of lines from `git ls-remote` into a thing
+// vaguely resembling a packument, where docs are a resolved ref
+
+const semver = require('semver')
+
+module.exports = lines => finish(lines.reduce(linesToRevsReducer, {
+  versions: {},
+  'dist-tags': {},
+  refs: {},
+  shas: {},
+}))
+
+const finish = revs => distTags(shaList(peelTags(revs)))
+
+// We can check out shallow clones on specific SHAs if we have a ref
+const shaList = revs => {
+  Object.keys(revs.refs).forEach(ref => {
+    const doc = revs.refs[ref]
+    if (!revs.shas[doc.sha]) {
+      revs.shas[doc.sha] = [ref]
+    } else {
+      revs.shas[doc.sha].push(ref)
+    }
+  })
+  return revs
+}
+
+// Replace any tags with their ^{} counterparts, if those exist
+const peelTags = revs => {
+  Object.keys(revs.refs).filter(ref => ref.endsWith('^{}')).forEach(ref => {
+    const peeled = revs.refs[ref]
+    const unpeeled = revs.refs[ref.replace(/\^\{\}$/, '')]
+    if (unpeeled) {
+      unpeeled.sha = peeled.sha
+      delete revs.refs[ref]
+    }
+  })
+  return revs
+}
+
+const distTags = revs => {
+  // not entirely sure what situations would result in an
+  // ichabod repo, but best to be careful in Sleepy Hollow anyway
+  const HEAD = revs.refs.HEAD || /* istanbul ignore next */ {}
+  const versions = Object.keys(revs.versions)
+  versions.forEach(v => {
+    // simulate a dist-tags with latest pointing at the
+    // 'latest' branch if one exists and is a version,
+    // or HEAD if not.
+    const ver = revs.versions[v]
+    if (revs.refs.latest && ver.sha === revs.refs.latest.sha) {
+      revs['dist-tags'].latest = v
+    } else if (ver.sha === HEAD.sha) {
+      revs['dist-tags'].HEAD = v
+      if (!revs.refs.latest) {
+        revs['dist-tags'].latest = v
+      }
+    }
+  })
+  return revs
+}
+
+const refType = ref => {
+  if (ref.startsWith('refs/tags/')) {
+    return 'tag'
+  }
+  if (ref.startsWith('refs/heads/')) {
+    return 'branch'
+  }
+  if (ref.startsWith('refs/pull/')) {
+    return 'pull'
+  }
+  if (ref === 'HEAD') {
+    return 'head'
+  }
+  // Could be anything, ignore for now
+  /* istanbul ignore next */
+  return 'other'
+}
+
+// return the doc, or null if we should ignore it.
+const lineToRevDoc = line => {
+  const split = line.trim().split(/\s+/, 2)
+  if (split.length < 2) {
+    return null
+  }
+
+  const sha = split[0].trim()
+  const rawRef = split[1].trim()
+  const type = refType(rawRef)
+
+  if (type === 'tag') {
+    // refs/tags/foo^{} is the 'peeled tag', ie the commit
+    // that is tagged by refs/tags/foo they resolve to the same
+    // content, just different objects in git's data structure.
+    // But, we care about the thing the tag POINTS to, not the tag
+    // object itself, so we only look at the peeled tag refs, and
+    // ignore the pointer.
+    // For now, though, we have to save both, because some tags
+    // don't have peels, if they were not annotated.
+    const ref = rawRef.slice('refs/tags/'.length)
+    return { sha, ref, rawRef, type }
+  }
+
+  if (type === 'branch') {
+    const ref = rawRef.slice('refs/heads/'.length)
+    return { sha, ref, rawRef, type }
+  }
+
+  if (type === 'pull') {
+    // NB: merged pull requests installable with #pull/123/merge
+    // for the merged pr, or #pull/123 for the PR head
+    const ref = rawRef.slice('refs/'.length).replace(/\/head$/, '')
+    return { sha, ref, rawRef, type }
+  }
+
+  if (type === 'head') {
+    const ref = 'HEAD'
+    return { sha, ref, rawRef, type }
+  }
+
+  // at this point, all we can do is leave the ref un-munged
+  return { sha, ref: rawRef, rawRef, type }
+}
+
+const linesToRevsReducer = (revs, line) => {
+  const doc = lineToRevDoc(line)
+
+  if (!doc) {
+    return revs
+  }
+
+  revs.refs[doc.ref] = doc
+  revs.refs[doc.rawRef] = doc
+
+  if (doc.type === 'tag') {
+    // try to pull a semver value out of tags like `release-v1.2.3`
+    // which is a pretty common pattern.
+    const match = !doc.ref.endsWith('^{}') &&
+      doc.ref.match(/v?(\d+\.\d+\.\d+(?:[-+].+)?)$/)
+    if (match && semver.valid(match[1], true)) {
+      revs.versions[semver.clean(match[1], true)] = doc
+    }
+  }
+
+  return revs
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/make-error.js

@@ -0,0 +1,33 @@
+const {
+  GitConnectionError,
+  GitPathspecError,
+  GitUnknownError,
+} = require('./errors.js')
+
+const connectionErrorRe = new RegExp([
+  'remote error: Internal Server Error',
+  'The remote end hung up unexpectedly',
+  'Connection timed out',
+  'Operation timed out',
+  'Failed to connect to .* Timed out',
+  'Connection reset by peer',
+  'SSL_ERROR_SYSCALL',
+  'The requested URL returned error: 503',
+].join('|'))
+
+const missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/
+
+function makeError (er) {
+  const message = er.stderr
+  let gitEr
+  if (connectionErrorRe.test(message)) {
+    gitEr = new GitConnectionError(message)
+  } else if (missingPathspecRe.test(message)) {
+    gitEr = new GitPathspecError(message)
+  } else {
+    gitEr = new GitUnknownError(message)
+  }
+  return Object.assign(gitEr, er)
+}
+
+module.exports = makeError

node/node_modules/npm/node_modules/@npmcli/git/lib/opts.js

@@ -0,0 +1,57 @@
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const ini = require('ini')
+
+const gitConfigPath = path.join(os.homedir(), '.gitconfig')
+
+let cachedConfig = null
+
+// Function to load and cache the git config
+const loadGitConfig = () => {
+  if (cachedConfig === null) {
+    try {
+      cachedConfig = {}
+      if (fs.existsSync(gitConfigPath)) {
+        const configContent = fs.readFileSync(gitConfigPath, 'utf-8')
+        cachedConfig = ini.parse(configContent)
+      }
+    } catch (error) {
+      cachedConfig = {}
+    }
+  }
+  return cachedConfig
+}
+
+const checkGitConfigs = () => {
+  const config = loadGitConfig()
+  return {
+    sshCommandSetInConfig: config?.core?.sshCommand !== undefined,
+    askPassSetInConfig: config?.core?.askpass !== undefined,
+  }
+}
+
+const sshCommandSetInEnv = process.env.GIT_SSH_COMMAND !== undefined
+const askPassSetInEnv = process.env.GIT_ASKPASS !== undefined
+const { sshCommandSetInConfig, askPassSetInConfig } = checkGitConfigs()
+
+// Values we want to set if they're not already defined by the end user
+// This defaults to accepting new ssh host key fingerprints
+const finalGitEnv = {
+  ...(askPassSetInEnv || askPassSetInConfig ? {} : {
+    GIT_ASKPASS: 'echo',
+  }),
+  ...(sshCommandSetInEnv || sshCommandSetInConfig ? {} : {
+    GIT_SSH_COMMAND: 'ssh -oStrictHostKeyChecking=accept-new',
+  }),
+}
+
+module.exports = (opts = {}) => ({
+  stdioString: true,
+  ...opts,
+  shell: false,
+  env: opts.env || { ...finalGitEnv, ...process.env },
+})
+
+// Export the loadGitConfig function for testing
+module.exports.loadGitConfig = loadGitConfig

node/node_modules/npm/node_modules/@npmcli/git/lib/revs.js

@@ -0,0 +1,22 @@
+const spawn = require('./spawn.js')
+const { LRUCache } = require('lru-cache')
+const linesToRevs = require('./lines-to-revs.js')
+
+const revsCache = new LRUCache({
+  max: 100,
+  ttl: 5 * 60 * 1000,
+})
+
+module.exports = async (repo, opts = {}) => {
+  if (!opts.noGitRevCache) {
+    const cached = revsCache.get(repo)
+    if (cached) {
+      return cached
+    }
+  }
+
+  const { stdout } = await spawn(['ls-remote', repo], opts)
+  const revs = linesToRevs(stdout.trim().split('\n'))
+  revsCache.set(repo, revs)
+  return revs
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/spawn.js

@@ -0,0 +1,44 @@
+const spawn = require('@npmcli/promise-spawn')
+const { promiseRetry } = require('@gar/promise-retry')
+const { log } = require('proc-log')
+const makeError = require('./make-error.js')
+const makeOpts = require('./opts.js')
+
+module.exports = (gitArgs, opts = {}) => {
+  const whichGit = require('./which.js')
+  const gitPath = whichGit(opts)
+
+  if (gitPath instanceof Error) {
+    return Promise.reject(gitPath)
+  }
+
+  // undocumented option, mostly only here for tests
+  const args = opts.allowReplace || gitArgs[0] === '--no-replace-objects'
+    ? gitArgs
+    : ['--no-replace-objects', ...gitArgs]
+
+  let retryOpts = opts.retry
+  if (retryOpts === null || retryOpts === undefined) {
+    retryOpts = {
+      retries: opts.fetchRetries || 2,
+      factor: opts.fetchRetryFactor || 10,
+      maxTimeout: opts.fetchRetryMaxtimeout || 60000,
+      minTimeout: opts.fetchRetryMintimeout || 1000,
+    }
+  }
+  return promiseRetry((retryFn, number) => {
+    if (number !== 1) {
+      log.silly('git', `Retrying git command: ${
+        args.join(' ')} attempt # ${number}`)
+    }
+
+    return spawn(gitPath, args, makeOpts(opts))
+      .catch(er => {
+        const gitError = makeError(er)
+        if (!gitError.shouldRetry(number)) {
+          throw gitError
+        }
+        retryFn(gitError)
+      })
+  }, retryOpts)
+}

node/node_modules/npm/node_modules/@npmcli/git/lib/utils.js

@@ -0,0 +1,3 @@
+const isWindows = opts => (opts.fakePlatform || process.platform) === 'win32'
+
+exports.isWindows = isWindows

node/node_modules/npm/node_modules/@npmcli/git/lib/which.js

@@ -0,0 +1,18 @@
+const which = require('which')
+
+let gitPath
+try {
+  gitPath = which.sync('git')
+} catch {
+  // ignore errors
+}
+
+module.exports = (opts = {}) => {
+  if (opts.git) {
+    return opts.git
+  }
+  if (!gitPath || opts.git === false) {
+    return Object.assign(new Error('No git binary found in $PATH'), { code: 'ENOGIT' })
+  }
+  return gitPath
+}

node/node_modules/npm/node_modules/@npmcli/git/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@npmcli/git",
+  "version": "7.0.2",
+  "main": "lib/index.js",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "description": "a util for spawning git from npm CLI contexts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/git.git"
+  },
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "scripts": {
+    "lint": "npm run eslint",
+    "snap": "tap",
+    "test": "tap",
+    "posttest": "npm run lint",
+    "postlint": "template-oss-check",
+    "lintfix": "npm run eslint -- --fix",
+    "template-oss-apply": "template-oss-apply --force",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+  },
+  "tap": {
+    "timeout": 600,
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.0",
+    "@npmcli/template-oss": "4.24.1",
+    "npm-package-arg": "^13.0.0",
+    "slash": "^3.0.0",
+    "tap": "^16.0.1"
+  },
+  "dependencies": {
+    "@gar/promise-retry": "^1.0.0",
+    "@npmcli/promise-spawn": "^9.0.0",
+    "ini": "^6.0.0",
+    "lru-cache": "^11.2.1",
+    "npm-pick-manifest": "^11.0.1",
+    "proc-log": "^6.0.0",
+    "semver": "^7.3.5",
+    "which": "^6.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.24.1",
+    "publish": true
+  }
+}

node/node_modules/npm/node_modules/@npmcli/installed-package-contents/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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.

node/node_modules/npm/node_modules/@npmcli/installed-package-contents/README.md

@@ -0,0 +1,109 @@
+# @npmcli/installed-package-contents
+
+Get the list of files installed in a package in node_modules, including
+bundled dependencies.
+
+This is useful if you want to remove a package node from the tree _without_
+removing its child nodes, for example to extract a new version of the
+dependency into place safely.
+
+It's sort of the reflection of [npm-packlist](http://npm.im/npm-packlist),
+but for listing out the _installed_ files rather than the files that _will_
+be installed.  This is of course a much simpler operation, because we don't
+have to handle ignore files or package.json `files` lists.
+
+## USAGE
+
+```js
+// programmatic usage
+const pkgContents = require('@npmcli/installed-package-contents')
+
+pkgContents({ path: 'node_modules/foo', depth: 1 }).then(files => {
+  // files is an array of items that need to be passed to
+  // rimraf or moved out of the way to make the folder empty
+  // if foo bundled dependencies, those will be included.
+  // It will not traverse into child directories, because we set
+  // depth:1 in the options.
+  // If the folder doesn't exist, this returns an empty array.
+})
+
+pkgContents({ path: 'node_modules/foo', depth: Infinity }).then(files => {
+  // setting depth:Infinity tells it to keep walking forever
+  // until it hits something that isn't a directory, so we'll
+  // just get the list of all files, but not their containing
+  // directories.
+})
+```
+
+As a CLI:
+
+```bash
+$ installed-package-contents node_modules/bundle-some -d1
+node_modules/.bin/some
+node_modules/bundle-some/package.json
+node_modules/bundle-some/node_modules/@scope/baz
+node_modules/bundle-some/node_modules/.bin/foo
+node_modules/bundle-some/node_modules/foo
+```
+
+CLI options:
+
+```
+Usage:
+  installed-package-contents <path> [-d<n> --depth=<n>]
+
+Lists the files installed for a package specified by <path>.
+
+Options:
+  -d<n> --depth=<n>   Provide a numeric value ("Infinity" is allowed)
+                      to specify how deep in the file tree to traverse.
+                      Default=1
+  -h --help           Show this usage information
+```
+
+## OPTIONS
+
+* `depth` Number, default `1`.  How deep to traverse through folders to get
+    contents.  Typically you'd want to set this to either `1` (to get the
+    surface files and folders) or `Infinity` (to get all files), but any
+    other positive number is supported as well.  If set to `0` or a
+    negative number, returns the path provided and (if it is a package) its
+    set of linked bins.
+* `path` Required.  Path to the package in `node_modules` where traversal
+    should begin.
+
+## RETURN VALUE
+
+A Promise that resolves to an array of fully-resolved files and folders
+matching the criteria.  This includes all bundled dependencies in
+`node_modules`, and any linked executables in `node_modules/.bin` that the
+package caused to be installed.
+
+An empty or missing package folder will return an empty array.  Empty
+directories _within_ package contents are listed, even if the `depth`
+argument would cause them to be traversed into.
+
+## CAVEAT
+
+If using this module to generate a list of files that should be recursively
+removed to clear away the package, note that this will leave empty
+directories behind in certain cases:
+
+- If all child packages are bundled dependencies, then the
+    `node_modules` folder will remain.
+- If all child packages within a given scope were bundled dependencies,
+    then the `node_modules/@scope` folder will remain.
+- If all linked bin scripts were removed, then an empty `node_modules/.bin`
+    folder will remain.
+
+In the interest of speed and algorithmic complexity, this module does _not_
+do a subsequent readdir to see if it would remove all directory entries,
+though it would be easier to look at if it returned `node_modules` or
+`.bin` in that case rather than the contents.  However, if the intent is to
+pass these arguments to `rimraf`, it hardly makes sense to do _two_
+`readdir` calls just so that we can have the luxury of having to make a
+third.
+
+Since the primary use case is to delete a package's contents so that they
+can be re-filled with a new version of that package, this caveat does not
+pose a problem.  Empty directories are already ignored by both npm and git.

node/node_modules/npm/node_modules/@npmcli/installed-package-contents/bin/index.js

@@ -0,0 +1,44 @@
+#! /usr/bin/env node
+
+const { relative } = require('path')
+const pkgContents = require('../')
+
+const usage = `Usage:
+  installed-package-contents <path> [-d<n> --depth=<n>]
+
+Lists the files installed for a package specified by <path>.
+
+Options:
+  -d<n> --depth=<n>   Provide a numeric value ("Infinity" is allowed)
+                      to specify how deep in the file tree to traverse.
+                      Default=1
+  -h --help           Show this usage information`
+
+const options = {}
+
+process.argv.slice(2).forEach(arg => {
+  let match
+  if ((match = arg.match(/^(?:--depth=|-d)([0-9]+|Infinity)/))) {
+    options.depth = +match[1]
+  } else if (arg === '-h' || arg === '--help') {
+    console.log(usage)
+    process.exit(0)
+  } else {
+    options.path = arg
+  }
+})
+
+if (!options.path) {
+  console.error('ERROR: no path provided')
+  console.error(usage)
+  process.exit(1)
+}
+
+const cwd = process.cwd()
+
+pkgContents(options)
+  .then(list => list.sort().forEach(p => console.log(relative(cwd, p))))
+  .catch(/* istanbul ignore next - pretty unusual */ er => {
+    console.error(er)
+    process.exit(1)
+  })

node/node_modules/npm/node_modules/@npmcli/installed-package-contents/lib/index.js

@@ -0,0 +1,181 @@
+// to GET CONTENTS for folder at PATH (which may be a PACKAGE):
+// - if PACKAGE, read path/package.json
+//   - if bins in ../node_modules/.bin, add those to result
+// - if depth >= maxDepth, add PATH to result, and finish
+// - readdir(PATH, with file types)
+// - add all FILEs in PATH to result
+// - if PARENT:
+//   - if depth < maxDepth, add GET CONTENTS of all DIRs in PATH
+//   - else, add all DIRs in PATH
+// - if no parent
+//   - if no bundled deps,
+//     - if depth < maxDepth, add GET CONTENTS of DIRs in path except
+//       node_modules
+//     - else, add all DIRs in path other than node_modules
+//   - if has bundled deps,
+//     - get list of bundled deps
+//     - add GET CONTENTS of bundled deps, PACKAGE=true, depth + 1
+
+const bundled = require('npm-bundled')
+const { readFile, readdir, stat } = require('fs/promises')
+const { resolve, basename, dirname } = require('path')
+const normalizePackageBin = require('npm-normalize-package-bin')
+
+const readPackage = ({ path, packageJsonCache }) => packageJsonCache.has(path)
+  ? Promise.resolve(packageJsonCache.get(path))
+  : readFile(path).then(json => {
+    const pkg = normalizePackageBin(JSON.parse(json))
+    packageJsonCache.set(path, pkg)
+    return pkg
+  }).catch(() => null)
+
+// just normalize bundle deps and bin, that's all we care about here.
+const normalized = Symbol('package data has been normalized')
+const rpj = ({ path, packageJsonCache }) => readPackage({ path, packageJsonCache })
+  .then(pkg => {
+    if (!pkg || pkg[normalized]) {
+      return pkg
+    }
+    if (pkg.bundledDependencies && !pkg.bundleDependencies) {
+      pkg.bundleDependencies = pkg.bundledDependencies
+      delete pkg.bundledDependencies
+    }
+    const bd = pkg.bundleDependencies
+    if (bd === true) {
+      pkg.bundleDependencies = [
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.optionalDependencies || {}),
+      ]
+    }
+    if (typeof bd === 'object' && !Array.isArray(bd)) {
+      pkg.bundleDependencies = Object.keys(bd)
+    }
+    pkg[normalized] = true
+    return pkg
+  })
+
+const pkgContents = async ({
+  path,
+  depth = 1,
+  currentDepth = 0,
+  pkg = null,
+  result = null,
+  packageJsonCache = null,
+}) => {
+  if (!result) {
+    result = new Set()
+  }
+
+  if (!packageJsonCache) {
+    packageJsonCache = new Map()
+  }
+
+  if (pkg === true) {
+    return rpj({ path: path + '/package.json', packageJsonCache })
+      .then(p => pkgContents({
+        path,
+        depth,
+        currentDepth,
+        pkg: p,
+        result,
+        packageJsonCache,
+      }))
+  }
+
+  if (pkg) {
+    // add all bins to result if they exist
+    if (pkg.bin) {
+      const dir = dirname(path)
+      const scope = basename(dir)
+      const nm = /^@.+/.test(scope) ? dirname(dir) : dir
+
+      const binFiles = []
+      Object.keys(pkg.bin).forEach(b => {
+        const base = resolve(nm, '.bin', b)
+        binFiles.push(base, base + '.cmd', base + '.ps1')
+      })
+
+      const bins = await Promise.all(
+        binFiles.map(b => stat(b).then(() => b).catch(() => null))
+      )
+      bins.filter(b => b).forEach(b => result.add(b))
+    }
+  }
+
+  if (currentDepth >= depth) {
+    result.add(path)
+    return result
+  }
+
+  // we'll need bundle list later, so get that now in parallel
+  const [dirEntries, bundleDeps] = await Promise.all([
+    readdir(path, { withFileTypes: true }),
+    currentDepth === 0 && pkg && pkg.bundleDependencies
+      ? bundled({ path, packageJsonCache }) : null,
+  ]).catch(() => [])
+
+  // not a thing, probably a missing folder
+  if (!dirEntries) {
+    return result
+  }
+
+  // empty folder, just add the folder itself to the result
+  if (!dirEntries.length && !bundleDeps && currentDepth !== 0) {
+    result.add(path)
+    return result
+  }
+
+  const recursePromises = []
+
+  for (const entry of dirEntries) {
+    const p = resolve(path, entry.name)
+    if (entry.isDirectory() === false) {
+      result.add(p)
+      continue
+    }
+
+    if (currentDepth !== 0 || entry.name !== 'node_modules') {
+      if (currentDepth < depth - 1) {
+        recursePromises.push(pkgContents({
+          path: p,
+          packageJsonCache,
+          depth,
+          currentDepth: currentDepth + 1,
+          result,
+        }))
+      } else {
+        result.add(p)
+      }
+      continue
+    }
+  }
+
+  if (bundleDeps) {
+    // bundle deps are all folders
+    // we always recurse to get pkg bins, but if currentDepth is too high,
+    // it'll return early before walking their contents.
+    recursePromises.push(...bundleDeps.map(dep => {
+      const p = resolve(path, 'node_modules', dep)
+      return pkgContents({
+        path: p,
+        packageJsonCache,
+        pkg: true,
+        depth,
+        currentDepth: currentDepth + 1,
+        result,
+      })
+    }))
+  }
+
+  if (recursePromises.length) {
+    await Promise.all(recursePromises)
+  }
+
+  return result
+}
+
+module.exports = ({ path, ...opts }) => pkgContents({
+  path: resolve(path),
+  ...opts,
+  pkg: true,
+}).then(results => [...results])

node/node_modules/npm/node_modules/@npmcli/installed-package-contents/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@npmcli/installed-package-contents",
+  "version": "4.0.0",
+  "description": "Get the list of files installed in a package in node_modules, including bundled dependencies",
+  "author": "GitHub Inc.",
+  "main": "lib/index.js",
+  "bin": {
+    "installed-package-contents": "bin/index.js"
+  },
+  "license": "ISC",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "lint": "npm run eslint",
+    "postlint": "template-oss-check",
+    "template-oss-apply": "template-oss-apply --force",
+    "lintfix": "npm run eslint -- --fix",
+    "posttest": "npm run lint",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.0",
+    "@npmcli/template-oss": "4.27.1",
+    "tap": "^16.3.0"
+  },
+  "dependencies": {
+    "npm-bundled": "^5.0.0",
+    "npm-normalize-package-bin": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/installed-package-contents.git"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "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/**"
+    ]
+  }
+}

node/node_modules/npm/node_modules/@npmcli/map-workspaces/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.

node/node_modules/npm/node_modules/@npmcli/map-workspaces/lib/index.js

@@ -0,0 +1,226 @@
+const path = require('path')
+
+const getName = require('@npmcli/name-from-folder')
+const { minimatch } = require('minimatch')
+const pkgJson = require('@npmcli/package-json')
+const { glob } = require('glob')
+
+function appendNegatedPatterns (allPatterns) {
+  const patterns = []
+  const negatedPatterns = []
+  for (let pattern of allPatterns) {
+    const excl = pattern.match(/^!+/)
+    if (excl) {
+      pattern = pattern.slice(excl[0].length)
+    }
+
+    // strip off any / or ./ from the start of the pattern.  /foo => foo
+    pattern = pattern.replace(/^\.?\/+/, '')
+
+    // an odd number of ! means a negated pattern.  !!foo ==> foo
+    const negate = excl && excl[0].length % 2 === 1
+    if (negate) {
+      negatedPatterns.push(pattern)
+    } else {
+      // remove negated patterns that appeared before this pattern to avoid
+      // ignoring paths that were matched afterwards
+      // e.g: ['packages/**', '!packages/b/**', 'packages/b/a']
+      // in the above list, the last pattern overrides the negated pattern
+      // right before it. In effect, the above list would become:
+      // ['packages/**', 'packages/b/a']
+      // The order matters here which is why we must do it inside the loop
+      // as opposed to doing it all together at the end.
+      for (let i = 0; i < negatedPatterns.length; ++i) {
+        const negatedPattern = negatedPatterns[i]
+        if (minimatch(pattern, negatedPattern)) {
+          negatedPatterns.splice(i, 1)
+        }
+      }
+      patterns.push(pattern)
+    }
+  }
+
+  // use the negated patterns to eagerly remove all the patterns that
+  // can be removed to avoid unnecessary crawling
+  for (const negated of negatedPatterns) {
+    for (const pattern of minimatch.match(patterns, negated)) {
+      patterns.splice(patterns.indexOf(pattern), 1)
+    }
+  }
+  return { patterns, negatedPatterns }
+}
+
+function getPatterns (workspaces) {
+  const workspacesDeclaration =
+    Array.isArray(workspaces.packages)
+      ? workspaces.packages
+      : workspaces
+
+  if (!Array.isArray(workspacesDeclaration)) {
+    throw getError({
+      message: 'workspaces config expects an Array',
+      code: 'EWORKSPACESCONFIG',
+    })
+  }
+
+  return appendNegatedPatterns(workspacesDeclaration)
+}
+
+function getPackageName (pkg, pathname) {
+  return pkg.name || getName(pathname)
+}
+
+// make sure glob pattern only matches folders
+function getGlobPattern (pattern) {
+  pattern = pattern.replace(/\\/g, '/')
+  return pattern.endsWith('/')
+    ? pattern
+    : `${pattern}/`
+}
+
+function getError ({ Type = TypeError, message, code }) {
+  return Object.assign(new Type(message), { code })
+}
+
+function reverseResultMap (map) {
+  return new Map(Array.from(map, item => item.reverse()))
+}
+
+async function mapWorkspaces (opts = {}) {
+  if (!opts || !opts.pkg) {
+    throw getError({
+      message: 'mapWorkspaces missing pkg info',
+      code: 'EMAPWORKSPACESPKG',
+    })
+  }
+  if (!opts.cwd) {
+    opts.cwd = process.cwd()
+  }
+
+  const { workspaces = [] } = opts.pkg
+  const { patterns, negatedPatterns } = getPatterns(workspaces)
+  const results = new Map()
+
+  if (!patterns.length && !negatedPatterns.length) {
+    return results
+  }
+
+  const seen = new Map()
+  const getGlobOpts = () => ({
+    ...opts,
+    ignore: [
+      ...opts.ignore || [],
+      '**/node_modules/**',
+      // just ignore the negated patterns to avoid unnecessary crawling
+      ...negatedPatterns,
+    ],
+  })
+
+  let matches = await glob(patterns.map((p) => getGlobPattern(p)), getGlobOpts())
+  // preserves glob@8 behavior
+  matches = matches.sort((a, b) => a.localeCompare(b, 'en'))
+
+  // we must preserve the order of results according to the given list of
+  // workspace patterns
+  const orderedMatches = []
+  for (const pattern of patterns) {
+    orderedMatches.push(...matches.filter((m) => {
+      return minimatch(m, pattern, { partial: true, windowsPathsNoEscape: true })
+    }))
+  }
+
+  for (const match of orderedMatches) {
+    let pkg
+    try {
+      pkg = await pkgJson.normalize(path.join(opts.cwd, match))
+    } catch (err) {
+      if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
+        continue
+      } else {
+        throw err
+      }
+    }
+
+    const name = getPackageName(pkg.content, pkg.path)
+
+    let seenPackagePathnames = seen.get(name)
+    if (!seenPackagePathnames) {
+      seenPackagePathnames = new Set()
+      seen.set(name, seenPackagePathnames)
+    }
+    seenPackagePathnames.add(pkg.path)
+  }
+
+  const errorMessageArray = ['must not have multiple workspaces with the same name']
+  for (const [packageName, seenPackagePathnames] of seen) {
+    if (seenPackagePathnames.size > 1) {
+      addDuplicateErrorMessages(errorMessageArray, packageName, seenPackagePathnames)
+    } else {
+      results.set(packageName, seenPackagePathnames.values().next().value)
+    }
+  }
+
+  if (errorMessageArray.length > 1) {
+    throw getError({
+      Type: Error,
+      message: errorMessageArray.join('\n'),
+      code: 'EDUPLICATEWORKSPACE',
+    })
+  }
+
+  return results
+}
+
+function addDuplicateErrorMessages (messageArray, packageName, packagePathnames) {
+  messageArray.push(
+    `package '${packageName}' has conflicts in the following paths:`
+  )
+
+  for (const packagePathname of packagePathnames) {
+    messageArray.push(
+      '    ' + packagePathname
+    )
+  }
+}
+
+mapWorkspaces.virtual = function (opts = {}) {
+  if (!opts || !opts.lockfile) {
+    throw getError({
+      message: 'mapWorkspaces.virtual missing lockfile info',
+      code: 'EMAPWORKSPACESLOCKFILE',
+    })
+  }
+  if (!opts.cwd) {
+    opts.cwd = process.cwd()
+  }
+
+  const { packages = {} } = opts.lockfile
+  const { workspaces = [] } = packages[''] || {}
+  // uses a pathname-keyed map in order to negate the exact items
+  const results = new Map()
+  const { patterns, negatedPatterns } = getPatterns(workspaces)
+  if (!patterns.length && !negatedPatterns.length) {
+    return results
+  }
+  negatedPatterns.push('**/node_modules/**')
+
+  const packageKeys = Object.keys(packages)
+  for (const pattern of negatedPatterns) {
+    for (const packageKey of minimatch.match(packageKeys, pattern)) {
+      packageKeys.splice(packageKeys.indexOf(packageKey), 1)
+    }
+  }
+
+  for (const pattern of patterns) {
+    for (const packageKey of minimatch.match(packageKeys, pattern)) {
+      const packagePathname = path.join(opts.cwd, packageKey)
+      const name = getPackageName(packages[packageKey], packagePathname)
+      results.set(packagePathname, name)
+    }
+  }
+
+  // Invert pathname-keyed to a proper name-to-pathnames Map
+  return reverseResultMap(results)
+}
+
+module.exports = mapWorkspaces

node/node_modules/npm/node_modules/@npmcli/map-workspaces/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@npmcli/map-workspaces",
+  "version": "5.0.3",
+  "main": "lib/index.js",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
+  },
+  "description": "Retrieves a name:pathname Map for a given workspaces config",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/map-workspaces.git"
+  },
+  "keywords": [
+    "npm",
+    "npmcli",
+    "libnpm",
+    "cli",
+    "workspaces",
+    "map-workspaces"
+  ],
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "scripts": {
+    "lint": "npm run eslint",
+    "pretest": "npm run lint",
+    "test": "tap",
+    "snap": "tap",
+    "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": {
+    "check-coverage": true,
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^6.0.0",
+    "@npmcli/template-oss": "4.28.0",
+    "tap": "^16.0.1"
+  },
+  "dependencies": {
+    "@npmcli/name-from-folder": "^4.0.0",
+    "@npmcli/package-json": "^7.0.0",
+    "glob": "^13.0.0",
+    "minimatch": "^10.0.3"
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "4.28.0",
+    "publish": "true"
+  }
+}

node/node_modules/npm/node_modules/@npmcli/metavuln-calculator/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 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 THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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.

node/node_modules/npm/node_modules/@npmcli/metavuln-calculator/lib/advisory.js

@@ -0,0 +1,435 @@
+const hash = require('./hash.js')
+const semver = require('semver')
+const semverOpt = { includePrerelease: true, loose: true }
+const getDepSpec = require('./get-dep-spec.js')
+
+// any fields that we don't want in the cache need to be hidden
+const _source = Symbol('source')
+const _packument = Symbol('packument')
+const _versionVulnMemo = Symbol('versionVulnMemo')
+const _updated = Symbol('updated')
+const _options = Symbol('options')
+const _specVulnMemo = Symbol('specVulnMemo')
+const _testVersion = Symbol('testVersion')
+const _testVersions = Symbol('testVersions')
+const _calculateRange = Symbol('calculateRange')
+const _markVulnerable = Symbol('markVulnerable')
+const _testSpec = Symbol('testSpec')
+
+class Advisory {
+  constructor (name, source, options = {}) {
+    this.source = source.id
+    this[_source] = source
+    this[_options] = options
+    this.name = name
+    if (!source.name) {
+      source.name = name
+    }
+
+    this.dependency = source.name
+
+    if (this.type === 'advisory') {
+      this.title = source.title
+      this.url = source.url
+    } else {
+      this.title = `Depends on vulnerable versions of ${source.name}`
+      this.url = null
+    }
+
+    this.severity = source.severity || 'high'
+    this.versions = []
+    this.vulnerableVersions = []
+    this.cwe = source.cwe
+    this.cvss = source.cvss
+
+    // advisories have the range, metavulns do not
+    // if an advisory doesn't specify range, assume all are vulnerable
+    this.range = this.type === 'advisory' ? source.vulnerable_versions || '*'
+      : null
+
+    this.id = hash(this)
+
+    this[_packument] = null
+    // memoized list of which versions are vulnerable
+    this[_versionVulnMemo] = new Map()
+    // memoized list of which dependency specs are vulnerable
+    this[_specVulnMemo] = new Map()
+    this[_updated] = false
+  }
+
+  // true if we updated from what we had in cache
+  get updated () {
+    return this[_updated]
+  }
+
+  get type () {
+    return this.dependency === this.name ? 'advisory' : 'metavuln'
+  }
+
+  get packument () {
+    return this[_packument]
+  }
+
+  // load up the data from a cache entry and a fetched packument
+  load (cached, packument) {
+    // basic data integrity gutcheck
+    if (!cached || typeof cached !== 'object') {
+      throw new TypeError('invalid cached data, expected object')
+    }
+
+    if (!packument || typeof packument !== 'object') {
+      throw new TypeError('invalid packument data, expected object')
+    }
+
+    if (cached.id && cached.id !== this.id) {
+      throw Object.assign(new Error('loading from incorrect cache entry'), {
+        expected: this.id,
+        actual: cached.id,
+      })
+    }
+    if (packument.name !== this.name) {
+      throw Object.assign(new Error('loading from incorrect packument'), {
+        expected: this.name,
+        actual: packument.name,
+      })
+    }
+    if (this[_packument]) {
+      throw new Error('advisory object already loaded')
+    }
+
+    // if we have a range from the initialization, and the cached
+    // data has a *different* range, then we know we have to recalc.
+    // just don't use the cached data, so we will definitely not match later
+    if (!this.range || cached.range && cached.range === this.range) {
+      Object.assign(this, cached)
+    }
+
+    this[_packument] = packument
+
+    const pakuVersions = Object.keys(packument.versions || {})
+    const allVersions = new Set([...pakuVersions, ...this.versions])
+    const versionsAdded = []
+    const versionsRemoved = []
+    for (const v of allVersions) {
+      if (!this.versions.includes(v)) {
+        versionsAdded.push(v)
+        this.versions.push(v)
+      } else if (!pakuVersions.includes(v)) {
+        versionsRemoved.push(v)
+      }
+    }
+
+    // strip out any removed versions from our lists, and sort by semver
+    this.versions = semver.sort(this.versions.filter(v =>
+      !versionsRemoved.includes(v)), semverOpt)
+
+    // if no changes, then just return what we got from cache
+    // versions added or removed always means we changed
+    // otherwise, advisories change if the range changes, and
+    // metavulns change if the source was updated
+    const unchanged = this.type === 'advisory'
+      ? this.range && this.range === cached.range
+      : !this[_source].updated
+
+    // if the underlying source changed, by an advisory updating the
+    // range, or a source advisory being updated, then we have to re-check
+    // otherwise, only recheck the new ones.
+    this.vulnerableVersions = !unchanged ? []
+      : semver.sort(this.vulnerableVersions.filter(v =>
+        !versionsRemoved.includes(v)), semverOpt)
+
+    if (unchanged && !versionsAdded.length && !versionsRemoved.length) {
+      // nothing added or removed, nothing to do here.  use the cached copy.
+      return this
+    }
+
+    this[_updated] = true
+
+    // test any versions newly added
+    if (!unchanged || versionsAdded.length) {
+      this[_testVersions](unchanged ? versionsAdded : this.versions)
+    }
+    this.vulnerableVersions = semver.sort(this.vulnerableVersions, semverOpt)
+
+    // metavulns have to calculate their range, since cache is invalidated
+    // advisories just get their range from the advisory above
+    if (this.type === 'metavuln') {
+      this[_calculateRange]()
+    }
+
+    return this
+  }
+
+  [_calculateRange] () {
+    // calling semver.simplifyRange with a massive list of versions, and those
+    // versions all concatenated with `||` is a geometric CPU explosion!
+    // we can try to be a *little* smarter up front by doing x-y for all
+    // contiguous version sets in the list
+    const ranges = []
+    this.versions = semver.sort(this.versions, semverOpt)
+    this.vulnerableVersions = semver.sort(this.vulnerableVersions, semverOpt)
+    for (let v = 0, vulnVer = 0; v < this.versions.length; v++) {
+      // figure out the vulnerable subrange
+      const vr = [this.versions[v]]
+      while (v < this.versions.length) {
+        if (this.versions[v] !== this.vulnerableVersions[vulnVer]) {
+          // we don't test prerelease versions, so just skip past it
+          if (/-/.test(this.versions[v])) {
+            v++
+            continue
+          }
+          break
+        }
+        if (vr.length > 1) {
+          vr[1] = this.versions[v]
+        } else {
+          vr.push(this.versions[v])
+        }
+        v++
+        vulnVer++
+      }
+      // it'll either be just the first version, which means no overlap,
+      // or the start and end versions, which might be the same version
+      if (vr.length > 1) {
+        const tail = this.versions[this.versions.length - 1]
+        ranges.push(vr[1] === tail ? `>=${vr[0]}`
+          : vr[0] === vr[1] ? vr[0]
+          : vr.join(' - '))
+      }
+    }
+    const metavuln = ranges.join(' || ').trim()
+    this.range = !metavuln ? '<0.0.0-0'
+      : semver.simplifyRange(this.versions, metavuln, semverOpt)
+  }
+
+  // returns true if marked as vulnerable, false if ok
+  // spec is a dependency specifier, for metavuln cases
+  // where the version might not be in the packument.  if
+  // we have the packument and spec is not provided, then
+  // we use the dependency version from the manifest.
+  testVersion (version, spec = null) {
+    const sv = String(version)
+    if (this[_versionVulnMemo].has(sv)) {
+      return this[_versionVulnMemo].get(sv)
+    }
+
+    const result = this[_testVersion](version, spec)
+    if (result) {
+      this[_markVulnerable](version)
+    }
+    this[_versionVulnMemo].set(sv, !!result)
+    return result
+  }
+
+  [_markVulnerable] (version) {
+    const sv = String(version)
+    if (!this.vulnerableVersions.includes(sv)) {
+      this.vulnerableVersions.push(sv)
+    }
+  }
+
+  [_testVersion] (version, spec) {
+    const sv = String(version)
+    if (this.vulnerableVersions.includes(sv)) {
+      return true
+    }
+
+    if (this.type === 'advisory') {
+      // advisory, just test range
+      return semver.satisfies(version, this.range, semverOpt)
+    }
+
+    // check the dependency of this version on the vulnerable dep
+    // if we got a version that's not in the packument, fall back on
+    // the spec provided, if possible.
+    const mani = this[_packument]?.versions?.[version] || {
+      dependencies: {
+        [this.dependency]: spec,
+      },
+    }
+
+    if (!spec) {
+      spec = getDepSpec(mani, this.dependency)
+    }
+
+    // no dep, no vuln
+    if (spec === null) {
+      return false
+    }
+
+    if (!semver.validRange(spec, semverOpt)) {
+      // not a semver range, nothing we can hope to do about it
+      return true
+    }
+
+    const bd = mani.bundleDependencies
+    const bundled = bd && bd.includes(this[_source].name)
+    // XXX if bundled, then semver.intersects() means vulnerable
+    // else, pick a manifest and see if it can't be avoided
+    // try to pick a version of the dep that isn't vulnerable
+    const avoid = this[_source].range
+
+    if (bundled) {
+      return semver.intersects(spec, avoid, semverOpt)
+    }
+
+    return this[_source].testSpec(spec)
+  }
+
+  testSpec (spec) {
+    // testing all the versions is a bit costly, and the spec tends to stay
+    // consistent across multiple versions, so memoize this as well, in case
+    // we're testing lots of versions.
+    const memo = this[_specVulnMemo]
+    if (memo.has(spec)) {
+      return memo.get(spec)
+    }
+
+    const res = this[_testSpec](spec)
+    memo.set(spec, res)
+    return res
+  }
+
+  [_testSpec] (spec) {
+    for (const v of this.versions) {
+      const satisfies = semver.satisfies(v, spec, semverOpt)
+      if (!satisfies) {
+        continue
+      }
+      if (!this.testVersion(v)) {
+        return false
+      }
+    }
+    // either vulnerable, or not installable because nothing satisfied
+    // either way, best avoided.
+    return true
+  }
+
+  [_testVersions] (versions) {
+    if (!versions.length) {
+      return
+    }
+
+    // set of lists of versions
+    const versionSets = new Set()
+    versions = semver.sort(versions.map(v => semver.parse(v, semverOpt)))
+
+    // start out with the versions grouped by major and minor
+    let last = versions[0].major + '.' + versions[0].minor
+    let list = []
+    versionSets.add(list)
+    for (const v of versions) {
+      const k = v.major + '.' + v.minor
+      if (k !== last) {
+        last = k
+        list = []
+        versionSets.add(list)
+      }
+      list.push(v)
+    }
+
+    for (const set of versionSets) {
+      // it's common to have version lists like:
+      // 1.0.0
+      // 1.0.1-alpha.0
+      // 1.0.1-alpha.1
+      // ...
+      // 1.0.1-alpha.999
+      // 1.0.1
+      // 1.0.2-alpha.0
+      // ...
+      // 1.0.2-alpha.99
+      // 1.0.2
+      // with a huge number of prerelease versions that are not installable
+      // anyway.
+      // If mid has a prerelease tag, and set[0] does not, then walk it
+      // back until we hit a non-prerelease version
+      // If mid has a prerelease tag, and set[set.length-1] does not,
+      // then walk it forward until we hit a version without a prerelease tag
+      // Similarly, if the head/tail is a prerelease, but there is a non-pr
+      // version in the set, then start there instead.
+      let h = 0
+      const origHeadVuln = this.testVersion(set[h])
+      while (h < set.length && /-/.test(String(set[h]))) {
+        h++
+      }
+
+      // don't filter out the whole list!  they might all be pr's
+      if (h === set.length) {
+        h = 0
+      } else if (origHeadVuln) {
+        // if the original was vulnerable, assume so are all of these
+        for (let hh = 0; hh < h; hh++) {
+          this[_markVulnerable](set[hh])
+        }
+      }
+
+      let t = set.length - 1
+      const origTailVuln = this.testVersion(set[t])
+      while (t > h && /-/.test(String(set[t]))) {
+        t--
+      }
+
+      // don't filter out the whole list!  might all be pr's
+      if (t === h) {
+        t = set.length - 1
+      } else if (origTailVuln) {
+        // if original tail was vulnerable, assume these are as well
+        for (let tt = set.length - 1; tt > t; tt--) {
+          this[_markVulnerable](set[tt])
+        }
+      }
+
+      const headVuln = h === 0 ? origHeadVuln
+        : this.testVersion(set[h])
+
+      const tailVuln = t === set.length - 1 ? origTailVuln
+        : this.testVersion(set[t])
+
+      // if head and tail both vulnerable, whole list is thrown out
+      if (headVuln && tailVuln) {
+        for (let v = h; v < t; v++) {
+          this[_markVulnerable](set[v])
+        }
+        continue
+      }
+
+      // if length is 2 or 1, then we marked them all already
+      if (t < h + 2) {
+        continue
+      }
+
+      const mid = Math.floor(set.length / 2)
+      const pre = set.slice(0, mid)
+      const post = set.slice(mid)
+
+      // if the parent list wasn't prereleases, then drop pr tags
+      // from end of the pre list, and beginning of the post list,
+      // marking as vulnerable if the midpoint item we picked is.
+      if (!/-/.test(String(pre[0]))) {
+        const midVuln = this.testVersion(pre[pre.length - 1])
+        while (/-/.test(String(pre[pre.length - 1]))) {
+          const v = pre.pop()
+          if (midVuln) {
+            this[_markVulnerable](v)
+          }
+        }
+      }
+
+      if (!/-/.test(String(post[post.length - 1]))) {
+        const midVuln = this.testVersion(post[0])
+        while (/-/.test(String(post[0]))) {
+          const v = post.shift()
+          if (midVuln) {
+            this[_markVulnerable](v)
+          }
+        }
+      }
+
+      versionSets.add(pre)
+      versionSets.add(post)
+    }
+  }
+}
+
+module.exports = Advisory