asd

25_01_07/mai/node_modules/jest-circus/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+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.

25_01_07/mai/node_modules/jest-circus/README.md

@@ -0,0 +1,65 @@
+[type-definitions]: https://github.com/facebook/jest/blob/main/packages/jest-types/src/Circus.ts
+
+<h1 align="center">
+  <img src="https://jestjs.io/img/jest.png" height="150" width="150"/>
+  <img src="https://jestjs.io/img/circus.png" height="150" width="150"/>
+  <p align="center">jest-circus</p>
+  <p align="center">The next-gen test runner for Jest</p>
+</h1>
+
+## Overview
+
+Circus is a flux-based test runner for Jest that is fast, maintainable, and simple to extend.
+
+Circus allows you to bind to events via an optional event handler on any [custom environment](https://jestjs.io/docs/configuration#testenvironment-string). See the [type definitions][type-definitions] for more information on the events and state data currently available.
+
+```js
+import {Event, State} from 'jest-circus';
+import NodeEnvironment from 'jest-environment-node';
+
+class MyCustomEnvironment extends NodeEnvironment {
+  //...
+
+  async handleTestEvent(event: Event, state: State) {
+    if (event.name === 'test_start') {
+      // ...
+    }
+  }
+}
+```
+
+Mutating event or state data is currently unsupported and may cause unexpected behavior or break in a future release without warning. New events, event data, and/or state data will not be considered a breaking change and may be added in any minor release.
+
+Note, that `jest-circus` test runner would pause until a promise returned from `handleTestEvent` gets fulfilled. **However, there are a few events that do not conform to this rule, namely**: `start_describe_definition`, `finish_describe_definition`, `add_hook`, `add_test` or `error` (for the up-to-date list you can look at [SyncEvent type in the types definitions][type-definitions]). That is caused by backward compatibility reasons and `process.on('unhandledRejection', callback)` signature, but that usually should not be a problem for most of the use cases.
+
+## Installation
+
+> Note: As of Jest 27, `jest-circus` is the default test runner, so you do not have to install it to use it.
+
+Install `jest-circus` using yarn:
+
+```bash
+yarn add --dev jest-circus
+```
+
+Or via npm:
+
+```bash
+npm install --save-dev jest-circus
+```
+
+## Configure
+
+Configure Jest to use `jest-circus` via the [`testRunner`](https://jestjs.io/docs/configuration#testrunner-string) option:
+
+```json
+{
+  "testRunner": "jest-circus/runner"
+}
+```
+
+Or via CLI:
+
+```bash
+jest --testRunner='jest-circus/runner'
+```

25_01_07/mai/node_modules/jest-circus/build/eventHandler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+declare const eventHandler: Circus.EventHandler;
+export default eventHandler;

25_01_07/mai/node_modules/jest-circus/build/eventHandler.js

@@ -0,0 +1,338 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _globalErrorHandlers = require('./globalErrorHandlers');
+
+var _types = require('./types');
+
+var _utils = require('./utils');
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var jestNow = global[Symbol.for('jest-native-now')] || global.Date.now;
+
+// TODO: investigate why a shorter (event, state) signature results into TS7006 compiler error
+const eventHandler = (event, state) => {
+  switch (event.name) {
+    case 'include_test_location_in_result': {
+      state.includeTestLocationInResult = true;
+      break;
+    }
+
+    case 'hook_start': {
+      event.hook.seenDone = false;
+      break;
+    }
+
+    case 'start_describe_definition': {
+      const {blockName, mode} = event;
+      const {currentDescribeBlock, currentlyRunningTest} = state;
+
+      if (currentlyRunningTest) {
+        currentlyRunningTest.errors.push(
+          new Error(
+            `Cannot nest a describe inside a test. Describe block "${blockName}" cannot run because it is nested within "${currentlyRunningTest.name}".`
+          )
+        );
+        break;
+      }
+
+      const describeBlock = (0, _utils.makeDescribe)(
+        blockName,
+        currentDescribeBlock,
+        mode
+      );
+      currentDescribeBlock.children.push(describeBlock);
+      state.currentDescribeBlock = describeBlock;
+      break;
+    }
+
+    case 'finish_describe_definition': {
+      const {currentDescribeBlock} = state;
+      (0, _utils.invariant)(
+        currentDescribeBlock,
+        'currentDescribeBlock must be there'
+      );
+
+      if (!(0, _utils.describeBlockHasTests)(currentDescribeBlock)) {
+        currentDescribeBlock.hooks.forEach(hook => {
+          hook.asyncError.message = `Invalid: ${hook.type}() may not be used in a describe block containing no tests.`;
+          state.unhandledErrors.push(hook.asyncError);
+        });
+      } // pass mode of currentDescribeBlock to tests
+      // but do not when there is already a single test with "only" mode
+
+      const shouldPassMode = !(
+        currentDescribeBlock.mode === 'only' &&
+        currentDescribeBlock.children.some(
+          child => child.type === 'test' && child.mode === 'only'
+        )
+      );
+
+      if (shouldPassMode) {
+        currentDescribeBlock.children.forEach(child => {
+          if (child.type === 'test' && !child.mode) {
+            child.mode = currentDescribeBlock.mode;
+          }
+        });
+      }
+
+      if (
+        !state.hasFocusedTests &&
+        currentDescribeBlock.mode !== 'skip' &&
+        currentDescribeBlock.children.some(
+          child => child.type === 'test' && child.mode === 'only'
+        )
+      ) {
+        state.hasFocusedTests = true;
+      }
+
+      if (currentDescribeBlock.parent) {
+        state.currentDescribeBlock = currentDescribeBlock.parent;
+      }
+
+      break;
+    }
+
+    case 'add_hook': {
+      const {currentDescribeBlock, currentlyRunningTest, hasStarted} = state;
+      const {asyncError, fn, hookType: type, timeout} = event;
+
+      if (currentlyRunningTest) {
+        currentlyRunningTest.errors.push(
+          new Error(
+            `Hooks cannot be defined inside tests. Hook of type "${type}" is nested within "${currentlyRunningTest.name}".`
+          )
+        );
+        break;
+      } else if (hasStarted) {
+        state.unhandledErrors.push(
+          new Error(
+            'Cannot add a hook after tests have started running. Hooks must be defined synchronously.'
+          )
+        );
+        break;
+      }
+
+      const parent = currentDescribeBlock;
+      currentDescribeBlock.hooks.push({
+        asyncError,
+        fn,
+        parent,
+        seenDone: false,
+        timeout,
+        type
+      });
+      break;
+    }
+
+    case 'add_test': {
+      const {currentDescribeBlock, currentlyRunningTest, hasStarted} = state;
+      const {asyncError, fn, mode, testName: name, timeout} = event;
+
+      if (currentlyRunningTest) {
+        currentlyRunningTest.errors.push(
+          new Error(
+            `Tests cannot be nested. Test "${name}" cannot run because it is nested within "${currentlyRunningTest.name}".`
+          )
+        );
+        break;
+      } else if (hasStarted) {
+        state.unhandledErrors.push(
+          new Error(
+            'Cannot add a test after tests have started running. Tests must be defined synchronously.'
+          )
+        );
+        break;
+      }
+
+      const test = (0, _utils.makeTest)(
+        fn,
+        mode,
+        name,
+        currentDescribeBlock,
+        timeout,
+        asyncError
+      );
+
+      if (currentDescribeBlock.mode !== 'skip' && test.mode === 'only') {
+        state.hasFocusedTests = true;
+      }
+
+      currentDescribeBlock.children.push(test);
+      currentDescribeBlock.tests.push(test);
+      break;
+    }
+
+    case 'hook_failure': {
+      const {test, describeBlock, error, hook} = event;
+      const {asyncError, type} = hook;
+
+      if (type === 'beforeAll') {
+        (0, _utils.invariant)(describeBlock, 'always present for `*All` hooks');
+        (0, _utils.addErrorToEachTestUnderDescribe)(
+          describeBlock,
+          error,
+          asyncError
+        );
+      } else if (type === 'afterAll') {
+        // Attaching `afterAll` errors to each test makes execution flow
+        // too complicated, so we'll consider them to be global.
+        state.unhandledErrors.push([error, asyncError]);
+      } else {
+        (0, _utils.invariant)(test, 'always present for `*Each` hooks');
+        test.errors.push([error, asyncError]);
+      }
+
+      break;
+    }
+
+    case 'test_skip': {
+      event.test.status = 'skip';
+      break;
+    }
+
+    case 'test_todo': {
+      event.test.status = 'todo';
+      break;
+    }
+
+    case 'test_done': {
+      event.test.duration = (0, _utils.getTestDuration)(event.test);
+      event.test.status = 'done';
+      state.currentlyRunningTest = null;
+      break;
+    }
+
+    case 'test_start': {
+      state.currentlyRunningTest = event.test;
+      event.test.startedAt = jestNow();
+      event.test.invocations += 1;
+      break;
+    }
+
+    case 'test_fn_start': {
+      event.test.seenDone = false;
+      break;
+    }
+
+    case 'test_fn_failure': {
+      const {
+        error,
+        test: {asyncError}
+      } = event;
+      event.test.errors.push([error, asyncError]);
+      break;
+    }
+
+    case 'test_retry': {
+      event.test.errors = [];
+      break;
+    }
+
+    case 'run_start': {
+      state.hasStarted = true;
+      global[_types.TEST_TIMEOUT_SYMBOL] &&
+        (state.testTimeout = global[_types.TEST_TIMEOUT_SYMBOL]);
+      break;
+    }
+
+    case 'run_finish': {
+      break;
+    }
+
+    case 'setup': {
+      // Uncaught exception handlers should be defined on the parent process
+      // object. If defined on the VM's process object they just no op and let
+      // the parent process crash. It might make sense to return a `dispatch`
+      // function to the parent process and register handlers there instead, but
+      // i'm not sure if this is works. For now i just replicated whatever
+      // jasmine was doing -- dabramov
+      state.parentProcess = event.parentProcess;
+      (0, _utils.invariant)(state.parentProcess);
+      state.originalGlobalErrorHandlers = (0,
+      _globalErrorHandlers.injectGlobalErrorHandlers)(state.parentProcess);
+
+      if (event.testNamePattern) {
+        state.testNamePattern = new RegExp(event.testNamePattern, 'i');
+      }
+
+      break;
+    }
+
+    case 'teardown': {
+      (0, _utils.invariant)(state.originalGlobalErrorHandlers);
+      (0, _utils.invariant)(state.parentProcess);
+      (0, _globalErrorHandlers.restoreGlobalErrorHandlers)(
+        state.parentProcess,
+        state.originalGlobalErrorHandlers
+      );
+      break;
+    }
+
+    case 'error': {
+      // It's very likely for long-running async tests to throw errors. In this
+      // case we want to catch them and fail the current test. At the same time
+      // there's a possibility that one test sets a long timeout, that will
+      // eventually throw after this test finishes but during some other test
+      // execution, which will result in one test's error failing another test.
+      // In any way, it should be possible to track where the error was thrown
+      // from.
+      state.currentlyRunningTest
+        ? state.currentlyRunningTest.errors.push(event.error)
+        : state.unhandledErrors.push(event.error);
+      break;
+    }
+  }
+};
+
+var _default = eventHandler;
+exports.default = _default;

25_01_07/mai/node_modules/jest-circus/build/formatNodeAssertErrors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+declare const formatNodeAssertErrors: (event: Circus.Event, state: Circus.State) => void;
+export default formatNodeAssertErrors;

25_01_07/mai/node_modules/jest-circus/build/formatNodeAssertErrors.js

@@ -0,0 +1,204 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = require('assert');
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _jestMatcherUtils = require('jest-matcher-utils');
+
+var _prettyFormat = require('pretty-format');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const assertOperatorsMap = {
+  '!=': 'notEqual',
+  '!==': 'notStrictEqual',
+  '==': 'equal',
+  '===': 'strictEqual'
+};
+const humanReadableOperators = {
+  deepEqual: 'to deeply equal',
+  deepStrictEqual: 'to deeply and strictly equal',
+  equal: 'to be equal',
+  notDeepEqual: 'not to deeply equal',
+  notDeepStrictEqual: 'not to deeply and strictly equal',
+  notEqual: 'to not be equal',
+  notStrictEqual: 'not be strictly equal',
+  strictEqual: 'to strictly be equal'
+};
+
+const formatNodeAssertErrors = (event, state) => {
+  if (event.name === 'test_done') {
+    event.test.errors = event.test.errors.map(errors => {
+      let error;
+
+      if (Array.isArray(errors)) {
+        const [originalError, asyncError] = errors;
+
+        if (originalError == null) {
+          error = asyncError;
+        } else if (!originalError.stack) {
+          error = asyncError;
+          error.message = originalError.message
+            ? originalError.message
+            : `thrown: ${(0, _prettyFormat.format)(originalError, {
+                maxDepth: 3
+              })}`;
+        } else {
+          error = originalError;
+        }
+      } else {
+        error = errors;
+      }
+
+      return isAssertionError(error)
+        ? {
+            message: assertionErrorMessage(error, {
+              expand: state.expand
+            })
+          }
+        : errors;
+    });
+  }
+};
+
+const getOperatorName = (operator, stack) => {
+  if (typeof operator === 'string') {
+    return assertOperatorsMap[operator] || operator;
+  }
+
+  if (stack.match('.doesNotThrow')) {
+    return 'doesNotThrow';
+  }
+
+  if (stack.match('.throws')) {
+    return 'throws';
+  } // this fallback is only needed for versions older than node 10
+
+  if (stack.match('.fail')) {
+    return 'fail';
+  }
+
+  return '';
+};
+
+const operatorMessage = operator => {
+  const niceOperatorName = getOperatorName(operator, '');
+  const humanReadableOperator = humanReadableOperators[niceOperatorName];
+  return typeof operator === 'string'
+    ? `${humanReadableOperator || niceOperatorName} to:\n`
+    : '';
+};
+
+const assertThrowingMatcherHint = operatorName =>
+  operatorName
+    ? _chalk.default.dim('assert') +
+      _chalk.default.dim('.' + operatorName + '(') +
+      _chalk.default.red('function') +
+      _chalk.default.dim(')')
+    : '';
+
+const assertMatcherHint = (operator, operatorName, expected) => {
+  let message = '';
+
+  if (operator === '==' && expected === true) {
+    message =
+      _chalk.default.dim('assert') +
+      _chalk.default.dim('(') +
+      _chalk.default.red('received') +
+      _chalk.default.dim(')');
+  } else if (operatorName) {
+    message =
+      _chalk.default.dim('assert') +
+      _chalk.default.dim('.' + operatorName + '(') +
+      _chalk.default.red('received') +
+      _chalk.default.dim(', ') +
+      _chalk.default.green('expected') +
+      _chalk.default.dim(')');
+  }
+
+  return message;
+};
+
+function assertionErrorMessage(error, options) {
+  const {expected, actual, generatedMessage, message, operator, stack} = error;
+  const diffString = (0, _jestMatcherUtils.diff)(expected, actual, options);
+  const hasCustomMessage = !generatedMessage;
+  const operatorName = getOperatorName(operator, stack);
+  const trimmedStack = stack
+    .replace(message, '')
+    .replace(/AssertionError(.*)/g, '');
+
+  if (operatorName === 'doesNotThrow') {
+    return (
+      buildHintString(assertThrowingMatcherHint(operatorName)) +
+      _chalk.default.reset('Expected the function not to throw an error.\n') +
+      _chalk.default.reset('Instead, it threw:\n') +
+      `  ${(0, _jestMatcherUtils.printReceived)(actual)}` +
+      _chalk.default.reset(
+        hasCustomMessage ? '\n\nMessage:\n  ' + message : ''
+      ) +
+      trimmedStack
+    );
+  }
+
+  if (operatorName === 'throws') {
+    return (
+      buildHintString(assertThrowingMatcherHint(operatorName)) +
+      _chalk.default.reset('Expected the function to throw an error.\n') +
+      _chalk.default.reset("But it didn't throw anything.") +
+      _chalk.default.reset(
+        hasCustomMessage ? '\n\nMessage:\n  ' + message : ''
+      ) +
+      trimmedStack
+    );
+  }
+
+  if (operatorName === 'fail') {
+    return (
+      buildHintString(assertMatcherHint(operator, operatorName, expected)) +
+      _chalk.default.reset(hasCustomMessage ? 'Message:\n  ' + message : '') +
+      trimmedStack
+    );
+  }
+
+  return (
+    buildHintString(assertMatcherHint(operator, operatorName, expected)) +
+    _chalk.default.reset(`Expected value ${operatorMessage(operator)}`) +
+    `  ${(0, _jestMatcherUtils.printExpected)(expected)}\n` +
+    _chalk.default.reset('Received:\n') +
+    `  ${(0, _jestMatcherUtils.printReceived)(actual)}` +
+    _chalk.default.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
+    (diffString ? `\n\nDifference:\n\n${diffString}` : '') +
+    trimmedStack
+  );
+}
+
+function isAssertionError(error) {
+  return (
+    error &&
+    (error instanceof _assert.AssertionError ||
+      error.name === _assert.AssertionError.name ||
+      error.code === 'ERR_ASSERTION')
+  );
+}
+
+function buildHintString(hint) {
+  return hint ? hint + '\n\n' : '';
+}
+
+var _default = formatNodeAssertErrors;
+exports.default = _default;

25_01_07/mai/node_modules/jest-circus/build/globalErrorHandlers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+export declare const injectGlobalErrorHandlers: (parentProcess: NodeJS.Process) => Circus.GlobalErrorHandlers;
+export declare const restoreGlobalErrorHandlers: (parentProcess: NodeJS.Process, originalErrorHandlers: Circus.GlobalErrorHandlers) => void;

25_01_07/mai/node_modules/jest-circus/build/globalErrorHandlers.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.restoreGlobalErrorHandlers = exports.injectGlobalErrorHandlers = void 0;
+
+var _state = require('./state');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const uncaught = error => {
+  (0, _state.dispatchSync)({
+    error,
+    name: 'error'
+  });
+};
+
+const injectGlobalErrorHandlers = parentProcess => {
+  const uncaughtException = process.listeners('uncaughtException').slice();
+  const unhandledRejection = process.listeners('unhandledRejection').slice();
+  parentProcess.removeAllListeners('uncaughtException');
+  parentProcess.removeAllListeners('unhandledRejection');
+  parentProcess.on('uncaughtException', uncaught);
+  parentProcess.on('unhandledRejection', uncaught);
+  return {
+    uncaughtException,
+    unhandledRejection
+  };
+};
+
+exports.injectGlobalErrorHandlers = injectGlobalErrorHandlers;
+
+const restoreGlobalErrorHandlers = (parentProcess, originalErrorHandlers) => {
+  parentProcess.removeListener('uncaughtException', uncaught);
+  parentProcess.removeListener('unhandledRejection', uncaught);
+
+  for (const listener of originalErrorHandlers.uncaughtException) {
+    parentProcess.on('uncaughtException', listener);
+  }
+
+  for (const listener of originalErrorHandlers.unhandledRejection) {
+    parentProcess.on('unhandledRejection', listener);
+  }
+};
+
+exports.restoreGlobalErrorHandlers = restoreGlobalErrorHandlers;

25_01_07/mai/node_modules/jest-circus/build/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus, Global } from '@jest/types';
+export { setState, getState, resetState } from './state';
+export { default as run } from './run';
+declare type THook = (fn: Circus.HookFn, timeout?: number) => void;
+declare const describe: {
+    (blockName: Circus.BlockName, blockFn: Circus.BlockFn): void;
+    each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+    only: {
+        (blockName: Circus.BlockName, blockFn: Circus.BlockFn): void;
+        each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+    };
+    skip: {
+        (blockName: Circus.BlockName, blockFn: Circus.BlockFn): void;
+        each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+    };
+};
+declare const beforeEach: THook;
+declare const beforeAll: THook;
+declare const afterEach: THook;
+declare const afterAll: THook;
+declare const test: Global.It;
+declare const it: Global.It;
+export declare type Event = Circus.Event;
+export declare type State = Circus.State;
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, test };
+declare const _default: {
+    afterAll: THook;
+    afterEach: THook;
+    beforeAll: THook;
+    beforeEach: THook;
+    describe: {
+        (blockName: string, blockFn: Global.BlockFn): void;
+        each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+        only: {
+            (blockName: string, blockFn: Global.BlockFn): void;
+            each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+        };
+        skip: {
+            (blockName: string, blockFn: Global.BlockFn): void;
+            each: (table: Global.EachTable, ...taggedTemplateData: Global.TemplateData) => (title: string, test: Global.EachTestFn<Global.TestCallback>, timeout?: number | undefined) => void;
+        };
+    };
+    it: Global.It;
+    test: Global.It;
+};
+export default _default;

