claude-autopm 3.1.1 → 3.2.0

package/packages/plugin-devops/node_modules/jest-worker/build/workers/threadChild.js

@@ -1,177 +0,0 @@
-'use strict';
-
-function _worker_threads() {
-  const data = require('worker_threads');
-  _worker_threads = function () {
-    return data;
-  };
-  return data;
-}
-function _jestUtil() {
-  const data = require('jest-util');
-  _jestUtil = function () {
-    return data;
-  };
-  return data;
-}
-var _types = require('../types');
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-let file = null;
-let setupArgs = [];
-let initialized = false;
-
-/**
- * This file is a small bootstrapper for workers. It sets up the communication
- * between the worker and the parent process, interpreting parent messages and
- * sending results back.
- *
- * The file loaded will be lazily initialized the first time any of the workers
- * is called. This is done for optimal performance: if the farm is initialized,
- * but no call is made to it, child Node processes will be consuming the least
- * possible amount of memory.
- *
- * If an invalid message is detected, the child will exit (by throwing) with a
- * non-zero exit code.
- */
-const messageListener = request => {
-  switch (request[0]) {
-    case _types.CHILD_MESSAGE_INITIALIZE:
-      const init = request;
-      file = init[2];
-      setupArgs = init[3];
-      process.env.JEST_WORKER_ID = init[4];
-      break;
-    case _types.CHILD_MESSAGE_CALL:
-      const call = request;
-      execMethod(call[2], call[3]);
-      break;
-    case _types.CHILD_MESSAGE_END:
-      end();
-      break;
-    case _types.CHILD_MESSAGE_MEM_USAGE:
-      reportMemoryUsage();
-      break;
-    case _types.CHILD_MESSAGE_CALL_SETUP:
-      if (initialized) {
-        reportSuccess(void 0);
-      } else {
-        const main = require(file);
-        initialized = true;
-        if (main.setup) {
-          execFunction(
-            main.setup,
-            main,
-            setupArgs,
-            reportSuccess,
-            reportInitializeError
-          );
-        } else {
-          reportSuccess(void 0);
-        }
-      }
-      break;
-    default:
-      throw new TypeError(
-        `Unexpected request from parent process: ${request[0]}`
-      );
-  }
-};
-_worker_threads().parentPort.on('message', messageListener);
-function reportMemoryUsage() {
-  if (_worker_threads().isMainThread) {
-    throw new Error('Child can only be used on a forked process');
-  }
-  const msg = [_types.PARENT_MESSAGE_MEM_USAGE, process.memoryUsage().heapUsed];
-  _worker_threads().parentPort.postMessage(msg);
-}
-function reportSuccess(result) {
-  if (_worker_threads().isMainThread) {
-    throw new Error('Child can only be used on a forked process');
-  }
-  try {
-    _worker_threads().parentPort.postMessage([
-      _types.PARENT_MESSAGE_OK,
-      result
-    ]);
-  } catch (err) {
-    // Handling it here to avoid unhandled `DataCloneError` rejection
-    // which is hard to distinguish on the parent side
-    // (such error doesn't have any message or stack trace)
-    reportClientError(err);
-  }
-}
-function reportClientError(error) {
-  return reportError(error, _types.PARENT_MESSAGE_CLIENT_ERROR);
-}
-function reportInitializeError(error) {
-  return reportError(error, _types.PARENT_MESSAGE_SETUP_ERROR);
-}
-function reportError(error, type) {
-  if (_worker_threads().isMainThread) {
-    throw new Error('Child can only be used on a forked process');
-  }
-  if (error == null) {
-    error = new Error('"null" or "undefined" thrown');
-  }
-  _worker_threads().parentPort.postMessage([
-    type,
-    error.constructor && error.constructor.name,
-    error.message,
-    error.stack,
-    typeof error === 'object'
-      ? {
-          ...error
-        }
-      : error
-  ]);
-}
-function end() {
-  const main = require(file);
-  if (!main.teardown) {
-    exitProcess();
-    return;
-  }
-  execFunction(main.teardown, main, [], exitProcess, exitProcess);
-}
-function exitProcess() {
-  // Clean up open handles so the worker ideally exits gracefully
-  _worker_threads().parentPort.removeListener('message', messageListener);
-}
-function execMethod(method, args) {
-  const main = require(file);
-  let fn;
-  if (method === 'default') {
-    fn = main.__esModule ? main.default : main;
-  } else {
-    fn = main[method];
-  }
-  function execHelper() {
-    execFunction(fn, main, args, reportSuccess, reportClientError);
-  }
-  if (initialized || !main.setup) {
-    execHelper();
-    return;
-  }
-  initialized = true;
-  execFunction(main.setup, main, setupArgs, execHelper, reportInitializeError);
-}
-function execFunction(fn, ctx, args, onResult, onError) {
-  let result;
-  try {
-    result = fn.apply(ctx, args);
-  } catch (err) {
-    onError(err);
-    return;
-  }
-  if ((0, _jestUtil().isPromise)(result)) {
-    result.then(onResult, onError);
-  } else {
-    onResult(result);
-  }
-}