25_01_07/mai/node_modules/jest-circus/build/index.js

@@ -0,0 +1,226 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.describe =
+  exports.default =
+  exports.beforeEach =
+  exports.beforeAll =
+  exports.afterEach =
+  exports.afterAll =
+    void 0;
+Object.defineProperty(exports, 'getState', {
+  enumerable: true,
+  get: function () {
+    return _state.getState;
+  }
+});
+exports.it = void 0;
+Object.defineProperty(exports, 'resetState', {
+  enumerable: true,
+  get: function () {
+    return _state.resetState;
+  }
+});
+Object.defineProperty(exports, 'run', {
+  enumerable: true,
+  get: function () {
+    return _run.default;
+  }
+});
+Object.defineProperty(exports, 'setState', {
+  enumerable: true,
+  get: function () {
+    return _state.setState;
+  }
+});
+exports.test = void 0;
+
+var _jestEach = require('jest-each');
+
+var _jestUtil = require('jest-util');
+
+var _state = require('./state');
+
+var _run = _interopRequireDefault(require('./run'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const describe = (() => {
+  const describe = (blockName, blockFn) =>
+    _dispatchDescribe(blockFn, blockName, describe);
+
+  const only = (blockName, blockFn) =>
+    _dispatchDescribe(blockFn, blockName, only, 'only');
+
+  const skip = (blockName, blockFn) =>
+    _dispatchDescribe(blockFn, blockName, skip, 'skip');
+
+  describe.each = (0, _jestEach.bind)(describe, false);
+  only.each = (0, _jestEach.bind)(only, false);
+  skip.each = (0, _jestEach.bind)(skip, false);
+  describe.only = only;
+  describe.skip = skip;
+  return describe;
+})();
+
+exports.describe = describe;
+
+const _dispatchDescribe = (blockFn, blockName, describeFn, mode) => {
+  const asyncError = new _jestUtil.ErrorWithStack(undefined, describeFn);
+
+  if (blockFn === undefined) {
+    asyncError.message =
+      'Missing second argument. It must be a callback function.';
+    throw asyncError;
+  }
+
+  if (typeof blockFn !== 'function') {
+    asyncError.message = `Invalid second argument, ${blockFn}. It must be a callback function.`;
+    throw asyncError;
+  }
+
+  (0, _state.dispatchSync)({
+    asyncError,
+    blockName,
+    mode,
+    name: 'start_describe_definition'
+  });
+  const describeReturn = blockFn();
+
+  if ((0, _jestUtil.isPromise)(describeReturn)) {
+    throw new _jestUtil.ErrorWithStack(
+      'Returning a Promise from "describe" is not supported. Tests must be defined synchronously.',
+      describeFn
+    );
+  } else if (describeReturn !== undefined) {
+    throw new _jestUtil.ErrorWithStack(
+      'A "describe" callback must not return a value.',
+      describeFn
+    );
+  }
+
+  (0, _state.dispatchSync)({
+    blockName,
+    mode,
+    name: 'finish_describe_definition'
+  });
+};
+
+const _addHook = (fn, hookType, hookFn, timeout) => {
+  const asyncError = new _jestUtil.ErrorWithStack(undefined, hookFn);
+
+  if (typeof fn !== 'function') {
+    asyncError.message =
+      'Invalid first argument. It must be a callback function.';
+    throw asyncError;
+  }
+
+  (0, _state.dispatchSync)({
+    asyncError,
+    fn,
+    hookType,
+    name: 'add_hook',
+    timeout
+  });
+}; // Hooks have to pass themselves to the HOF in order for us to trim stack traces.
+
+const beforeEach = (fn, timeout) =>
+  _addHook(fn, 'beforeEach', beforeEach, timeout);
+
+exports.beforeEach = beforeEach;
+
+const beforeAll = (fn, timeout) =>
+  _addHook(fn, 'beforeAll', beforeAll, timeout);
+
+exports.beforeAll = beforeAll;
+
+const afterEach = (fn, timeout) =>
+  _addHook(fn, 'afterEach', afterEach, timeout);
+
+exports.afterEach = afterEach;
+
+const afterAll = (fn, timeout) => _addHook(fn, 'afterAll', afterAll, timeout);
+
+exports.afterAll = afterAll;
+
+const test = (() => {
+  const test = (testName, fn, timeout) =>
+    _addTest(testName, undefined, fn, test, timeout);
+
+  const skip = (testName, fn, timeout) =>
+    _addTest(testName, 'skip', fn, skip, timeout);
+
+  const only = (testName, fn, timeout) =>
+    _addTest(testName, 'only', fn, test.only, timeout);
+
+  test.todo = (testName, ...rest) => {
+    if (rest.length > 0 || typeof testName !== 'string') {
+      throw new _jestUtil.ErrorWithStack(
+        'Todo must be called with only a description.',
+        test.todo
+      );
+    }
+
+    return _addTest(testName, 'todo', () => {}, test.todo);
+  };
+
+  const _addTest = (testName, mode, fn, testFn, timeout) => {
+    const asyncError = new _jestUtil.ErrorWithStack(undefined, testFn);
+
+    if (typeof testName !== 'string') {
+      asyncError.message = `Invalid first argument, ${testName}. It must be a string.`;
+      throw asyncError;
+    }
+
+    if (fn === undefined) {
+      asyncError.message =
+        'Missing second argument. It must be a callback function. Perhaps you want to use `test.todo` for a test placeholder.';
+      throw asyncError;
+    }
+
+    if (typeof fn !== 'function') {
+      asyncError.message = `Invalid second argument, ${fn}. It must be a callback function.`;
+      throw asyncError;
+    }
+
+    return (0, _state.dispatchSync)({
+      asyncError,
+      fn,
+      mode,
+      name: 'add_test',
+      testName,
+      timeout
+    });
+  };
+
+  test.each = (0, _jestEach.bind)(test);
+  only.each = (0, _jestEach.bind)(only);
+  skip.each = (0, _jestEach.bind)(skip);
+  test.only = only;
+  test.skip = skip;
+  return test;
+})();
+
+exports.test = test;
+const it = test;
+exports.it = it;
+var _default = {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  it,
+  test
+};
+exports.default = _default;

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { JestEnvironment } from '@jest/environment';
+import type { TestFileEvent, TestResult } from '@jest/test-result';
+import type { Config } from '@jest/types';
+import type Runtime from 'jest-runtime';
+declare const jestAdapter: (globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, environment: JestEnvironment, runtime: Runtime, testPath: string, sendMessageToJest?: TestFileEvent<"test-file-start" | "test-file-success" | "test-file-failure" | "test-case-result"> | undefined) => Promise<TestResult>;
+export = jestAdapter;

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var _jestUtil = require('jest-util');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const FRAMEWORK_INITIALIZER = require.resolve('./jestAdapterInit');
+
+const jestAdapter = async (
+  globalConfig,
+  config,
+  environment,
+  runtime,
+  testPath,
+  sendMessageToJest
+) => {
+  const {initialize, runAndTransformResultsToJestFormat} =
+    runtime.requireInternalModule(FRAMEWORK_INITIALIZER);
+  const {globals, snapshotState} = await initialize({
+    config,
+    environment,
+    globalConfig,
+    localRequire: runtime.requireModule.bind(runtime),
+    parentProcess: process,
+    sendMessageToJest,
+    setGlobalsForRuntime: runtime.setGlobalsForRuntime.bind(runtime),
+    testPath
+  });
+
+  if (config.timers === 'fake' || config.timers === 'modern') {
+    // during setup, this cannot be null (and it's fine to explode if it is)
+    environment.fakeTimersModern.useFakeTimers();
+  } else if (config.timers === 'legacy') {
+    environment.fakeTimers.useFakeTimers();
+  }
+
+  globals.beforeEach(() => {
+    if (config.resetModules) {
+      runtime.resetModules();
+    }
+
+    if (config.clearMocks) {
+      runtime.clearAllMocks();
+    }
+
+    if (config.resetMocks) {
+      runtime.resetAllMocks();
+
+      if (config.timers === 'legacy') {
+        // during setup, this cannot be null (and it's fine to explode if it is)
+        environment.fakeTimers.useFakeTimers();
+      }
+    }
+
+    if (config.restoreMocks) {
+      runtime.restoreAllMocks();
+    }
+  });
+
+  for (const path of config.setupFilesAfterEnv) {
+    const esm = runtime.unstable_shouldLoadAsEsm(path);
+
+    if (esm) {
+      await runtime.unstable_importModule(path);
+    } else {
+      runtime.requireModule(path);
+    }
+  }
+
+  const esm = runtime.unstable_shouldLoadAsEsm(testPath);
+
+  if (esm) {
+    await runtime.unstable_importModule(testPath);
+  } else {
+    runtime.requireModule(testPath);
+  }
+
+  const results = await runAndTransformResultsToJestFormat({
+    config,
+    globalConfig,
+    testPath
+  });
+
+  _addSnapshotData(results, snapshotState); // We need to copy the results object to ensure we don't leaks the prototypes
+  // from the VM. Jasmine creates the result objects in the parent process, we
+  // should consider doing that for circus as well.
+
+  return (0, _jestUtil.deepCyclicCopy)(results, {
+    keepPrototype: false
+  });
+};
+
+const _addSnapshotData = (results, snapshotState) => {
+  results.testResults.forEach(({fullName, status}) => {
+    if (status === 'pending' || status === 'failed') {
+      // if test is skipped or failed, we don't want to mark
+      // its snapshots as obsolete.
+      snapshotState.markSnapshotsAsCheckedForTest(fullName);
+    }
+  });
+  const uncheckedCount = snapshotState.getUncheckedCount();
+  const uncheckedKeys = snapshotState.getUncheckedKeys();
+
+  if (uncheckedCount) {
+    snapshotState.removeUncheckedKeys();
+  }
+
+  const status = snapshotState.save();
+  results.snapshot.fileDeleted = status.deleted;
+  results.snapshot.added = snapshotState.added;
+  results.snapshot.matched = snapshotState.matched;
+  results.snapshot.unmatched = snapshotState.unmatched;
+  results.snapshot.updated = snapshotState.updated;
+  results.snapshot.unchecked = !status.deleted ? uncheckedCount : 0; // Copy the array to prevent memory leaks
+
+  results.snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+};
+
+module.exports = jestAdapter;

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { JestEnvironment } from '@jest/environment';
+import { TestFileEvent, TestResult } from '@jest/test-result';
+import type { Config, Global } from '@jest/types';
+import { SnapshotStateType } from 'jest-snapshot';
+import globals from '..';
+import { Expect } from './jestExpect';
+declare type Process = NodeJS.Process;
+interface JestGlobals extends Global.TestFrameworkGlobals {
+    expect: Expect;
+}
+export declare const initialize: ({ config, environment, globalConfig, localRequire, parentProcess, sendMessageToJest, setGlobalsForRuntime, testPath, }: {
+    config: Config.ProjectConfig;
+    environment: JestEnvironment;
+    globalConfig: Config.GlobalConfig;
+    localRequire: <T = unknown>(path: Config.Path) => T;
+    testPath: Config.Path;
+    parentProcess: Process;
+    sendMessageToJest?: TestFileEvent<"test-file-start" | "test-file-success" | "test-file-failure" | "test-case-result"> | undefined;
+    setGlobalsForRuntime: (globals: JestGlobals) => void;
+}) => Promise<{
+    globals: Global.TestFrameworkGlobals;
+    snapshotState: SnapshotStateType;
+}>;
+export declare const runAndTransformResultsToJestFormat: ({ config, globalConfig, testPath, }: {
+    config: Config.ProjectConfig;
+    globalConfig: Config.GlobalConfig;
+    testPath: string;
+}) => Promise<TestResult>;
+export {};

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js

@@ -0,0 +1,299 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.runAndTransformResultsToJestFormat = exports.initialize = void 0;
+
+var _throat = _interopRequireDefault(require('throat'));
+
+var _testResult = require('@jest/test-result');
+
+var _expect = require('expect');
+
+var _jestEach = require('jest-each');
+
+var _jestMessageUtil = require('jest-message-util');
+
+var _jestSnapshot = require('jest-snapshot');
+
+var _ = _interopRequireDefault(require('..'));
+
+var _run = _interopRequireDefault(require('../run'));
+
+var _state = require('../state');
+
+var _testCaseReportHandler = _interopRequireDefault(
+  require('../testCaseReportHandler')
+);
+
+var _utils = require('../utils');
+
+var _jestExpect = _interopRequireDefault(require('./jestExpect'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const initialize = async ({
+  config,
+  environment,
+  globalConfig,
+  localRequire,
+  parentProcess,
+  sendMessageToJest,
+  setGlobalsForRuntime,
+  testPath
+}) => {
+  if (globalConfig.testTimeout) {
+    (0, _state.getState)().testTimeout = globalConfig.testTimeout;
+  }
+
+  const mutex = (0, _throat.default)(globalConfig.maxConcurrency); // @ts-expect-error
+
+  const globalsObject = {
+    ..._.default,
+    fdescribe: _.default.describe.only,
+    fit: _.default.it.only,
+    xdescribe: _.default.describe.skip,
+    xit: _.default.it.skip,
+    xtest: _.default.it.skip
+  };
+
+  globalsObject.test.concurrent = (test => {
+    const concurrent = (testName, testFn, timeout) => {
+      // For concurrent tests we first run the function that returns promise, and then register a
+      // normal test that will be waiting on the returned promise (when we start the test, the promise
+      // will already be in the process of execution).
+      // Unfortunately at this stage there's no way to know if there are any `.only` tests in the suite
+      // that will result in this test to be skipped, so we'll be executing the promise function anyway,
+      // even if it ends up being skipped.
+      const promise = mutex(() => testFn()); // Avoid triggering the uncaught promise rejection handler in case the test errors before
+      // being awaited on.
+
+      promise.catch(() => {});
+      globalsObject.test(testName, () => promise, timeout);
+    };
+
+    const only = (testName, testFn, timeout) => {
+      const promise = mutex(() => testFn()); // eslint-disable-next-line jest/no-focused-tests
+
+      test.only(testName, () => promise, timeout);
+    };
+
+    concurrent.only = only;
+    concurrent.skip = test.skip;
+    concurrent.each = (0, _jestEach.bind)(test, false);
+    concurrent.skip.each = (0, _jestEach.bind)(test.skip, false);
+    only.each = (0, _jestEach.bind)(test.only, false);
+    return concurrent;
+  })(globalsObject.test);
+
+  (0, _state.addEventHandler)(eventHandler);
+
+  if (environment.handleTestEvent) {
+    (0, _state.addEventHandler)(environment.handleTestEvent.bind(environment));
+  }
+
+  const runtimeGlobals = {
+    ...globalsObject,
+    expect: (0, _jestExpect.default)(globalConfig)
+  };
+  setGlobalsForRuntime(runtimeGlobals);
+
+  if (config.injectGlobals) {
+    Object.assign(environment.global, runtimeGlobals);
+  }
+
+  await (0, _state.dispatch)({
+    name: 'setup',
+    parentProcess,
+    runtimeGlobals,
+    testNamePattern: globalConfig.testNamePattern
+  });
+
+  if (config.testLocationInResults) {
+    await (0, _state.dispatch)({
+      name: 'include_test_location_in_result'
+    });
+  } // Jest tests snapshotSerializers in order preceding built-in serializers.
+  // Therefore, add in reverse because the last added is the first tested.
+
+  config.snapshotSerializers
+    .concat()
+    .reverse()
+    .forEach(path => (0, _jestSnapshot.addSerializer)(localRequire(path)));
+  const {expand, updateSnapshot} = globalConfig;
+  const snapshotResolver = await (0, _jestSnapshot.buildSnapshotResolver)(
+    config,
+    localRequire
+  );
+  const snapshotPath = snapshotResolver.resolveSnapshotPath(testPath);
+  const snapshotState = new _jestSnapshot.SnapshotState(snapshotPath, {
+    expand,
+    prettierPath: config.prettierPath,
+    snapshotFormat: config.snapshotFormat,
+    updateSnapshot
+  }); // @ts-expect-error: snapshotState is a jest extension of `expect`
+
+  (0, _expect.setState)({
+    snapshotState,
+    testPath
+  });
+  (0, _state.addEventHandler)(handleSnapshotStateAfterRetry(snapshotState));
+
+  if (sendMessageToJest) {
+    (0, _state.addEventHandler)(
+      (0, _testCaseReportHandler.default)(testPath, sendMessageToJest)
+    );
+  } // Return it back to the outer scope (test runner outside the VM).
+
+  return {
+    globals: globalsObject,
+    snapshotState
+  };
+};
+
+exports.initialize = initialize;
+
+const runAndTransformResultsToJestFormat = async ({
+  config,
+  globalConfig,
+  testPath
+}) => {
+  const runResult = await (0, _run.default)();
+  let numFailingTests = 0;
+  let numPassingTests = 0;
+  let numPendingTests = 0;
+  let numTodoTests = 0;
+  const assertionResults = runResult.testResults.map(testResult => {
+    let status;
+
+    if (testResult.status === 'skip') {
+      status = 'pending';
+      numPendingTests += 1;
+    } else if (testResult.status === 'todo') {
+      status = 'todo';
+      numTodoTests += 1;
+    } else if (testResult.errors.length) {
+      status = 'failed';
+      numFailingTests += 1;
+    } else {
+      status = 'passed';
+      numPassingTests += 1;
+    }
+
+    const ancestorTitles = testResult.testPath.filter(
+      name => name !== _state.ROOT_DESCRIBE_BLOCK_NAME
+    );
+    const title = ancestorTitles.pop();
+    return {
+      ancestorTitles,
+      duration: testResult.duration,
+      failureDetails: testResult.errorsDetailed,
+      failureMessages: testResult.errors,
+      fullName: title
+        ? ancestorTitles.concat(title).join(' ')
+        : ancestorTitles.join(' '),
+      invocations: testResult.invocations,
+      location: testResult.location,
+      numPassingAsserts: 0,
+      status,
+      title: testResult.testPath[testResult.testPath.length - 1]
+    };
+  });
+  let failureMessage = (0, _jestMessageUtil.formatResultsErrors)(
+    assertionResults,
+    config,
+    globalConfig,
+    testPath
+  );
+  let testExecError;
+
+  if (runResult.unhandledErrors.length) {
+    testExecError = {
+      message: '',
+      stack: runResult.unhandledErrors.join('\n')
+    };
+    failureMessage =
+      (failureMessage || '') +
+      '\n\n' +
+      runResult.unhandledErrors
+        .map(err =>
+          (0, _jestMessageUtil.formatExecError)(err, config, globalConfig)
+        )
+        .join('\n');
+  }
+
+  await (0, _state.dispatch)({
+    name: 'teardown'
+  });
+  return {
+    ...(0, _testResult.createEmptyTestResult)(),
+    console: undefined,
+    displayName: config.displayName,
+    failureMessage,
+    numFailingTests,
+    numPassingTests,
+    numPendingTests,
+    numTodoTests,
+    testExecError,
+    testFilePath: testPath,
+    testResults: assertionResults
+  };
+};
+
+exports.runAndTransformResultsToJestFormat = runAndTransformResultsToJestFormat;
+
+const handleSnapshotStateAfterRetry = snapshotState => event => {
+  switch (event.name) {
+    case 'test_retry': {
+      // Clear any snapshot data that occurred in previous test run
+      snapshotState.clear();
+    }
+  }
+};
+
+const eventHandler = async event => {
+  switch (event.name) {
+    case 'test_start': {
+      (0, _expect.setState)({
+        currentTestName: (0, _utils.getTestID)(event.test)
+      });
+      break;
+    }
+
+    case 'test_done': {
+      _addSuppressedErrors(event.test);
+
+      _addExpectedAssertionErrors(event.test);
+
+      break;
+    }
+  }
+};
+
+const _addExpectedAssertionErrors = test => {
+  const failures = (0, _expect.extractExpectedAssertionsErrors)();
+  const errors = failures.map(failure => failure.error);
+  test.errors = test.errors.concat(errors);
+}; // Get suppressed errors from ``jest-matchers`` that weren't throw during
+// test execution and add them to the test result, potentially failing
+// a passing test.
+
+const _addSuppressedErrors = test => {
+  const {suppressedErrors} = (0, _expect.getState)();
+  (0, _expect.setState)({
+    suppressedErrors: []
+  });
+
+  if (suppressedErrors.length) {
+    test.errors = test.errors.concat(suppressedErrors);
+  }
+};

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Config } from '@jest/types';
+import expect = require('expect');
+export declare type Expect = typeof expect;
+export default function jestExpect(config: Pick<Config.GlobalConfig, 'expand'>): Expect;

25_01_07/mai/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = jestExpect;
+
+var _expect = _interopRequireDefault(require('expect'));
+
+var _jestSnapshot = require('jest-snapshot');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function jestExpect(config) {
+  _expect.default.setState({
+    expand: config.expand
+  });
+
+  _expect.default.extend({
+    toMatchInlineSnapshot: _jestSnapshot.toMatchInlineSnapshot,
+    toMatchSnapshot: _jestSnapshot.toMatchSnapshot,
+    toThrowErrorMatchingInlineSnapshot:
+      _jestSnapshot.toThrowErrorMatchingInlineSnapshot,
+    toThrowErrorMatchingSnapshot: _jestSnapshot.toThrowErrorMatchingSnapshot
+  });
+
+  _expect.default.addSnapshotSerializer = _jestSnapshot.addSerializer;
+  return _expect.default;
+}

25_01_07/mai/node_modules/jest-circus/build/run.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+declare const run: () => Promise<Circus.RunResult>;
+export default run;

25_01_07/mai/node_modules/jest-circus/build/run.js

@@ -0,0 +1,236 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _state = require('./state');
+
+var _types = require('./types');
+
+var _utils = require('./utils');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const run = async () => {
+  const {rootDescribeBlock} = (0, _state.getState)();
+  await (0, _state.dispatch)({
+    name: 'run_start'
+  });
+  await _runTestsForDescribeBlock(rootDescribeBlock);
+  await (0, _state.dispatch)({
+    name: 'run_finish'
+  });
+  return (0, _utils.makeRunResult)(
+    (0, _state.getState)().rootDescribeBlock,
+    (0, _state.getState)().unhandledErrors
+  );
+};
+
+const _runTestsForDescribeBlock = async describeBlock => {
+  await (0, _state.dispatch)({
+    describeBlock,
+    name: 'run_describe_start'
+  });
+  const {beforeAll, afterAll} = (0, _utils.getAllHooksForDescribe)(
+    describeBlock
+  );
+  const isSkipped = describeBlock.mode === 'skip';
+
+  if (!isSkipped) {
+    for (const hook of beforeAll) {
+      await _callCircusHook({
+        describeBlock,
+        hook
+      });
+    }
+  } // Tests that fail and are retried we run after other tests
+
+  const retryTimes = parseInt(global[_types.RETRY_TIMES], 10) || 0;
+  const deferredRetryTests = [];
+
+  for (const child of describeBlock.children) {
+    switch (child.type) {
+      case 'describeBlock': {
+        await _runTestsForDescribeBlock(child);
+        break;
+      }
+
+      case 'test': {
+        const hasErrorsBeforeTestRun = child.errors.length > 0;
+        await _runTest(child, isSkipped);
+
+        if (
+          hasErrorsBeforeTestRun === false &&
+          retryTimes > 0 &&
+          child.errors.length > 0
+        ) {
+          deferredRetryTests.push(child);
+        }
+
+        break;
+      }
+    }
+  } // Re-run failed tests n-times if configured
+
+  for (const test of deferredRetryTests) {
+    let numRetriesAvailable = retryTimes;
+
+    while (numRetriesAvailable > 0 && test.errors.length > 0) {
+      // Clear errors so retries occur
+      await (0, _state.dispatch)({
+        name: 'test_retry',
+        test
+      });
+      await _runTest(test, isSkipped);
+      numRetriesAvailable--;
+    }
+  }
+
+  if (!isSkipped) {
+    for (const hook of afterAll) {
+      await _callCircusHook({
+        describeBlock,
+        hook
+      });
+    }
+  }
+
+  await (0, _state.dispatch)({
+    describeBlock,
+    name: 'run_describe_finish'
+  });
+};
+
+const _runTest = async (test, parentSkipped) => {
+  await (0, _state.dispatch)({
+    name: 'test_start',
+    test
+  });
+  const testContext = Object.create(null);
+  const {hasFocusedTests, testNamePattern} = (0, _state.getState)();
+  const isSkipped =
+    parentSkipped ||
+    test.mode === 'skip' ||
+    (hasFocusedTests && test.mode !== 'only') ||
+    (testNamePattern && !testNamePattern.test((0, _utils.getTestID)(test)));
+
+  if (isSkipped) {
+    await (0, _state.dispatch)({
+      name: 'test_skip',
+      test
+    });
+    return;
+  }
+
+  if (test.mode === 'todo') {
+    await (0, _state.dispatch)({
+      name: 'test_todo',
+      test
+    });
+    return;
+  }
+
+  const {afterEach, beforeEach} = (0, _utils.getEachHooksForTest)(test);
+
+  for (const hook of beforeEach) {
+    if (test.errors.length) {
+      // If any of the before hooks failed already, we don't run any
+      // hooks after that.
+      break;
+    }
+
+    await _callCircusHook({
+      hook,
+      test,
+      testContext
+    });
+  }
+
+  await _callCircusTest(test, testContext);
+
+  for (const hook of afterEach) {
+    await _callCircusHook({
+      hook,
+      test,
+      testContext
+    });
+  } // `afterAll` hooks should not affect test status (pass or fail), because if
+  // we had a global `afterAll` hook it would block all existing tests until
+  // this hook is executed. So we dispatch `test_done` right away.
+
+  await (0, _state.dispatch)({
+    name: 'test_done',
+    test
+  });
+};
+
+const _callCircusHook = async ({hook, test, describeBlock, testContext}) => {
+  await (0, _state.dispatch)({
+    hook,
+    name: 'hook_start'
+  });
+  const timeout = hook.timeout || (0, _state.getState)().testTimeout;
+
+  try {
+    await (0, _utils.callAsyncCircusFn)(hook, testContext, {
+      isHook: true,
+      timeout
+    });
+    await (0, _state.dispatch)({
+      describeBlock,
+      hook,
+      name: 'hook_success',
+      test
+    });
+  } catch (error) {
+    await (0, _state.dispatch)({
+      describeBlock,
+      error,
+      hook,
+      name: 'hook_failure',
+      test
+    });
+  }
+};
+
+const _callCircusTest = async (test, testContext) => {
+  await (0, _state.dispatch)({
+    name: 'test_fn_start',
+    test
+  });
+  const timeout = test.timeout || (0, _state.getState)().testTimeout;
+  (0, _utils.invariant)(
+    test.fn,
+    "Tests with no 'fn' should have 'mode' set to 'skipped'"
+  );
+
+  if (test.errors.length) {
+    return; // We don't run the test if there's already an error in before hooks.
+  }
+
+  try {
+    await (0, _utils.callAsyncCircusFn)(test, testContext, {
+      isHook: false,
+      timeout
+    });
+    await (0, _state.dispatch)({
+      name: 'test_fn_success',
+      test
+    });
+  } catch (error) {
+    await (0, _state.dispatch)({
+      error,
+      name: 'test_fn_failure',
+      test
+    });
+  }
+};
+
+var _default = run;
+exports.default = _default;

25_01_07/mai/node_modules/jest-circus/build/state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+export declare const ROOT_DESCRIBE_BLOCK_NAME = "ROOT_DESCRIBE_BLOCK";
+export declare const resetState: () => void;
+export declare const getState: () => Circus.State;
+export declare const setState: (state: Circus.State) => Circus.State;
+export declare const dispatch: (event: Circus.AsyncEvent) => Promise<void>;
+export declare const dispatchSync: (event: Circus.SyncEvent) => void;
+export declare const addEventHandler: (handler: Circus.EventHandler) => void;

25_01_07/mai/node_modules/jest-circus/build/state.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.setState =
+  exports.resetState =
+  exports.getState =
+  exports.dispatchSync =
+  exports.dispatch =
+  exports.addEventHandler =
+  exports.ROOT_DESCRIBE_BLOCK_NAME =
+    void 0;
+
+var _eventHandler = _interopRequireDefault(require('./eventHandler'));
+
+var _formatNodeAssertErrors = _interopRequireDefault(
+  require('./formatNodeAssertErrors')
+);
+
+var _types = require('./types');
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const eventHandlers = [_eventHandler.default, _formatNodeAssertErrors.default];
+const ROOT_DESCRIBE_BLOCK_NAME = 'ROOT_DESCRIBE_BLOCK';
+exports.ROOT_DESCRIBE_BLOCK_NAME = ROOT_DESCRIBE_BLOCK_NAME;
+
+const createState = () => {
+  const ROOT_DESCRIBE_BLOCK = (0, _utils.makeDescribe)(
+    ROOT_DESCRIBE_BLOCK_NAME
+  );
+  return {
+    currentDescribeBlock: ROOT_DESCRIBE_BLOCK,
+    currentlyRunningTest: null,
+    expand: undefined,
+    hasFocusedTests: false,
+    hasStarted: false,
+    includeTestLocationInResult: false,
+    parentProcess: null,
+    rootDescribeBlock: ROOT_DESCRIBE_BLOCK,
+    testNamePattern: null,
+    testTimeout: 5000,
+    unhandledErrors: []
+  };
+};
+
+const resetState = () => {
+  global[_types.STATE_SYM] = createState();
+};
+
+exports.resetState = resetState;
+resetState();
+
+const getState = () => global[_types.STATE_SYM];
+
+exports.getState = getState;
+
+const setState = state => (global[_types.STATE_SYM] = state);
+
+exports.setState = setState;
+
+const dispatch = async event => {
+  for (const handler of eventHandlers) {
+    await handler(event, getState());
+  }
+};
+
+exports.dispatch = dispatch;
+
+const dispatchSync = event => {
+  for (const handler of eventHandlers) {
+    handler(event, getState());
+  }
+};
+
+exports.dispatchSync = dispatchSync;
+
+const addEventHandler = handler => {
+  eventHandlers.push(handler);
+};
+
+exports.addEventHandler = addEventHandler;

25_01_07/mai/node_modules/jest-circus/build/testCaseReportHandler.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { TestFileEvent } from '@jest/test-result';
+import type { Circus } from '@jest/types';
+declare const testCaseReportHandler: (testPath: string, sendMessageToJest: TestFileEvent) => (event: Circus.Event) => void;
+export default testCaseReportHandler;

25_01_07/mai/node_modules/jest-circus/build/testCaseReportHandler.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require('./utils');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const testCaseReportHandler = (testPath, sendMessageToJest) => event => {
+  switch (event.name) {
+    case 'test_done': {
+      const testResult = (0, _utils.makeSingleTestResult)(event.test);
+      const testCaseResult = (0, _utils.parseSingleTestResult)(testResult);
+      sendMessageToJest('test-case-result', [testPath, testCaseResult]);
+      break;
+    }
+  }
+};
+
+var _default = testCaseReportHandler;
+exports.default = _default;

25_01_07/mai/node_modules/jest-circus/build/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Circus } from '@jest/types';
+import expect = require('expect');
+export declare const STATE_SYM: "STATE_SYM_SYMBOL";
+export declare const RETRY_TIMES: "RETRY_TIMES_SYMBOL";
+export declare const TEST_TIMEOUT_SYMBOL: "TEST_TIMEOUT_SYMBOL";
+declare global {
+    namespace NodeJS {
+        interface Global {
+            STATE_SYM_SYMBOL: Circus.State;
+            RETRY_TIMES_SYMBOL: string;
+            TEST_TIMEOUT_SYMBOL: number;
+            expect: typeof expect;
+        }
+    }
+}

25_01_07/mai/node_modules/jest-circus/build/types.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.TEST_TIMEOUT_SYMBOL = exports.STATE_SYM = exports.RETRY_TIMES = void 0;
+
+var _expect = _interopRequireDefault(require('expect'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+const STATE_SYM = Symbol('JEST_STATE_SYMBOL');
+exports.STATE_SYM = STATE_SYM;
+const RETRY_TIMES = Symbol.for('RETRY_TIMES'); // To pass this value from Runtime object to state we need to use global[sym]
+
+exports.RETRY_TIMES = RETRY_TIMES;
+const TEST_TIMEOUT_SYMBOL = Symbol.for('TEST_TIMEOUT_SYMBOL');
+exports.TEST_TIMEOUT_SYMBOL = TEST_TIMEOUT_SYMBOL;

25_01_07/mai/node_modules/jest-circus/build/utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { AssertionResult } from '@jest/test-result';
+import type { Circus } from '@jest/types';
+export declare const makeDescribe: (name: Circus.BlockName, parent?: Circus.DescribeBlock | undefined, mode?: void | "skip" | "only" | "todo" | undefined) => Circus.DescribeBlock;
+export declare const makeTest: (fn: Circus.TestFn, mode: Circus.TestMode, name: Circus.TestName, parent: Circus.DescribeBlock, timeout: number | undefined, asyncError: Circus.Exception) => Circus.TestEntry;
+declare type DescribeHooks = {
+    beforeAll: Array<Circus.Hook>;
+    afterAll: Array<Circus.Hook>;
+};
+export declare const getAllHooksForDescribe: (describe: Circus.DescribeBlock) => DescribeHooks;
+declare type TestHooks = {
+    beforeEach: Array<Circus.Hook>;
+    afterEach: Array<Circus.Hook>;
+};
+export declare const getEachHooksForTest: (test: Circus.TestEntry) => TestHooks;
+export declare const describeBlockHasTests: (describe: Circus.DescribeBlock) => boolean;
+export declare const callAsyncCircusFn: (testOrHook: Circus.TestEntry | Circus.Hook, testContext: Circus.TestContext | undefined, { isHook, timeout }: {
+    isHook: boolean;
+    timeout: number;
+}) => Promise<unknown>;
+export declare const getTestDuration: (test: Circus.TestEntry) => number | null;
+export declare const makeRunResult: (describeBlock: Circus.DescribeBlock, unhandledErrors: Array<Error>) => Circus.RunResult;
+export declare const makeSingleTestResult: (test: Circus.TestEntry) => Circus.TestResult;
+export declare const getTestID: (test: Circus.TestEntry) => string;
+export declare const addErrorToEachTestUnderDescribe: (describeBlock: Circus.DescribeBlock, error: Circus.Exception, asyncError: Circus.Exception) => void;
+export declare function invariant(condition: unknown, message?: string): asserts condition;
+export declare const parseSingleTestResult: (testResult: Circus.TestResult) => AssertionResult;
+export {};

25_01_07/mai/node_modules/jest-circus/build/utils.js

@@ -0,0 +1,637 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getTestID =
+  exports.getTestDuration =
+  exports.getEachHooksForTest =
+  exports.getAllHooksForDescribe =
+  exports.describeBlockHasTests =
+  exports.callAsyncCircusFn =
+  exports.addErrorToEachTestUnderDescribe =
+    void 0;
+exports.invariant = invariant;
+exports.parseSingleTestResult =
+  exports.makeTest =
+  exports.makeSingleTestResult =
+  exports.makeRunResult =
+  exports.makeDescribe =
+    void 0;
+
+var path = _interopRequireWildcard(require('path'));
+
+var _co = _interopRequireDefault(require('co'));
+
+var _dedent = _interopRequireDefault(require('dedent'));
+
+var _isGeneratorFn = _interopRequireDefault(require('is-generator-fn'));
+
+var _slash = _interopRequireDefault(require('slash'));
+
+var _stackUtils = _interopRequireDefault(require('stack-utils'));
+
+var _jestUtil = require('jest-util');
+
+var _prettyFormat = require('pretty-format');
+
+var _state = require('./state');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var jestNow = global[Symbol.for('jest-native-now')] || global.Date.now;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+const stackUtils = new _stackUtils.default({
+  cwd: 'A path that does not exist'
+});
+const jestEachBuildDir = (0, _slash.default)(
+  path.dirname(require.resolve('jest-each'))
+);
+
+function takesDoneCallback(fn) {
+  return fn.length > 0;
+}
+
+function isGeneratorFunction(fn) {
+  return (0, _isGeneratorFn.default)(fn);
+}
+
+const makeDescribe = (name, parent, mode) => {
+  let _mode = mode;
+
+  if (parent && !mode) {
+    // If not set explicitly, inherit from the parent describe.
+    _mode = parent.mode;
+  }
+
+  return {
+    type: 'describeBlock',
+    // eslint-disable-next-line sort-keys
+    children: [],
+    hooks: [],
+    mode: _mode,
+    name: (0, _jestUtil.convertDescriptorToString)(name),
+    parent,
+    tests: []
+  };
+};
+
+exports.makeDescribe = makeDescribe;
+
+const makeTest = (fn, mode, name, parent, timeout, asyncError) => ({
+  type: 'test',
+  // eslint-disable-next-line sort-keys
+  asyncError,
+  duration: null,
+  errors: [],
+  fn,
+  invocations: 0,
+  mode,
+  name: (0, _jestUtil.convertDescriptorToString)(name),
+  parent,
+  seenDone: false,
+  startedAt: null,
+  status: null,
+  timeout
+}); // Traverse the tree of describe blocks and return true if at least one describe
+// block has an enabled test.
+
+exports.makeTest = makeTest;
+
+const hasEnabledTest = describeBlock => {
+  const {hasFocusedTests, testNamePattern} = (0, _state.getState)();
+  return describeBlock.children.some(child =>
+    child.type === 'describeBlock'
+      ? hasEnabledTest(child)
+      : !(
+          child.mode === 'skip' ||
+          (hasFocusedTests && child.mode !== 'only') ||
+          (testNamePattern && !testNamePattern.test(getTestID(child)))
+        )
+  );
+};
+
+const getAllHooksForDescribe = describe => {
+  const result = {
+    afterAll: [],
+    beforeAll: []
+  };
+
+  if (hasEnabledTest(describe)) {
+    for (const hook of describe.hooks) {
+      switch (hook.type) {
+        case 'beforeAll':
+          result.beforeAll.push(hook);
+          break;
+
+        case 'afterAll':
+          result.afterAll.push(hook);
+          break;
+      }
+    }
+  }
+
+  return result;
+};
+
+exports.getAllHooksForDescribe = getAllHooksForDescribe;
+
+const getEachHooksForTest = test => {
+  const result = {
+    afterEach: [],
+    beforeEach: []
+  };
+  let block = test.parent;
+
+  do {
+    const beforeEachForCurrentBlock = []; // TODO: inline after https://github.com/microsoft/TypeScript/pull/34840 is released
+
+    let hook;
+
+    for (hook of block.hooks) {
+      switch (hook.type) {
+        case 'beforeEach':
+          beforeEachForCurrentBlock.push(hook);
+          break;
+
+        case 'afterEach':
+          result.afterEach.push(hook);
+          break;
+      }
+    } // 'beforeEach' hooks are executed from top to bottom, the opposite of the
+    // way we traversed it.
+
+    result.beforeEach = [...beforeEachForCurrentBlock, ...result.beforeEach];
+  } while ((block = block.parent));
+
+  return result;
+};
+
+exports.getEachHooksForTest = getEachHooksForTest;
+
+const describeBlockHasTests = describe =>
+  describe.children.some(
+    child => child.type === 'test' || describeBlockHasTests(child)
+  );
+
+exports.describeBlockHasTests = describeBlockHasTests;
+
+const _makeTimeoutMessage = (timeout, isHook) =>
+  `Exceeded timeout of ${(0, _jestUtil.formatTime)(timeout)} for a ${
+    isHook ? 'hook' : 'test'
+  }.\nUse jest.setTimeout(newTimeout) to increase the timeout value, if this is a long-running test.`; // Global values can be overwritten by mocks or tests. We'll capture
+// the original values in the variables before we require any files.
+
+const {setTimeout, clearTimeout} = global;
+
+function checkIsError(error) {
+  return !!(error && error.message && error.stack);
+}
+
+const callAsyncCircusFn = (testOrHook, testContext, {isHook, timeout}) => {
+  let timeoutID;
+  let completed = false;
+  const {fn, asyncError} = testOrHook;
+  return new Promise((resolve, reject) => {
+    timeoutID = setTimeout(
+      () => reject(_makeTimeoutMessage(timeout, isHook)),
+      timeout
+    ); // If this fn accepts `done` callback we return a promise that fulfills as
+    // soon as `done` called.
+
+    if (takesDoneCallback(fn)) {
+      let returnedValue = undefined;
+
+      const done = reason => {
+        // We need to keep a stack here before the promise tick
+        const errorAtDone = new _jestUtil.ErrorWithStack(undefined, done);
+
+        if (!completed && testOrHook.seenDone) {
+          errorAtDone.message =
+            'Expected done to be called once, but it was called multiple times.';
+
+          if (reason) {
+            errorAtDone.message +=
+              ' Reason: ' +
+              (0, _prettyFormat.format)(reason, {
+                maxDepth: 3
+              });
+          }
+
+          reject(errorAtDone);
+          throw errorAtDone;
+        } else {
+          testOrHook.seenDone = true;
+        } // Use `Promise.resolve` to allow the event loop to go a single tick in case `done` is called synchronously
+
+        Promise.resolve().then(() => {
+          if (returnedValue !== undefined) {
+            asyncError.message = (0, _dedent.default)`
+      Test functions cannot both take a 'done' callback and return something. Either use a 'done' callback, or return a promise.
+      Returned value: ${(0, _prettyFormat.format)(returnedValue, {
+        maxDepth: 3
+      })}
+      `;
+            return reject(asyncError);
+          }
+
+          let errorAsErrorObject;
+
+          if (checkIsError(reason)) {
+            errorAsErrorObject = reason;
+          } else {
+            errorAsErrorObject = errorAtDone;
+            errorAtDone.message = `Failed: ${(0, _prettyFormat.format)(reason, {
+              maxDepth: 3
+            })}`;
+          } // Consider always throwing, regardless if `reason` is set or not
+
+          if (completed && reason) {
+            errorAsErrorObject.message =
+              'Caught error after test environment was torn down\n\n' +
+              errorAsErrorObject.message;
+            throw errorAsErrorObject;
+          }
+
+          return reason ? reject(errorAsErrorObject) : resolve();
+        });
+      };
+
+      returnedValue = fn.call(testContext, done);
+      return;
+    }
+
+    let returnedValue;
+
+    if (isGeneratorFunction(fn)) {
+      returnedValue = _co.default.wrap(fn).call({});
+    } else {
+      try {
+        returnedValue = fn.call(testContext);
+      } catch (error) {
+        reject(error);
+        return;
+      }
+    } // If it's a Promise, return it. Test for an object with a `then` function
+    // to support custom Promise implementations.
+
+    if (
+      typeof returnedValue === 'object' &&
+      returnedValue !== null &&
+      typeof returnedValue.then === 'function'
+    ) {
+      returnedValue.then(() => resolve(), reject);
+      return;
+    }
+
+    if (!isHook && returnedValue !== undefined) {
+      reject(
+        new Error((0, _dedent.default)`
+      test functions can only return Promise or undefined.
+      Returned value: ${(0, _prettyFormat.format)(returnedValue, {
+        maxDepth: 3
+      })}
+      `)
+      );
+      return;
+    } // Otherwise this test is synchronous, and if it didn't throw it means
+    // it passed.
+
+    resolve();
+  })
+    .then(() => {
+      var _timeoutID$unref, _timeoutID;
+
+      completed = true; // If timeout is not cleared/unrefed the node process won't exit until
+      // it's resolved.
+
+      (_timeoutID$unref = (_timeoutID = timeoutID).unref) === null ||
+      _timeoutID$unref === void 0
+        ? void 0
+        : _timeoutID$unref.call(_timeoutID);
+      clearTimeout(timeoutID);
+    })
+    .catch(error => {
+      var _timeoutID$unref2, _timeoutID2;
+
+      completed = true;
+      (_timeoutID$unref2 = (_timeoutID2 = timeoutID).unref) === null ||
+      _timeoutID$unref2 === void 0
+        ? void 0
+        : _timeoutID$unref2.call(_timeoutID2);
+      clearTimeout(timeoutID);
+      throw error;
+    });
+};
+
+exports.callAsyncCircusFn = callAsyncCircusFn;
+
+const getTestDuration = test => {
+  const {startedAt} = test;
+  return typeof startedAt === 'number' ? jestNow() - startedAt : null;
+};
+
+exports.getTestDuration = getTestDuration;
+
+const makeRunResult = (describeBlock, unhandledErrors) => ({
+  testResults: makeTestResults(describeBlock),
+  unhandledErrors: unhandledErrors.map(_getError).map(getErrorStack)
+});
+
+exports.makeRunResult = makeRunResult;
+
+const makeSingleTestResult = test => {
+  const {includeTestLocationInResult} = (0, _state.getState)();
+  const testPath = [];
+  let parent = test;
+  const {status} = test;
+  invariant(status, 'Status should be present after tests are run.');
+
+  do {
+    testPath.unshift(parent.name);
+  } while ((parent = parent.parent));
+
+  let location = null;
+
+  if (includeTestLocationInResult) {
+    var _parsedLine, _parsedLine$file;
+
+    const stackLines = test.asyncError.stack.split('\n');
+    const stackLine = stackLines[1];
+    let parsedLine = stackUtils.parseLine(stackLine);
+
+    if (
+      (_parsedLine = parsedLine) !== null &&
+      _parsedLine !== void 0 &&
+      (_parsedLine$file = _parsedLine.file) !== null &&
+      _parsedLine$file !== void 0 &&
+      _parsedLine$file.startsWith(jestEachBuildDir)
+    ) {
+      const stackLine = stackLines[4];
+      parsedLine = stackUtils.parseLine(stackLine);
+    }
+
+    if (
+      parsedLine &&
+      typeof parsedLine.column === 'number' &&
+      typeof parsedLine.line === 'number'
+    ) {
+      location = {
+        column: parsedLine.column,
+        line: parsedLine.line
+      };
+    }
+  }
+
+  const errorsDetailed = test.errors.map(_getError);
+  return {
+    duration: test.duration,
+    errors: errorsDetailed.map(getErrorStack),
+    errorsDetailed,
+    invocations: test.invocations,
+    location,
+    status,
+    testPath: Array.from(testPath)
+  };
+};
+
+exports.makeSingleTestResult = makeSingleTestResult;
+
+const makeTestResults = describeBlock => {
+  const testResults = [];
+
+  for (const child of describeBlock.children) {
+    switch (child.type) {
+      case 'describeBlock': {
+        testResults.push(...makeTestResults(child));
+        break;
+      }
+
+      case 'test': {
+        testResults.push(makeSingleTestResult(child));
+        break;
+      }
+    }
+  }
+
+  return testResults;
+}; // Return a string that identifies the test (concat of parent describe block
+// names + test title)
+
+const getTestID = test => {
+  const titles = [];
+  let parent = test;
+
+  do {
+    titles.unshift(parent.name);
+  } while ((parent = parent.parent));
+
+  titles.shift(); // remove TOP_DESCRIBE_BLOCK_NAME
+
+  return titles.join(' ');
+};
+
+exports.getTestID = getTestID;
+
+const _getError = errors => {
+  let error;
+  let asyncError;
+
+  if (Array.isArray(errors)) {
+    error = errors[0];
+    asyncError = errors[1];
+  } else {
+    error = errors;
+    asyncError = new Error();
+  }
+
+  if (error && (typeof error.stack === 'string' || error.message)) {
+    return error;
+  }
+
+  asyncError.message = `thrown: ${(0, _prettyFormat.format)(error, {
+    maxDepth: 3
+  })}`;
+  return asyncError;
+};
+
+const getErrorStack = error =>
+  typeof error.stack === 'string' ? error.stack : error.message;
+
+const addErrorToEachTestUnderDescribe = (describeBlock, error, asyncError) => {
+  for (const child of describeBlock.children) {
+    switch (child.type) {
+      case 'describeBlock':
+        addErrorToEachTestUnderDescribe(child, error, asyncError);
+        break;
+
+      case 'test':
+        child.errors.push([error, asyncError]);
+        break;
+    }
+  }
+};
+
+exports.addErrorToEachTestUnderDescribe = addErrorToEachTestUnderDescribe;
+
+function invariant(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+const parseSingleTestResult = testResult => {
+  let status;
+
+  if (testResult.status === 'skip') {
+    status = 'pending';
+  } else if (testResult.status === 'todo') {
+    status = 'todo';
+  } else if (testResult.errors.length > 0) {
+    status = 'failed';
+  } else {
+    status = 'passed';
+  }
+
+  const ancestorTitles = testResult.testPath.filter(
+    name => name !== _state.ROOT_DESCRIBE_BLOCK_NAME
+  );
+  const title = ancestorTitles.pop();
+  return {
+    ancestorTitles,
+    duration: testResult.duration,
+    failureDetails: testResult.errorsDetailed,
+    failureMessages: Array.from(testResult.errors),
+    fullName: title
+      ? ancestorTitles.concat(title).join(' ')
+      : ancestorTitles.join(' '),
+    invocations: testResult.invocations,
+    location: testResult.location,
+    numPassingAsserts: 0,
+    status,
+    title: testResult.testPath[testResult.testPath.length - 1]
+  };
+};
+
+exports.parseSingleTestResult = parseSingleTestResult;

25_01_07/mai/node_modules/jest-circus/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "jest-circus",
+  "version": "27.5.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-circus"
+  },
+  "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",
+    "./runner": "./runner.js"
+  },
+  "dependencies": {
+    "@jest/environment": "^27.5.1",
+    "@jest/test-result": "^27.5.1",
+    "@jest/types": "^27.5.1",
+    "@types/node": "*",
+    "chalk": "^4.0.0",
+    "co": "^4.6.0",
+    "dedent": "^0.7.0",
+    "expect": "^27.5.1",
+    "is-generator-fn": "^2.0.0",
+    "jest-each": "^27.5.1",
+    "jest-matcher-utils": "^27.5.1",
+    "jest-message-util": "^27.5.1",
+    "jest-runtime": "^27.5.1",
+    "jest-snapshot": "^27.5.1",
+    "jest-util": "^27.5.1",
+    "pretty-format": "^27.5.1",
+    "slash": "^3.0.0",
+    "stack-utils": "^2.0.3",
+    "throat": "^6.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.1.0",
+    "@babel/register": "^7.0.0",
+    "@types/co": "^4.6.0",
+    "@types/dedent": "^0.7.0",
+    "@types/graceful-fs": "^4.1.3",
+    "@types/stack-utils": "^2.0.0",
+    "execa": "^5.0.0",
+    "graceful-fs": "^4.2.9"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "67c1aa20c5fec31366d733e901fee2b981cb1850"
+}

25_01_07/mai/node_modules/jest-circus/runner.js

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Allow people to use `jest-circus/runner` as a runner.
+const runner = require('./build/legacy-code-todo-rewrite/jestAdapter');
+module.exports = runner;