package/packages/plugin-devops/node_modules/jest-worker/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "jest-worker",
-  "version": "29.7.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/jestjs/jest.git",
-    "directory": "packages/jest-worker"
-  },
-  "license": "MIT",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./build/index.d.ts",
-      "default": "./build/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "dependencies": {
-    "@types/node": "*",
-    "jest-util": "^29.7.0",
-    "merge-stream": "^2.0.0",
-    "supports-color": "^8.0.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.11.6",
-    "@tsd/typescript": "^5.0.4",
-    "@types/merge-stream": "^1.1.2",
-    "@types/supports-color": "^8.1.0",
-    "get-stream": "^6.0.0",
-    "jest-leak-detector": "^29.7.0",
-    "tsd-lite": "^0.7.0",
-    "worker-farm": "^1.6.0"
-  },
-  "engines": {
-    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
-}

package/packages/plugin-devops/node_modules/minimatch/LICENSE

@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-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.

package/packages/plugin-devops/node_modules/minimatch/README.md

@@ -1,230 +0,0 @@
-# minimatch
-
-A minimal matching utility.
-
-[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch)
-
-
-This is the matching library used internally by npm.
-
-It works by converting glob expressions into JavaScript `RegExp`
-objects.
-
-## Usage
-
-```javascript
-var minimatch = require("minimatch")
-
-minimatch("bar.foo", "*.foo") // true!
-minimatch("bar.foo", "*.bar") // false!
-minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
-```
-
-## Features
-
-Supports these glob features:
-
-* Brace Expansion
-* Extended glob matching
-* "Globstar" `**` matching
-
-See:
-
-* `man sh`
-* `man bash`
-* `man 3 fnmatch`
-* `man 5 gitignore`
-
-## Minimatch Class
-
-Create a minimatch object by instantiating the `minimatch.Minimatch` class.
-
-```javascript
-var Minimatch = require("minimatch").Minimatch
-var mm = new Minimatch(pattern, options)
-```
-
-### Properties
-
-* `pattern` The original pattern the minimatch object represents.
-* `options` The options supplied to the constructor.
-* `set` A 2-dimensional array of regexp or string expressions.
-  Each row in the
-  array corresponds to a brace-expanded pattern.  Each item in the row
-  corresponds to a single path-part.  For example, the pattern
-  `{a,b/c}/d` would expand to a set of patterns like:
-
-        [ [ a, d ]
-        , [ b, c, d ] ]
-
-    If a portion of the pattern doesn't have any "magic" in it
-    (that is, it's something like `"foo"` rather than `fo*o?`), then it
-    will be left as a string rather than converted to a regular
-    expression.
-
-* `regexp` Created by the `makeRe` method.  A single regular expression
-  expressing the entire pattern.  This is useful in cases where you wish
-  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
-* `negate` True if the pattern is negated.
-* `comment` True if the pattern is a comment.
-* `empty` True if the pattern is `""`.
-
-### Methods
-
-* `makeRe` Generate the `regexp` member if necessary, and return it.
-  Will return `false` if the pattern is invalid.
-* `match(fname)` Return true if the filename matches the pattern, or
-  false otherwise.
-* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
-  filename, and match it against a single row in the `regExpSet`.  This
-  method is mainly for internal use, but is exposed so that it can be
-  used by a glob-walker that needs to avoid excessive filesystem calls.
-
-All other methods are internal, and will be called as necessary.
-
-### minimatch(path, pattern, options)
-
-Main export.  Tests a path against the pattern using the options.
-
-```javascript
-var isJS = minimatch(file, "*.js", { matchBase: true })
-```
-
-### minimatch.filter(pattern, options)
-
-Returns a function that tests its
-supplied argument, suitable for use with `Array.filter`.  Example:
-
-```javascript
-var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
-```
-
-### minimatch.match(list, pattern, options)
-
-Match against the list of
-files, in the style of fnmatch or glob.  If nothing is matched, and
-options.nonull is set, then return a list containing the pattern itself.
-
-```javascript
-var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
-```
-
-### minimatch.makeRe(pattern, options)
-
-Make a regular expression object from the pattern.
-
-## Options
-
-All options are `false` by default.
-
-### debug
-
-Dump a ton of stuff to stderr.
-
-### nobrace
-
-Do not expand `{a,b}` and `{1..3}` brace sets.
-
-### noglobstar
-
-Disable `**` matching against multiple folder names.
-
-### dot
-
-Allow patterns to match filenames starting with a period, even if
-the pattern does not explicitly have a period in that spot.
-
-Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
-is set.
-
-### noext
-
-Disable "extglob" style patterns like `+(a|b)`.
-
-### nocase
-
-Perform a case-insensitive match.
-
-### nonull
-
-When a match is not found by `minimatch.match`, return a list containing
-the pattern itself if this option is set.  When not set, an empty list
-is returned if there are no matches.
-
-### matchBase
-
-If set, then patterns without slashes will be matched
-against the basename of the path if it contains slashes.  For example,
-`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
-
-### nocomment
-
-Suppress the behavior of treating `#` at the start of a pattern as a
-comment.
-
-### nonegate
-
-Suppress the behavior of treating a leading `!` character as negation.
-
-### flipNegate
-
-Returns from negate expressions the same as if they were not negated.
-(Ie, true on a hit, false on a miss.)
-
-### partial
-
-Compare a partial path to a pattern.  As long as the parts of the path that
-are present are not contradicted by the pattern, it will be treated as a
-match.  This is useful in applications where you're walking through a
-folder structure, and don't yet have the full path, but want to ensure that
-you do not walk down paths that can never be a match.
-
-For example,
-
-```js
-minimatch('/a/b', '/a/*/c/d', { partial: true })  // true, might be /a/b/c/d
-minimatch('/a/b', '/**/d', { partial: true })     // true, might be /a/b/.../d
-minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
-```
-
-### allowWindowsEscape
-
-Windows path separator `\` is by default converted to `/`, which
-prohibits the usage of `\` as a escape character. This flag skips that
-behavior and allows using the escape character.
-
-## Comparisons to other fnmatch/glob implementations
-
-While strict compliance with the existing standards is a worthwhile
-goal, some discrepancies exist between minimatch and other
-implementations, and are intentional.
-
-If the pattern starts with a `!` character, then it is negated.  Set the
-`nonegate` flag to suppress this behavior, and treat leading `!`
-characters normally.  This is perhaps relevant if you wish to start the
-pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
-characters at the start of a pattern will negate the pattern multiple
-times.
-
-If a pattern starts with `#`, then it is treated as a comment, and
-will not match anything.  Use `\#` to match a literal `#` at the
-start of a line, or set the `nocomment` flag to suppress this behavior.
-
-The double-star character `**` is supported by default, unless the
-`noglobstar` flag is set.  This is supported in the manner of bsdglob
-and bash 4.1, where `**` only has special significance if it is the only
-thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
-`a/**b` will not.
-
-If an escaped pattern has no matches, and the `nonull` flag is set,
-then minimatch.match returns the pattern as-provided, rather than
-interpreting the character escapes.  For example,
-`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
-`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
-that it does not resolve escaped pattern characters.
-
-If brace expansion is not disabled, then it is performed before any
-other interpretation of the glob pattern.  Thus, a pattern like
-`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
-**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
-checked for validity.  Since those two are valid, matching proceeds.