Add side panels, task selection, graph animation, and project docs

- Foldable left panel (user profile) and right panel (task details)
- Clicking a task in the list or graph node selects it and shows details
- Both views (task list + graph) always mounted via absolute inset-0 for
  correct canvas dimensions; tabs toggle visibility with opacity
- Graph node selection animation: other nodes repel outward (charge -600),
  then selected node smoothly slides to center (500ms cubic ease-out),
  then charge restores to -120 and graph stabilizes
- Graph re-fits on tab switch and panel resize via ResizeObserver
- Fix UUID string IDs throughout (backend returns UUIDs, not integers)
- Add TaskDetailPanel, UserPanel components
- Add CLAUDE.md project documentation

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

frontend/node_modules/@jest/core/LICENSE

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

frontend/node_modules/@jest/core/README.md

@@ -0,0 +1,3 @@
+# @jest/core
+
+Jest is currently working on providing a programmatic API. This is under development, and usage of this package directly is currently not supported.

frontend/node_modules/@jest/core/build/FailedTestsCache.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+/**
+ * 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.
+ */
+
+class FailedTestsCache {
+  _enabledTestsMap;
+  filterTests(tests) {
+    const enabledTestsMap = this._enabledTestsMap;
+    if (!enabledTestsMap) {
+      return tests;
+    }
+    return tests.filter(testResult => enabledTestsMap[testResult.path]);
+  }
+  setTestResults(testResults) {
+    this._enabledTestsMap = (testResults || []).reduce(
+      (suiteMap, testResult) => {
+        if (!testResult.numFailingTests) {
+          return suiteMap;
+        }
+        suiteMap[testResult.testFilePath] = testResult.testResults.reduce(
+          (testMap, test) => {
+            if (test.status !== 'failed') {
+              return testMap;
+            }
+            testMap[test.fullName] = true;
+            return testMap;
+          },
+          {}
+        );
+        return suiteMap;
+      },
+      {}
+    );
+    this._enabledTestsMap = Object.freeze(this._enabledTestsMap);
+  }
+}
+exports.default = FailedTestsCache;

frontend/node_modules/@jest/core/build/FailedTestsInteractiveMode.js

@@ -0,0 +1,195 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+  _ansiEscapes = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+const {ARROW, CLEAR} = _jestUtil().specialChars;
+function describeKey(key, description) {
+  return `${_chalk().default.dim(
+    `${ARROW}Press`
+  )} ${key} ${_chalk().default.dim(description)}`;
+}
+const TestProgressLabel = _chalk().default.bold('Interactive Test Progress');
+class FailedTestsInteractiveMode {
+  _isActive = false;
+  _countPaths = 0;
+  _skippedNum = 0;
+  _testAssertions = [];
+  _updateTestRunnerConfig;
+  constructor(_pipe) {
+    this._pipe = _pipe;
+  }
+  isActive() {
+    return this._isActive;
+  }
+  put(key) {
+    switch (key) {
+      case 's':
+        if (this._skippedNum === this._testAssertions.length) {
+          break;
+        }
+        this._skippedNum += 1;
+        // move skipped test to the end
+        this._testAssertions.push(this._testAssertions.shift());
+        if (this._testAssertions.length - this._skippedNum > 0) {
+          this._run();
+        } else {
+          this._drawUIDoneWithSkipped();
+        }
+        break;
+      case 'q':
+      case _jestWatcher().KEYS.ESCAPE:
+        this.abort();
+        break;
+      case 'r':
+        this.restart();
+        break;
+      case _jestWatcher().KEYS.ENTER:
+        if (this._testAssertions.length === 0) {
+          this.abort();
+        } else {
+          this._run();
+        }
+        break;
+      default:
+    }
+  }
+  run(failedTestAssertions, updateConfig) {
+    if (failedTestAssertions.length === 0) return;
+    this._testAssertions = [...failedTestAssertions];
+    this._countPaths = this._testAssertions.length;
+    this._updateTestRunnerConfig = updateConfig;
+    this._isActive = true;
+    this._run();
+  }
+  updateWithResults(results) {
+    if (!results.snapshot.failure && results.numFailedTests > 0) {
+      return this._drawUIOverlay();
+    }
+    this._testAssertions.shift();
+    if (this._testAssertions.length === 0) {
+      return this._drawUIOverlay();
+    }
+
+    // Go to the next test
+    return this._run();
+  }
+  _clearTestSummary() {
+    this._pipe.write(_ansiEscapes().default.cursorUp(6));
+    this._pipe.write(_ansiEscapes().default.eraseDown);
+  }
+  _drawUIDone() {
+    this._pipe.write(CLEAR);
+    const messages = [
+      _chalk().default.bold('Watch Usage'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+    this._pipe.write(`${messages.join('\n')}\n`);
+  }
+  _drawUIDoneWithSkipped() {
+    this._pipe.write(CLEAR);
+    let stats = `${(0, _jestUtil().pluralize)(
+      'test',
+      this._countPaths
+    )} reviewed`;
+    if (this._skippedNum > 0) {
+      const skippedText = _chalk().default.bold.yellow(
+        `${(0, _jestUtil().pluralize)('test', this._skippedNum)} skipped`
+      );
+      stats = `${stats}, ${skippedText}`;
+    }
+    const message = [
+      TestProgressLabel,
+      `${ARROW}${stats}`,
+      '\n',
+      _chalk().default.bold('Watch Usage'),
+      describeKey('r', 'to restart Interactive Mode.'),
+      describeKey('q', 'to quit Interactive Mode.'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+    this._pipe.write(`\n${message.join('\n')}`);
+  }
+  _drawUIProgress() {
+    this._clearTestSummary();
+    const numPass = this._countPaths - this._testAssertions.length;
+    const numRemaining = this._countPaths - numPass - this._skippedNum;
+    let stats = `${(0, _jestUtil().pluralize)('test', numRemaining)} remaining`;
+    if (this._skippedNum > 0) {
+      const skippedText = _chalk().default.bold.yellow(
+        `${(0, _jestUtil().pluralize)('test', this._skippedNum)} skipped`
+      );
+      stats = `${stats}, ${skippedText}`;
+    }
+    const message = [
+      TestProgressLabel,
+      `${ARROW}${stats}`,
+      '\n',
+      _chalk().default.bold('Watch Usage'),
+      describeKey('s', 'to skip the current test.'),
+      describeKey('q', 'to quit Interactive Mode.'),
+      describeKey('Enter', 'to return to watch mode.')
+    ];
+    this._pipe.write(`\n${message.join('\n')}`);
+  }
+  _drawUIOverlay() {
+    if (this._testAssertions.length === 0) return this._drawUIDone();
+    return this._drawUIProgress();
+  }
+  _run() {
+    if (this._updateTestRunnerConfig) {
+      this._updateTestRunnerConfig(this._testAssertions[0]);
+    }
+  }
+  abort() {
+    this._isActive = false;
+    this._skippedNum = 0;
+    if (this._updateTestRunnerConfig) {
+      this._updateTestRunnerConfig();
+    }
+  }
+  restart() {
+    this._skippedNum = 0;
+    this._countPaths = this._testAssertions.length;
+    this._run();
+  }
+}
+exports.default = FailedTestsInteractiveMode;

frontend/node_modules/@jest/core/build/ReporterDispatcher.js

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+/**
+ * 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.
+ */
+
+class ReporterDispatcher {
+  _reporters;
+  constructor() {
+    this._reporters = [];
+  }
+  register(reporter) {
+    this._reporters.push(reporter);
+  }
+  unregister(reporterConstructor) {
+    this._reporters = this._reporters.filter(
+      reporter => !(reporter instanceof reporterConstructor)
+    );
+  }
+  async onTestFileResult(test, testResult, results) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestFileResult) {
+        await reporter.onTestFileResult(test, testResult, results);
+      } else if (reporter.onTestResult) {
+        await reporter.onTestResult(test, testResult, results);
+      }
+    }
+
+    // Release memory if unused later.
+    testResult.coverage = undefined;
+    testResult.console = undefined;
+  }
+  async onTestFileStart(test) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestFileStart) {
+        await reporter.onTestFileStart(test);
+      } else if (reporter.onTestStart) {
+        await reporter.onTestStart(test);
+      }
+    }
+  }
+  async onRunStart(results, options) {
+    for (const reporter of this._reporters) {
+      reporter.onRunStart && (await reporter.onRunStart(results, options));
+    }
+  }
+  async onTestCaseStart(test, testCaseStartInfo) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestCaseStart) {
+        await reporter.onTestCaseStart(test, testCaseStartInfo);
+      }
+    }
+  }
+  async onTestCaseResult(test, testCaseResult) {
+    for (const reporter of this._reporters) {
+      if (reporter.onTestCaseResult) {
+        await reporter.onTestCaseResult(test, testCaseResult);
+      }
+    }
+  }
+  async onRunComplete(testContexts, results) {
+    for (const reporter of this._reporters) {
+      if (reporter.onRunComplete) {
+        await reporter.onRunComplete(testContexts, results);
+      }
+    }
+  }
+
+  // Return a list of last errors for every reporter
+  getErrors() {
+    return this._reporters.reduce((list, reporter) => {
+      const error = reporter.getLastError && reporter.getLastError();
+      return error ? list.concat(error) : list;
+    }, []);
+  }
+  hasErrors() {
+    return this.getErrors().length !== 0;
+  }
+}
+exports.default = ReporterDispatcher;

frontend/node_modules/@jest/core/build/SearchSource.js

@@ -0,0 +1,408 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function os() {
+  const data = _interopRequireWildcard(require('os'));
+  os = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _micromatch() {
+  const data = _interopRequireDefault(require('micromatch'));
+  _micromatch = function () {
+    return data;
+  };
+  return data;
+}
+function _jestConfig() {
+  const data = require('jest-config');
+  _jestConfig = function () {
+    return data;
+  };
+  return data;
+}
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+  _jestRegexUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestResolveDependencies() {
+  const data = require('jest-resolve-dependencies');
+  _jestResolveDependencies = function () {
+    return data;
+  };
+  return data;
+}
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+  _jestSnapshot = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+/**
+ * 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.
+ */
+
+const regexToMatcher = testRegex => {
+  const regexes = testRegex.map(testRegex => new RegExp(testRegex));
+  return path =>
+    regexes.some(regex => {
+      const result = regex.test(path);
+
+      // prevent stateful regexes from breaking, just in case
+      regex.lastIndex = 0;
+      return result;
+    });
+};
+const toTests = (context, tests) =>
+  tests.map(path => ({
+    context,
+    duration: undefined,
+    path
+  }));
+const hasSCM = changedFilesInfo => {
+  const {repos} = changedFilesInfo;
+  // no SCM (git/hg/...) is found in any of the roots.
+  const noSCM = Object.values(repos).every(scm => scm.size === 0);
+  return !noSCM;
+};
+class SearchSource {
+  _context;
+  _dependencyResolver;
+  _testPathCases = [];
+  constructor(context) {
+    const {config} = context;
+    this._context = context;
+    this._dependencyResolver = null;
+    const rootPattern = new RegExp(
+      config.roots
+        .map(dir => (0, _jestRegexUtil().escapePathForRegex)(dir + path().sep))
+        .join('|')
+    );
+    this._testPathCases.push({
+      isMatch: path => rootPattern.test(path),
+      stat: 'roots'
+    });
+    if (config.testMatch.length) {
+      this._testPathCases.push({
+        isMatch: (0, _jestUtil().globsToMatcher)(config.testMatch),
+        stat: 'testMatch'
+      });
+    }
+    if (config.testPathIgnorePatterns.length) {
+      const testIgnorePatternsRegex = new RegExp(
+        config.testPathIgnorePatterns.join('|')
+      );
+      this._testPathCases.push({
+        isMatch: path => !testIgnorePatternsRegex.test(path),
+        stat: 'testPathIgnorePatterns'
+      });
+    }
+    if (config.testRegex.length) {
+      this._testPathCases.push({
+        isMatch: regexToMatcher(config.testRegex),
+        stat: 'testRegex'
+      });
+    }
+  }
+  async _getOrBuildDependencyResolver() {
+    if (!this._dependencyResolver) {
+      this._dependencyResolver =
+        new (_jestResolveDependencies().DependencyResolver)(
+          this._context.resolver,
+          this._context.hasteFS,
+          await (0, _jestSnapshot().buildSnapshotResolver)(this._context.config)
+        );
+    }
+    return this._dependencyResolver;
+  }
+  _filterTestPathsWithStats(allPaths, testPathPattern) {
+    const data = {
+      stats: {
+        roots: 0,
+        testMatch: 0,
+        testPathIgnorePatterns: 0,
+        testRegex: 0
+      },
+      tests: [],
+      total: allPaths.length
+    };
+    const testCases = Array.from(this._testPathCases); // clone
+    if (testPathPattern) {
+      const regex = (0, _jestUtil().testPathPatternToRegExp)(testPathPattern);
+      testCases.push({
+        isMatch: path => regex.test(path),
+        stat: 'testPathPattern'
+      });
+      data.stats.testPathPattern = 0;
+    }
+    data.tests = allPaths.filter(test => {
+      let filterResult = true;
+      for (const {isMatch, stat} of testCases) {
+        if (isMatch(test.path)) {
+          data.stats[stat]++;
+        } else {
+          filterResult = false;
+        }
+      }
+      return filterResult;
+    });
+    return data;
+  }
+  _getAllTestPaths(testPathPattern) {
+    return this._filterTestPathsWithStats(
+      toTests(this._context, this._context.hasteFS.getAllFiles()),
+      testPathPattern
+    );
+  }
+  isTestFilePath(path) {
+    return this._testPathCases.every(testCase => testCase.isMatch(path));
+  }
+  findMatchingTests(testPathPattern) {
+    return this._getAllTestPaths(testPathPattern);
+  }
+  async findRelatedTests(allPaths, collectCoverage) {
+    const dependencyResolver = await this._getOrBuildDependencyResolver();
+    if (!collectCoverage) {
+      return {
+        tests: toTests(
+          this._context,
+          dependencyResolver.resolveInverse(
+            allPaths,
+            this.isTestFilePath.bind(this),
+            {
+              skipNodeResolution: this._context.config.skipNodeResolution
+            }
+          )
+        )
+      };
+    }
+    const testModulesMap = dependencyResolver.resolveInverseModuleMap(
+      allPaths,
+      this.isTestFilePath.bind(this),
+      {
+        skipNodeResolution: this._context.config.skipNodeResolution
+      }
+    );
+    const allPathsAbsolute = Array.from(allPaths).map(p => path().resolve(p));
+    const collectCoverageFrom = new Set();
+    testModulesMap.forEach(testModule => {
+      if (!testModule.dependencies) {
+        return;
+      }
+      testModule.dependencies.forEach(p => {
+        if (!allPathsAbsolute.includes(p)) {
+          return;
+        }
+        const filename = (0, _jestConfig().replaceRootDirInPath)(
+          this._context.config.rootDir,
+          p
+        );
+        collectCoverageFrom.add(
+          path().isAbsolute(filename)
+            ? path().relative(this._context.config.rootDir, filename)
+            : filename
+        );
+      });
+    });
+    return {
+      collectCoverageFrom,
+      tests: toTests(
+        this._context,
+        testModulesMap.map(testModule => testModule.file)
+      )
+    };
+  }
+  findTestsByPaths(paths) {
+    return {
+      tests: toTests(
+        this._context,
+        paths
+          .map(p => path().resolve(this._context.config.cwd, p))
+          .filter(this.isTestFilePath.bind(this))
+      )
+    };
+  }
+  async findRelatedTestsFromPattern(paths, collectCoverage) {
+    if (Array.isArray(paths) && paths.length) {
+      const resolvedPaths = paths.map(p =>
+        path().resolve(this._context.config.cwd, p)
+      );
+      return this.findRelatedTests(new Set(resolvedPaths), collectCoverage);
+    }
+    return {
+      tests: []
+    };
+  }
+  async findTestRelatedToChangedFiles(changedFilesInfo, collectCoverage) {
+    if (!hasSCM(changedFilesInfo)) {
+      return {
+        noSCM: true,
+        tests: []
+      };
+    }
+    const {changedFiles} = changedFilesInfo;
+    return this.findRelatedTests(changedFiles, collectCoverage);
+  }
+  async _getTestPaths(globalConfig, changedFiles) {
+    if (globalConfig.onlyChanged) {
+      if (!changedFiles) {
+        throw new Error('Changed files must be set when running with -o.');
+      }
+      return this.findTestRelatedToChangedFiles(
+        changedFiles,
+        globalConfig.collectCoverage
+      );
+    }
+    let paths = globalConfig.nonFlagArgs;
+    if (globalConfig.findRelatedTests && 'win32' === os().platform()) {
+      paths = this.filterPathsWin32(paths);
+    }
+    if (globalConfig.runTestsByPath && paths && paths.length) {
+      return this.findTestsByPaths(paths);
+    } else if (globalConfig.findRelatedTests && paths && paths.length) {
+      return this.findRelatedTestsFromPattern(
+        paths,
+        globalConfig.collectCoverage
+      );
+    } else if (globalConfig.testPathPattern != null) {
+      return this.findMatchingTests(globalConfig.testPathPattern);
+    } else {
+      return {
+        tests: []
+      };
+    }
+  }
+  filterPathsWin32(paths) {
+    const allFiles = this._context.hasteFS.getAllFiles();
+    const options = {
+      nocase: true,
+      windows: false
+    };
+    function normalizePosix(filePath) {
+      return filePath.replace(/\\/g, '/');
+    }
+    paths = paths
+      .map(p => {
+        // micromatch works with forward slashes: https://github.com/micromatch/micromatch#backslashes
+        const normalizedPath = normalizePosix(
+          path().resolve(this._context.config.cwd, p)
+        );
+        const match = (0, _micromatch().default)(
+          allFiles.map(normalizePosix),
+          normalizedPath,
+          options
+        );
+        return match[0];
+      })
+      .filter(Boolean)
+      .map(p => path().resolve(p));
+    return paths;
+  }
+  async getTestPaths(globalConfig, changedFiles, filter) {
+    const searchResult = await this._getTestPaths(globalConfig, changedFiles);
+    const filterPath = globalConfig.filter;
+    if (filter) {
+      const tests = searchResult.tests;
+      const filterResult = await filter(tests.map(test => test.path));
+      if (!Array.isArray(filterResult.filtered)) {
+        throw new Error(
+          `Filter ${filterPath} did not return a valid test list`
+        );
+      }
+      const filteredSet = new Set(
+        filterResult.filtered.map(result => result.test)
+      );
+      return {
+        ...searchResult,
+        tests: tests.filter(test => filteredSet.has(test.path))
+      };
+    }
+    return searchResult;
+  }
+  async findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo) {
+    if (!hasSCM(changedFilesInfo)) {
+      return [];
+    }
+    const {changedFiles} = changedFilesInfo;
+    const dependencyResolver = await this._getOrBuildDependencyResolver();
+    const relatedSourcesSet = new Set();
+    changedFiles.forEach(filePath => {
+      if (this.isTestFilePath(filePath)) {
+        const sourcePaths = dependencyResolver.resolve(filePath, {
+          skipNodeResolution: this._context.config.skipNodeResolution
+        });
+        sourcePaths.forEach(sourcePath => relatedSourcesSet.add(sourcePath));
+      }
+    });
+    return Array.from(relatedSourcesSet);
+  }
+}
+exports.default = SearchSource;

frontend/node_modules/@jest/core/build/SnapshotInteractiveMode.js

@@ -0,0 +1,238 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+  _ansiEscapes = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+const {ARROW, CLEAR} = _jestUtil().specialChars;
+class SnapshotInteractiveMode {
+  _pipe;
+  _isActive;
+  _updateTestRunnerConfig;
+  _testAssertions;
+  _countPaths;
+  _skippedNum;
+  constructor(pipe) {
+    this._pipe = pipe;
+    this._isActive = false;
+    this._skippedNum = 0;
+  }
+  isActive() {
+    return this._isActive;
+  }
+  getSkippedNum() {
+    return this._skippedNum;
+  }
+  _clearTestSummary() {
+    this._pipe.write(_ansiEscapes().default.cursorUp(6));
+    this._pipe.write(_ansiEscapes().default.eraseDown);
+  }
+  _drawUIProgress() {
+    this._clearTestSummary();
+    const numPass = this._countPaths - this._testAssertions.length;
+    const numRemaining = this._countPaths - numPass - this._skippedNum;
+    let stats = _chalk().default.bold.dim(
+      `${(0, _jestUtil().pluralize)('snapshot', numRemaining)} remaining`
+    );
+    if (numPass) {
+      stats += `, ${_chalk().default.bold.green(
+        `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated`
+      )}`;
+    }
+    if (this._skippedNum) {
+      stats += `, ${_chalk().default.bold.yellow(
+        `${(0, _jestUtil().pluralize)('snapshot', this._skippedNum)} skipped`
+      )}`;
+    }
+    const messages = [
+      `\n${_chalk().default.bold('Interactive Snapshot Progress')}`,
+      ARROW + stats,
+      `\n${_chalk().default.bold('Watch Usage')}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}u${_chalk().default.dim(
+        ' to update failing snapshots for this test.'
+      )}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}s${_chalk().default.dim(
+        ' to skip the current test.'
+      )}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}q${_chalk().default.dim(
+        ' to quit Interactive Snapshot Mode.'
+      )}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}Enter${_chalk().default.dim(
+        ' to trigger a test run.'
+      )}`
+    ];
+    this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`);
+  }
+  _drawUIDoneWithSkipped() {
+    this._pipe.write(CLEAR);
+    const numPass = this._countPaths - this._testAssertions.length;
+    let stats = _chalk().default.bold.dim(
+      `${(0, _jestUtil().pluralize)('snapshot', this._countPaths)} reviewed`
+    );
+    if (numPass) {
+      stats += `, ${_chalk().default.bold.green(
+        `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated`
+      )}`;
+    }
+    if (this._skippedNum) {
+      stats += `, ${_chalk().default.bold.yellow(
+        `${(0, _jestUtil().pluralize)('snapshot', this._skippedNum)} skipped`
+      )}`;
+    }
+    const messages = [
+      `\n${_chalk().default.bold('Interactive Snapshot Result')}`,
+      ARROW + stats,
+      `\n${_chalk().default.bold('Watch Usage')}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}r${_chalk().default.dim(
+        ' to restart Interactive Snapshot Mode.'
+      )}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}q${_chalk().default.dim(
+        ' to quit Interactive Snapshot Mode.'
+      )}`
+    ];
+    this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`);
+  }
+  _drawUIDone() {
+    this._pipe.write(CLEAR);
+    const numPass = this._countPaths - this._testAssertions.length;
+    let stats = _chalk().default.bold.dim(
+      `${(0, _jestUtil().pluralize)('snapshot', this._countPaths)} reviewed`
+    );
+    if (numPass) {
+      stats += `, ${_chalk().default.bold.green(
+        `${(0, _jestUtil().pluralize)('snapshot', numPass)} updated`
+      )}`;
+    }
+    const messages = [
+      `\n${_chalk().default.bold('Interactive Snapshot Result')}`,
+      ARROW + stats,
+      `\n${_chalk().default.bold('Watch Usage')}`,
+      `${_chalk().default.dim(`${ARROW}Press `)}Enter${_chalk().default.dim(
+        ' to return to watch mode.'
+      )}`
+    ];
+    this._pipe.write(`${messages.filter(Boolean).join('\n')}\n`);
+  }
+  _drawUIOverlay() {
+    if (this._testAssertions.length === 0) {
+      return this._drawUIDone();
+    }
+    if (this._testAssertions.length - this._skippedNum === 0) {
+      return this._drawUIDoneWithSkipped();
+    }
+    return this._drawUIProgress();
+  }
+  put(key) {
+    switch (key) {
+      case 's':
+        if (this._skippedNum === this._testAssertions.length) break;
+        this._skippedNum += 1;
+
+        // move skipped test to the end
+        this._testAssertions.push(this._testAssertions.shift());
+        if (this._testAssertions.length - this._skippedNum > 0) {
+          this._run(false);
+        } else {
+          this._drawUIDoneWithSkipped();
+        }
+        break;
+      case 'u':
+        this._run(true);
+        break;
+      case 'q':
+      case _jestWatcher().KEYS.ESCAPE:
+        this.abort();
+        break;
+      case 'r':
+        this.restart();
+        break;
+      case _jestWatcher().KEYS.ENTER:
+        if (this._testAssertions.length === 0) {
+          this.abort();
+        } else {
+          this._run(false);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  abort() {
+    this._isActive = false;
+    this._skippedNum = 0;
+    this._updateTestRunnerConfig(null, false);
+  }
+  restart() {
+    this._skippedNum = 0;
+    this._countPaths = this._testAssertions.length;
+    this._run(false);
+  }
+  updateWithResults(results) {
+    const hasSnapshotFailure = !!results.snapshot.failure;
+    if (hasSnapshotFailure) {
+      this._drawUIOverlay();
+      return;
+    }
+    this._testAssertions.shift();
+    if (this._testAssertions.length - this._skippedNum === 0) {
+      this._drawUIOverlay();
+      return;
+    }
+
+    // Go to the next test
+    this._run(false);
+  }
+  _run(shouldUpdateSnapshot) {
+    const testAssertion = this._testAssertions[0];
+    this._updateTestRunnerConfig(testAssertion, shouldUpdateSnapshot);
+  }
+  run(failedSnapshotTestAssertions, onConfigChange) {
+    if (!failedSnapshotTestAssertions.length) {
+      return;
+    }
+    this._testAssertions = [...failedSnapshotTestAssertions];
+    this._countPaths = this._testAssertions.length;
+    this._updateTestRunnerConfig = onConfigChange;
+    this._isActive = true;
+    this._run(false);
+  }
+}
+exports.default = SnapshotInteractiveMode;

frontend/node_modules/@jest/core/build/TestNamePatternPrompt.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+class TestNamePatternPrompt extends _jestWatcher().PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt, 'tests');
+  }
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+    this._printPrompt(pattern);
+  }
+  _printPrompt(pattern) {
+    const pipe = this._pipe;
+    (0, _jestWatcher().printPatternCaret)(pattern, pipe);
+    (0, _jestWatcher().printRestoredPatternCaret)(
+      pattern,
+      this._currentUsageRows,
+      pipe
+    );
+  }
+}
+exports.default = TestNamePatternPrompt;

frontend/node_modules/@jest/core/build/TestPathPatternPrompt.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+class TestPathPatternPrompt extends _jestWatcher().PatternPrompt {
+  constructor(pipe, prompt) {
+    super(pipe, prompt, 'filenames');
+  }
+  _onChange(pattern, options) {
+    super._onChange(pattern, options);
+    this._printPrompt(pattern);
+  }
+  _printPrompt(pattern) {
+    const pipe = this._pipe;
+    (0, _jestWatcher().printPatternCaret)(pattern, pipe);
+    (0, _jestWatcher().printRestoredPatternCaret)(
+      pattern,
+      this._currentUsageRows,
+      pipe
+    );
+  }
+}
+exports.default = TestPathPatternPrompt;

frontend/node_modules/@jest/core/build/TestScheduler.js

@@ -0,0 +1,463 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.createTestScheduler = createTestScheduler;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _ciInfo() {
+  const data = require('ci-info');
+  _ciInfo = function () {
+    return data;
+  };
+  return data;
+}
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+  _exit = function () {
+    return data;
+  };
+  return data;
+}
+function _reporters() {
+  const data = require('@jest/reporters');
+  _reporters = function () {
+    return data;
+  };
+  return data;
+}
+function _testResult() {
+  const data = require('@jest/test-result');
+  _testResult = function () {
+    return data;
+  };
+  return data;
+}
+function _transform() {
+  const data = require('@jest/transform');
+  _transform = function () {
+    return data;
+  };
+  return data;
+}
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+  _jestMessageUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+  _jestSnapshot = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+var _ReporterDispatcher = _interopRequireDefault(
+  require('./ReporterDispatcher')
+);
+var _testSchedulerHelper = require('./testSchedulerHelper');
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+async function createTestScheduler(globalConfig, context) {
+  const scheduler = new TestScheduler(globalConfig, context);
+  await scheduler._setupReporters();
+  return scheduler;
+}
+class TestScheduler {
+  _context;
+  _dispatcher;
+  _globalConfig;
+  constructor(globalConfig, context) {
+    this._context = context;
+    this._dispatcher = new _ReporterDispatcher.default();
+    this._globalConfig = globalConfig;
+  }
+  addReporter(reporter) {
+    this._dispatcher.register(reporter);
+  }
+  removeReporter(reporterConstructor) {
+    this._dispatcher.unregister(reporterConstructor);
+  }
+  async scheduleTests(tests, watcher) {
+    const onTestFileStart = this._dispatcher.onTestFileStart.bind(
+      this._dispatcher
+    );
+    const timings = [];
+    const testContexts = new Set();
+    tests.forEach(test => {
+      testContexts.add(test.context);
+      if (test.duration) {
+        timings.push(test.duration);
+      }
+    });
+    const aggregatedResults = createAggregatedResults(tests.length);
+    const estimatedTime = Math.ceil(
+      getEstimatedTime(timings, this._globalConfig.maxWorkers) / 1000
+    );
+    const runInBand = (0, _testSchedulerHelper.shouldRunInBand)(
+      tests,
+      timings,
+      this._globalConfig
+    );
+    const onResult = async (test, testResult) => {
+      if (watcher.isInterrupted()) {
+        return Promise.resolve();
+      }
+      if (testResult.testResults.length === 0) {
+        const message = 'Your test suite must contain at least one test.';
+        return onFailure(test, {
+          message,
+          stack: new Error(message).stack
+        });
+      }
+
+      // Throws when the context is leaked after executing a test.
+      if (testResult.leaks) {
+        const message =
+          `${_chalk().default.red.bold(
+            'EXPERIMENTAL FEATURE!\n'
+          )}Your test suite is leaking memory. Please ensure all references are cleaned.\n` +
+          '\n' +
+          'There is a number of things that can leak memory:\n' +
+          '  - Async operations that have not finished (e.g. fs.readFile).\n' +
+          '  - Timers not properly mocked (e.g. setInterval, setTimeout).\n' +
+          '  - Keeping references to the global scope.';
+        return onFailure(test, {
+          message,
+          stack: new Error(message).stack
+        });
+      }
+      (0, _testResult().addResult)(aggregatedResults, testResult);
+      await this._dispatcher.onTestFileResult(
+        test,
+        testResult,
+        aggregatedResults
+      );
+      return this._bailIfNeeded(testContexts, aggregatedResults, watcher);
+    };
+    const onFailure = async (test, error) => {
+      if (watcher.isInterrupted()) {
+        return;
+      }
+      const testResult = (0, _testResult().buildFailureTestResult)(
+        test.path,
+        error
+      );
+      testResult.failureMessage = (0, _jestMessageUtil().formatExecError)(
+        testResult.testExecError,
+        test.context.config,
+        this._globalConfig,
+        test.path
+      );
+      (0, _testResult().addResult)(aggregatedResults, testResult);
+      await this._dispatcher.onTestFileResult(
+        test,
+        testResult,
+        aggregatedResults
+      );
+    };
+    const updateSnapshotState = async () => {
+      const contextsWithSnapshotResolvers = await Promise.all(
+        Array.from(testContexts).map(async context => [
+          context,
+          await (0, _jestSnapshot().buildSnapshotResolver)(context.config)
+        ])
+      );
+      contextsWithSnapshotResolvers.forEach(([context, snapshotResolver]) => {
+        const status = (0, _jestSnapshot().cleanup)(
+          context.hasteFS,
+          this._globalConfig.updateSnapshot,
+          snapshotResolver,
+          context.config.testPathIgnorePatterns
+        );
+        aggregatedResults.snapshot.filesRemoved += status.filesRemoved;
+        aggregatedResults.snapshot.filesRemovedList = (
+          aggregatedResults.snapshot.filesRemovedList || []
+        ).concat(status.filesRemovedList);
+      });
+      const updateAll = this._globalConfig.updateSnapshot === 'all';
+      aggregatedResults.snapshot.didUpdate = updateAll;
+      aggregatedResults.snapshot.failure = !!(
+        !updateAll &&
+        (aggregatedResults.snapshot.unchecked ||
+          aggregatedResults.snapshot.unmatched ||
+          aggregatedResults.snapshot.filesRemoved)
+      );
+    };
+    await this._dispatcher.onRunStart(aggregatedResults, {
+      estimatedTime,
+      showStatus: !runInBand
+    });
+    const testRunners = Object.create(null);
+    const contextsByTestRunner = new WeakMap();
+    try {
+      await Promise.all(
+        Array.from(testContexts).map(async context => {
+          const {config} = context;
+          if (!testRunners[config.runner]) {
+            const transformer = await (0, _transform().createScriptTransformer)(
+              config
+            );
+            const Runner = await transformer.requireAndTranspileModule(
+              config.runner
+            );
+            const runner = new Runner(this._globalConfig, {
+              changedFiles: this._context.changedFiles,
+              sourcesRelatedToTestsInChangedFiles:
+                this._context.sourcesRelatedToTestsInChangedFiles
+            });
+            testRunners[config.runner] = runner;
+            contextsByTestRunner.set(runner, context);
+          }
+        })
+      );
+      const testsByRunner = this._partitionTests(testRunners, tests);
+      if (testsByRunner) {
+        try {
+          for (const runner of Object.keys(testRunners)) {
+            const testRunner = testRunners[runner];
+            const context = contextsByTestRunner.get(testRunner);
+            (0, _jestUtil().invariant)(context);
+            const tests = testsByRunner[runner];
+            const testRunnerOptions = {
+              serial: runInBand || Boolean(testRunner.isSerial)
+            };
+            if (testRunner.supportsEventEmitters) {
+              const unsubscribes = [
+                testRunner.on('test-file-start', ([test]) =>
+                  onTestFileStart(test)
+                ),
+                testRunner.on('test-file-success', ([test, testResult]) =>
+                  onResult(test, testResult)
+                ),
+                testRunner.on('test-file-failure', ([test, error]) =>
+                  onFailure(test, error)
+                ),
+                testRunner.on(
+                  'test-case-start',
+                  ([testPath, testCaseStartInfo]) => {
+                    const test = {
+                      context,
+                      path: testPath
+                    };
+                    this._dispatcher.onTestCaseStart(test, testCaseStartInfo);
+                  }
+                ),
+                testRunner.on(
+                  'test-case-result',
+                  ([testPath, testCaseResult]) => {
+                    const test = {
+                      context,
+                      path: testPath
+                    };
+                    this._dispatcher.onTestCaseResult(test, testCaseResult);
+                  }
+                )
+              ];
+              await testRunner.runTests(tests, watcher, testRunnerOptions);
+              unsubscribes.forEach(sub => sub());
+            } else {
+              await testRunner.runTests(
+                tests,
+                watcher,
+                onTestFileStart,
+                onResult,
+                onFailure,
+                testRunnerOptions
+              );
+            }
+          }
+        } catch (error) {
+          if (!watcher.isInterrupted()) {
+            throw error;
+          }
+        }
+      }
+    } catch (error) {
+      aggregatedResults.runExecError = buildExecError(error);
+      await this._dispatcher.onRunComplete(testContexts, aggregatedResults);
+      throw error;
+    }
+    await updateSnapshotState();
+    aggregatedResults.wasInterrupted = watcher.isInterrupted();
+    await this._dispatcher.onRunComplete(testContexts, aggregatedResults);
+    const anyTestFailures = !(
+      aggregatedResults.numFailedTests === 0 &&
+      aggregatedResults.numRuntimeErrorTestSuites === 0
+    );
+    const anyReporterErrors = this._dispatcher.hasErrors();
+    aggregatedResults.success = !(
+      anyTestFailures ||
+      aggregatedResults.snapshot.failure ||
+      anyReporterErrors
+    );
+    return aggregatedResults;
+  }
+  _partitionTests(testRunners, tests) {
+    if (Object.keys(testRunners).length > 1) {
+      return tests.reduce((testRuns, test) => {
+        const runner = test.context.config.runner;
+        if (!testRuns[runner]) {
+          testRuns[runner] = [];
+        }
+        testRuns[runner].push(test);
+        return testRuns;
+      }, Object.create(null));
+    } else if (tests.length > 0 && tests[0] != null) {
+      // If there is only one runner, don't partition the tests.
+      return Object.assign(Object.create(null), {
+        [tests[0].context.config.runner]: tests
+      });
+    } else {
+      return null;
+    }
+  }
+  async _setupReporters() {
+    const {collectCoverage: coverage, notify, verbose} = this._globalConfig;
+    const reporters = this._globalConfig.reporters || [['default', {}]];
+    let summaryOptions = null;
+    for (const [reporter, options] of reporters) {
+      switch (reporter) {
+        case 'default':
+          summaryOptions = options;
+          verbose
+            ? this.addReporter(
+                new (_reporters().VerboseReporter)(this._globalConfig)
+              )
+            : this.addReporter(
+                new (_reporters().DefaultReporter)(this._globalConfig)
+              );
+          break;
+        case 'github-actions':
+          _ciInfo().GITHUB_ACTIONS &&
+            this.addReporter(
+              new (_reporters().GitHubActionsReporter)(
+                this._globalConfig,
+                options
+              )
+            );
+          break;
+        case 'summary':
+          summaryOptions = options;
+          break;
+        default:
+          await this._addCustomReporter(reporter, options);
+      }
+    }
+    if (notify) {
+      this.addReporter(
+        new (_reporters().NotifyReporter)(this._globalConfig, this._context)
+      );
+    }
+    if (coverage) {
+      this.addReporter(
+        new (_reporters().CoverageReporter)(this._globalConfig, this._context)
+      );
+    }
+    if (summaryOptions != null) {
+      this.addReporter(
+        new (_reporters().SummaryReporter)(this._globalConfig, summaryOptions)
+      );
+    }
+  }
+  async _addCustomReporter(reporter, options) {
+    try {
+      const Reporter = await (0, _jestUtil().requireOrImportModule)(reporter);
+      this.addReporter(
+        new Reporter(this._globalConfig, options, this._context)
+      );
+    } catch (error) {
+      error.message = `An error occurred while adding the reporter at path "${_chalk().default.bold(
+        reporter
+      )}".\n${error instanceof Error ? error.message : ''}`;
+      throw error;
+    }
+  }
+  async _bailIfNeeded(testContexts, aggregatedResults, watcher) {
+    if (
+      this._globalConfig.bail !== 0 &&
+      aggregatedResults.numFailedTests >= this._globalConfig.bail
+    ) {
+      if (watcher.isWatchMode()) {
+        await watcher.setState({
+          interrupted: true
+        });
+        return;
+      }
+      try {
+        await this._dispatcher.onRunComplete(testContexts, aggregatedResults);
+      } finally {
+        const exitCode = this._globalConfig.testFailureExitCode;
+        (0, _exit().default)(exitCode);
+      }
+    }
+  }
+}
+const createAggregatedResults = numTotalTestSuites => {
+  const result = (0, _testResult().makeEmptyAggregatedTestResult)();
+  result.numTotalTestSuites = numTotalTestSuites;
+  result.startTime = Date.now();
+  result.success = false;
+  return result;
+};
+const getEstimatedTime = (timings, workers) => {
+  if (timings.length === 0) {
+    return 0;
+  }
+  const max = Math.max(...timings);
+  return timings.length <= workers
+    ? max
+    : Math.max(timings.reduce((sum, time) => sum + time) / workers, max);
+};
+const strToError = errString => {
+  const {message, stack} = (0, _jestMessageUtil().separateMessageFromStack)(
+    errString
+  );
+  if (stack.length > 0) {
+    return {
+      message,
+      stack
+    };
+  }
+  const error = new (_jestUtil().ErrorWithStack)(message, buildExecError);
+  return {
+    message,
+    stack: error.stack || ''
+  };
+};
+const buildExecError = err => {
+  if (typeof err === 'string' || err == null) {
+    return strToError(err || 'Error');
+  }
+  const anyErr = err;
+  if (typeof anyErr.message === 'string') {
+    if (typeof anyErr.stack === 'string' && anyErr.stack.length > 0) {
+      return anyErr;
+    }
+    return strToError(anyErr.message);
+  }
+  return strToError(JSON.stringify(err));
+};

frontend/node_modules/@jest/core/build/cli/index.js

@@ -0,0 +1,417 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.runCLI = runCLI;
+function _perf_hooks() {
+  const data = require('perf_hooks');
+  _perf_hooks = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+  _exit = function () {
+    return data;
+  };
+  return data;
+}
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+function _console() {
+  const data = require('@jest/console');
+  _console = function () {
+    return data;
+  };
+  return data;
+}
+function _jestConfig() {
+  const data = require('jest-config');
+  _jestConfig = function () {
+    return data;
+  };
+  return data;
+}
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+  _jestRuntime = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _collectHandles = require('../collectHandles');
+var _getChangedFilesPromise = _interopRequireDefault(
+  require('../getChangedFilesPromise')
+);
+var _getConfigsOfProjectsToRun = _interopRequireDefault(
+  require('../getConfigsOfProjectsToRun')
+);
+var _getProjectNamesMissingWarning = _interopRequireDefault(
+  require('../getProjectNamesMissingWarning')
+);
+var _getSelectProjectsMessage = _interopRequireDefault(
+  require('../getSelectProjectsMessage')
+);
+var _createContext = _interopRequireDefault(require('../lib/createContext'));
+var _handleDeprecationWarnings = _interopRequireDefault(
+  require('../lib/handleDeprecationWarnings')
+);
+var _logDebugMessages = _interopRequireDefault(
+  require('../lib/logDebugMessages')
+);
+var _runJest = _interopRequireDefault(require('../runJest'));
+var _watch = _interopRequireDefault(require('../watch'));
+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;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+const {print: preRunMessagePrint} = _jestUtil().preRunMessage;
+async function runCLI(argv, projects) {
+  _perf_hooks().performance.mark('jest/runCLI:start');
+  let results;
+
+  // If we output a JSON object, we can't write anything to stdout, since
+  // it'll break the JSON structure and it won't be valid.
+  const outputStream =
+    argv.json || argv.useStderr ? process.stderr : process.stdout;
+  const {globalConfig, configs, hasDeprecationWarnings} = await (0,
+  _jestConfig().readConfigs)(argv, projects);
+  if (argv.debug) {
+    (0, _logDebugMessages.default)(globalConfig, configs, outputStream);
+  }
+  if (argv.showConfig) {
+    (0, _logDebugMessages.default)(globalConfig, configs, process.stdout);
+    (0, _exit().default)(0);
+  }
+  if (argv.clearCache) {
+    // stick in a Set to dedupe the deletions
+    new Set(configs.map(config => config.cacheDirectory)).forEach(
+      cacheDirectory => {
+        fs().rmSync(cacheDirectory, {
+          force: true,
+          recursive: true
+        });
+        process.stdout.write(`Cleared ${cacheDirectory}\n`);
+      }
+    );
+    (0, _exit().default)(0);
+  }
+  const configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)(
+    configs,
+    {
+      ignoreProjects: argv.ignoreProjects,
+      selectProjects: argv.selectProjects
+    }
+  );
+  if (argv.selectProjects || argv.ignoreProjects) {
+    const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)(
+      configs,
+      {
+        ignoreProjects: argv.ignoreProjects,
+        selectProjects: argv.selectProjects
+      }
+    );
+    if (namesMissingWarning) {
+      outputStream.write(namesMissingWarning);
+    }
+    outputStream.write(
+      (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun, {
+        ignoreProjects: argv.ignoreProjects,
+        selectProjects: argv.selectProjects
+      })
+    );
+  }
+  await _run10000(
+    globalConfig,
+    configsOfProjectsToRun,
+    hasDeprecationWarnings,
+    outputStream,
+    r => {
+      results = r;
+    }
+  );
+  if (argv.watch || argv.watchAll) {
+    // If in watch mode, return the promise that will never resolve.
+    // If the watch mode is interrupted, watch should handle the process
+    // shutdown.
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    return new Promise(() => {});
+  }
+  if (!results) {
+    throw new Error(
+      'AggregatedResult must be present after test run is complete'
+    );
+  }
+  const {openHandles} = results;
+  if (openHandles && openHandles.length) {
+    const formatted = (0, _collectHandles.formatHandleErrors)(
+      openHandles,
+      configs[0]
+    );
+    const openHandlesString = (0, _jestUtil().pluralize)(
+      'open handle',
+      formatted.length,
+      's'
+    );
+    const message =
+      _chalk().default.red(
+        `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n`
+      ) + formatted.join('\n\n');
+    console.error(message);
+  }
+  _perf_hooks().performance.mark('jest/runCLI:end');
+  return {
+    globalConfig,
+    results
+  };
+}
+const buildContextsAndHasteMaps = async (
+  configs,
+  globalConfig,
+  outputStream
+) => {
+  const hasteMapInstances = Array(configs.length);
+  const contexts = await Promise.all(
+    configs.map(async (config, index) => {
+      (0, _jestUtil().createDirectory)(config.cacheDirectory);
+      const hasteMapInstance = await _jestRuntime().default.createHasteMap(
+        config,
+        {
+          console: new (_console().CustomConsole)(outputStream, outputStream),
+          maxWorkers: Math.max(
+            1,
+            Math.floor(globalConfig.maxWorkers / configs.length)
+          ),
+          resetCache: !config.cache,
+          watch: globalConfig.watch || globalConfig.watchAll,
+          watchman: globalConfig.watchman,
+          workerThreads: globalConfig.workerThreads
+        }
+      );
+      hasteMapInstances[index] = hasteMapInstance;
+      return (0, _createContext.default)(
+        config,
+        await hasteMapInstance.build()
+      );
+    })
+  );
+  return {
+    contexts,
+    hasteMapInstances
+  };
+};
+const _run10000 = async (
+  globalConfig,
+  configs,
+  hasDeprecationWarnings,
+  outputStream,
+  onComplete
+) => {
+  // Queries to hg/git can take a while, so we need to start the process
+  // as soon as possible, so by the time we need the result it's already there.
+  const changedFilesPromise = (0, _getChangedFilesPromise.default)(
+    globalConfig,
+    configs
+  );
+  if (changedFilesPromise) {
+    _perf_hooks().performance.mark('jest/getChangedFiles:start');
+    changedFilesPromise.finally(() => {
+      _perf_hooks().performance.mark('jest/getChangedFiles:end');
+    });
+  }
+
+  // Filter may need to do an HTTP call or something similar to setup.
+  // We will wait on an async response from this before using the filter.
+  let filter;
+  if (globalConfig.filter && !globalConfig.skipFilter) {
+    const rawFilter = require(globalConfig.filter);
+    let filterSetupPromise;
+    if (rawFilter.setup) {
+      // Wrap filter setup Promise to avoid "uncaught Promise" error.
+      // If an error is returned, we surface it in the return value.
+      filterSetupPromise = (async () => {
+        try {
+          await rawFilter.setup();
+        } catch (err) {
+          return err;
+        }
+        return undefined;
+      })();
+    }
+    filter = async testPaths => {
+      if (filterSetupPromise) {
+        // Expect an undefined return value unless there was an error.
+        const err = await filterSetupPromise;
+        if (err) {
+          throw err;
+        }
+      }
+      return rawFilter(testPaths);
+    };
+  }
+  _perf_hooks().performance.mark('jest/buildContextsAndHasteMaps:start');
+  const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps(
+    configs,
+    globalConfig,
+    outputStream
+  );
+  _perf_hooks().performance.mark('jest/buildContextsAndHasteMaps:end');
+  globalConfig.watch || globalConfig.watchAll
+    ? await runWatch(
+        contexts,
+        configs,
+        hasDeprecationWarnings,
+        globalConfig,
+        outputStream,
+        hasteMapInstances,
+        filter
+      )
+    : await runWithoutWatch(
+        globalConfig,
+        contexts,
+        outputStream,
+        onComplete,
+        changedFilesPromise,
+        filter
+      );
+};
+const runWatch = async (
+  contexts,
+  _configs,
+  hasDeprecationWarnings,
+  globalConfig,
+  outputStream,
+  hasteMapInstances,
+  filter
+) => {
+  if (hasDeprecationWarnings) {
+    try {
+      await (0, _handleDeprecationWarnings.default)(
+        outputStream,
+        process.stdin
+      );
+      return await (0, _watch.default)(
+        globalConfig,
+        contexts,
+        outputStream,
+        hasteMapInstances,
+        undefined,
+        undefined,
+        filter
+      );
+    } catch {
+      (0, _exit().default)(0);
+    }
+  }
+  return (0, _watch.default)(
+    globalConfig,
+    contexts,
+    outputStream,
+    hasteMapInstances,
+    undefined,
+    undefined,
+    filter
+  );
+};
+const runWithoutWatch = async (
+  globalConfig,
+  contexts,
+  outputStream,
+  onComplete,
+  changedFilesPromise,
+  filter
+) => {
+  const startRun = async () => {
+    if (!globalConfig.listTests) {
+      preRunMessagePrint(outputStream);
+    }
+    return (0, _runJest.default)({
+      changedFilesPromise,
+      contexts,
+      failedTestsCache: undefined,
+      filter,
+      globalConfig,
+      onComplete,
+      outputStream,
+      startRun,
+      testWatcher: new (_jestWatcher().TestWatcher)({
+        isWatchMode: false
+      })
+    });
+  };
+  return startRun();
+};

frontend/node_modules/@jest/core/build/collectHandles.js

@@ -0,0 +1,266 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = collectHandles;
+exports.formatHandleErrors = formatHandleErrors;
+function asyncHooks() {
+  const data = _interopRequireWildcard(require('async_hooks'));
+  asyncHooks = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require('util');
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function v8() {
+  const data = _interopRequireWildcard(require('v8'));
+  v8 = function () {
+    return data;
+  };
+  return data;
+}
+function vm() {
+  const data = _interopRequireWildcard(require('vm'));
+  vm = function () {
+    return data;
+  };
+  return data;
+}
+function _stripAnsi() {
+  const data = _interopRequireDefault(require('strip-ansi'));
+  _stripAnsi = function () {
+    return data;
+  };
+  return data;
+}
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+  _jestMessageUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+/**
+ * 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.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+
+function stackIsFromUser(stack) {
+  // Either the test file, or something required by it
+  if (stack.includes('Runtime.requireModule')) {
+    return true;
+  }
+
+  // jest-jasmine it or describe call
+  if (stack.includes('asyncJestTest') || stack.includes('asyncJestLifecycle')) {
+    return true;
+  }
+
+  // An async function call from within circus
+  if (stack.includes('callAsyncCircusFn')) {
+    // jest-circus it or describe call
+    return (
+      stack.includes('_callCircusTest') || stack.includes('_callCircusHook')
+    );
+  }
+  return false;
+}
+const alwaysActive = () => true;
+
+// @ts-expect-error: doesn't exist in v12 typings
+const hasWeakRef = typeof WeakRef === 'function';
+const asyncSleep = (0, _util().promisify)(setTimeout);
+let gcFunc = globalThis.gc;
+function runGC() {
+  if (!gcFunc) {
+    v8().setFlagsFromString('--expose-gc');
+    gcFunc = vm().runInNewContext('gc');
+    v8().setFlagsFromString('--no-expose-gc');
+    if (!gcFunc) {
+      throw new Error(
+        'Cannot find `global.gc` function. Please run node with `--expose-gc` and report this issue in jest repo.'
+      );
+    }
+  }
+  gcFunc();
+}
+
+// Inspired by https://github.com/mafintosh/why-is-node-running/blob/master/index.js
+// Extracted as we want to format the result ourselves
+function collectHandles() {
+  const activeHandles = new Map();
+  const hook = asyncHooks().createHook({
+    destroy(asyncId) {
+      activeHandles.delete(asyncId);
+    },
+    init: function initHook(asyncId, type, triggerAsyncId, resource) {
+      // Skip resources that should not generally prevent the process from
+      // exiting, not last a meaningfully long time, or otherwise shouldn't be
+      // tracked.
+      if (
+        type === 'PROMISE' ||
+        type === 'TIMERWRAP' ||
+        type === 'ELDHISTOGRAM' ||
+        type === 'PerformanceObserver' ||
+        type === 'RANDOMBYTESREQUEST' ||
+        type === 'DNSCHANNEL' ||
+        type === 'ZLIB' ||
+        type === 'SIGNREQUEST'
+      ) {
+        return;
+      }
+      const error = new (_jestUtil().ErrorWithStack)(type, initHook, 100);
+      let fromUser = stackIsFromUser(error.stack || '');
+
+      // If the async resource was not directly created by user code, but was
+      // triggered by another async resource from user code, track it and use
+      // the original triggering resource's stack.
+      if (!fromUser) {
+        const triggeringHandle = activeHandles.get(triggerAsyncId);
+        if (triggeringHandle) {
+          fromUser = true;
+          error.stack = triggeringHandle.error.stack;
+        }
+      }
+      if (fromUser) {
+        let isActive;
+
+        // Handle that supports hasRef
+        if ('hasRef' in resource) {
+          if (hasWeakRef) {
+            // @ts-expect-error: doesn't exist in v12 typings
+            const ref = new WeakRef(resource);
+            isActive = () => {
+              return ref.deref()?.hasRef() ?? false;
+            };
+          } else {
+            isActive = resource.hasRef.bind(resource);
+          }
+        } else {
+          // Handle that doesn't support hasRef
+          isActive = alwaysActive;
+        }
+        activeHandles.set(asyncId, {
+          error,
+          isActive
+        });
+      }
+    }
+  });
+  hook.enable();
+  return async () => {
+    // Wait briefly for any async resources that have been queued for
+    // destruction to actually be destroyed.
+    // For example, Node.js TCP Servers are not destroyed until *after* their
+    // `close` callback runs. If someone finishes a test from the `close`
+    // callback, we will not yet have seen the resource be destroyed here.
+    await asyncSleep(100);
+    if (activeHandles.size > 0) {
+      // For some special objects such as `TLSWRAP`.
+      // Ref: https://github.com/jestjs/jest/issues/11665
+      runGC();
+      await asyncSleep(0);
+    }
+    hook.disable();
+
+    // Get errors for every async resource still referenced at this moment
+    const result = Array.from(activeHandles.values())
+      .filter(({isActive}) => isActive())
+      .map(({error}) => error);
+    activeHandles.clear();
+    return result;
+  };
+}
+function formatHandleErrors(errors, config) {
+  const stacks = new Set();
+  return (
+    errors
+      .map(err =>
+        (0, _jestMessageUtil().formatExecError)(
+          err,
+          config,
+          {
+            noStackTrace: false
+          },
+          undefined,
+          true
+        )
+      )
+      // E.g. timeouts might give multiple traces to the same line of code
+      // This hairy filtering tries to remove entries with duplicate stack traces
+      .filter(handle => {
+        const ansiFree = (0, _stripAnsi().default)(handle);
+        const match = ansiFree.match(/\s+at(.*)/);
+        if (!match || match.length < 2) {
+          return true;
+        }
+        const stack = ansiFree.substr(ansiFree.indexOf(match[1])).trim();
+        if (stacks.has(stack)) {
+          return false;
+        }
+        stacks.add(stack);
+        return true;
+      })
+  );
+}

frontend/node_modules/@jest/core/build/getChangedFilesPromise.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getChangedFilesPromise;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestChangedFiles() {
+  const data = require('jest-changed-files');
+  _jestChangedFiles = function () {
+    return data;
+  };
+  return data;
+}
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+  _jestMessageUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getChangedFilesPromise(globalConfig, configs) {
+  if (globalConfig.onlyChanged) {
+    const allRootsForAllProjects = configs.reduce((roots, config) => {
+      if (config.roots) {
+        roots.push(...config.roots);
+      }
+      return roots;
+    }, []);
+    return (0, _jestChangedFiles().getChangedFilesForRoots)(
+      allRootsForAllProjects,
+      {
+        changedSince: globalConfig.changedSince,
+        lastCommit: globalConfig.lastCommit,
+        withAncestor: globalConfig.changedFilesWithAncestor
+      }
+    ).catch(e => {
+      const message = (0, _jestMessageUtil().formatExecError)(e, configs[0], {
+        noStackTrace: true
+      })
+        .split('\n')
+        .filter(line => !line.includes('Command failed:'))
+        .join('\n');
+      console.error(_chalk().default.red(`\n\n${message}`));
+      process.exit(1);
+    });
+  }
+  return undefined;
+}

frontend/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getConfigsOfProjectsToRun;
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getConfigsOfProjectsToRun(projectConfigs, opts) {
+  const projectFilter = createProjectFilter(opts);
+  return projectConfigs.filter(config => {
+    const name = (0, _getProjectDisplayName.default)(config);
+    return projectFilter(name);
+  });
+}
+function createProjectFilter(opts) {
+  const {selectProjects, ignoreProjects} = opts;
+  const always = () => true;
+  const selected = selectProjects
+    ? name => name && selectProjects.includes(name)
+    : always;
+  const notIgnore = ignoreProjects
+    ? name => !(name && ignoreProjects.includes(name))
+    : always;
+  function test(name) {
+    return selected(name) && notIgnore(name);
+  }
+  return test;
+}

frontend/node_modules/@jest/core/build/getNoTestFound.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFound;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestFound(testRunData, globalConfig, willExitWith0) {
+  const testFiles = testRunData.reduce(
+    (current, testRun) => current + (testRun.matches.total || 0),
+    0
+  );
+  let dataMessage;
+  if (globalConfig.runTestsByPath) {
+    dataMessage = `Files: ${globalConfig.nonFlagArgs
+      .map(p => `"${p}"`)
+      .join(', ')}`;
+  } else {
+    dataMessage = `Pattern: ${_chalk().default.yellow(
+      globalConfig.testPathPattern
+    )} - 0 matches`;
+  }
+  if (willExitWith0) {
+    return (
+      `${_chalk().default.bold('No tests found, exiting with code 0')}\n` +
+      `In ${_chalk().default.bold(globalConfig.rootDir)}` +
+      '\n' +
+      `  ${(0, _jestUtil().pluralize)(
+        'file',
+        testFiles,
+        's'
+      )} checked across ${(0, _jestUtil().pluralize)(
+        'project',
+        testRunData.length,
+        's'
+      )}. Run with \`--verbose\` for more details.` +
+      `\n${dataMessage}`
+    );
+  }
+  return (
+    `${_chalk().default.bold('No tests found, exiting with code 1')}\n` +
+    'Run with `--passWithNoTests` to exit with code 0' +
+    '\n' +
+    `In ${_chalk().default.bold(globalConfig.rootDir)}` +
+    '\n' +
+    `  ${(0, _jestUtil().pluralize)(
+      'file',
+      testFiles,
+      's'
+    )} checked across ${(0, _jestUtil().pluralize)(
+      'project',
+      testRunData.length,
+      's'
+    )}. Run with \`--verbose\` for more details.` +
+    `\n${dataMessage}`
+  );
+}

frontend/node_modules/@jest/core/build/getNoTestFoundFailed.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundFailed;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestFoundFailed(globalConfig) {
+  let msg = _chalk().default.bold('No failed test found.');
+  if (_jestUtil().isInteractive) {
+    msg += _chalk().default.dim(
+      `\n${
+        globalConfig.watch
+          ? 'Press `f` to quit "only failed tests" mode.'
+          : 'Run Jest without `--onlyFailures` or with `--all` to run all tests.'
+      }`
+    );
+  }
+  return msg;
+}

frontend/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundPassWithNoTests;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestFoundPassWithNoTests() {
+  return _chalk().default.bold('No tests found, exiting with code 0');
+}

frontend/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundRelatedToChangedFiles;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestFoundRelatedToChangedFiles(globalConfig) {
+  const ref = globalConfig.changedSince
+    ? `"${globalConfig.changedSince}"`
+    : 'last commit';
+  let msg = _chalk().default.bold(
+    `No tests found related to files changed since ${ref}.`
+  );
+  if (_jestUtil().isInteractive) {
+    msg += _chalk().default.dim(
+      `\n${
+        globalConfig.watch
+          ? 'Press `a` to run all tests, or run Jest with `--watchAll`.'
+          : 'Run Jest without `-o` or with `--all` to run all tests.'
+      }`
+    );
+  }
+  return msg;
+}

frontend/node_modules/@jest/core/build/getNoTestFoundVerbose.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestFoundVerbose;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestFoundVerbose(testRunData, globalConfig, willExitWith0) {
+  const individualResults = testRunData.map(testRun => {
+    const stats = testRun.matches.stats || {};
+    const config = testRun.context.config;
+    const statsMessage = Object.keys(stats)
+      .map(key => {
+        if (key === 'roots' && config.roots.length === 1) {
+          return null;
+        }
+        const value = config[key];
+        if (value) {
+          const valueAsString = Array.isArray(value)
+            ? value.join(', ')
+            : String(value);
+          const matches = (0, _jestUtil().pluralize)(
+            'match',
+            stats[key] || 0,
+            'es'
+          );
+          return `  ${key}: ${_chalk().default.yellow(
+            valueAsString
+          )} - ${matches}`;
+        }
+        return null;
+      })
+      .filter(line => line)
+      .join('\n');
+    return testRun.matches.total
+      ? `In ${_chalk().default.bold(config.rootDir)}\n` +
+          `  ${(0, _jestUtil().pluralize)(
+            'file',
+            testRun.matches.total || 0,
+            's'
+          )} checked.\n${statsMessage}`
+      : `No files found in ${config.rootDir}.\n` +
+          "Make sure Jest's configuration does not exclude this directory." +
+          '\nTo set up Jest, make sure a package.json file exists.\n' +
+          'Jest Documentation: ' +
+          'https://jestjs.io/docs/configuration';
+  });
+  let dataMessage;
+  if (globalConfig.runTestsByPath) {
+    dataMessage = `Files: ${globalConfig.nonFlagArgs
+      .map(p => `"${p}"`)
+      .join(', ')}`;
+  } else {
+    dataMessage = `Pattern: ${_chalk().default.yellow(
+      globalConfig.testPathPattern
+    )} - 0 matches`;
+  }
+  if (willExitWith0) {
+    return `${_chalk().default.bold(
+      'No tests found, exiting with code 0'
+    )}\n${individualResults.join('\n')}\n${dataMessage}`;
+  }
+  return (
+    `${_chalk().default.bold('No tests found, exiting with code 1')}\n` +
+    'Run with `--passWithNoTests` to exit with code 0' +
+    `\n${individualResults.join('\n')}\n${dataMessage}`
+  );
+}

frontend/node_modules/@jest/core/build/getNoTestsFoundMessage.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getNoTestsFoundMessage;
+var _getNoTestFound = _interopRequireDefault(require('./getNoTestFound'));
+var _getNoTestFoundFailed = _interopRequireDefault(
+  require('./getNoTestFoundFailed')
+);
+var _getNoTestFoundPassWithNoTests = _interopRequireDefault(
+  require('./getNoTestFoundPassWithNoTests')
+);
+var _getNoTestFoundRelatedToChangedFiles = _interopRequireDefault(
+  require('./getNoTestFoundRelatedToChangedFiles')
+);
+var _getNoTestFoundVerbose = _interopRequireDefault(
+  require('./getNoTestFoundVerbose')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getNoTestsFoundMessage(testRunData, globalConfig) {
+  const exitWith0 =
+    globalConfig.passWithNoTests ||
+    globalConfig.lastCommit ||
+    globalConfig.onlyChanged;
+  if (globalConfig.onlyFailures) {
+    return {
+      exitWith0,
+      message: (0, _getNoTestFoundFailed.default)(globalConfig)
+    };
+  }
+  if (globalConfig.onlyChanged) {
+    return {
+      exitWith0,
+      message: (0, _getNoTestFoundRelatedToChangedFiles.default)(globalConfig)
+    };
+  }
+  if (globalConfig.passWithNoTests) {
+    return {
+      exitWith0,
+      message: (0, _getNoTestFoundPassWithNoTests.default)()
+    };
+  }
+  return {
+    exitWith0,
+    message:
+      testRunData.length === 1 || globalConfig.verbose
+        ? (0, _getNoTestFoundVerbose.default)(
+            testRunData,
+            globalConfig,
+            exitWith0
+          )
+        : (0, _getNoTestFound.default)(testRunData, globalConfig, exitWith0)
+  };
+}

frontend/node_modules/@jest/core/build/getProjectDisplayName.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getProjectDisplayName;
+/**
+ * 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.
+ */
+
+function getProjectDisplayName(projectConfig) {
+  return projectConfig.displayName?.name || undefined;
+}

frontend/node_modules/@jest/core/build/getProjectNamesMissingWarning.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getProjectNamesMissingWarning;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getProjectNamesMissingWarning(projectConfigs, opts) {
+  const numberOfProjectsWithoutAName = projectConfigs.filter(
+    config => !(0, _getProjectDisplayName.default)(config)
+  ).length;
+  if (numberOfProjectsWithoutAName === 0) {
+    return undefined;
+  }
+  const args = [];
+  if (opts.selectProjects) {
+    args.push('--selectProjects');
+  }
+  if (opts.ignoreProjects) {
+    args.push('--ignoreProjects');
+  }
+  return _chalk().default.yellow(
+    `You provided values for ${args.join(' and ')} but ${
+      numberOfProjectsWithoutAName === 1
+        ? 'a project does not have a name'
+        : `${numberOfProjectsWithoutAName} projects do not have a name`
+    }.\n` +
+      'Set displayName in the config of all projects in order to disable this warning.\n'
+  );
+}

frontend/node_modules/@jest/core/build/getSelectProjectsMessage.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getSelectProjectsMessage;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+var _getProjectDisplayName = _interopRequireDefault(
+  require('./getProjectDisplayName')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function getSelectProjectsMessage(projectConfigs, opts) {
+  if (projectConfigs.length === 0) {
+    return getNoSelectionWarning(opts);
+  }
+  return getProjectsRunningMessage(projectConfigs);
+}
+function getNoSelectionWarning(opts) {
+  if (opts.ignoreProjects && opts.selectProjects) {
+    return _chalk().default.yellow(
+      'You provided values for --selectProjects and --ignoreProjects, but no projects were found matching the selection.\n' +
+        'Are you ignoring all the selected projects?\n'
+    );
+  } else if (opts.ignoreProjects) {
+    return _chalk().default.yellow(
+      'You provided values for --ignoreProjects, but no projects were found matching the selection.\n' +
+        'Are you ignoring all projects?\n'
+    );
+  } else if (opts.selectProjects) {
+    return _chalk().default.yellow(
+      'You provided values for --selectProjects but no projects were found matching the selection.\n'
+    );
+  } else {
+    return _chalk().default.yellow('No projects were found.\n');
+  }
+}
+function getProjectsRunningMessage(projectConfigs) {
+  if (projectConfigs.length === 1) {
+    const name =
+      (0, _getProjectDisplayName.default)(projectConfigs[0]) ??
+      '<unnamed project>';
+    return `Running one project: ${_chalk().default.bold(name)}\n`;
+  }
+  const projectsList = projectConfigs
+    .map(getProjectNameListElement)
+    .sort()
+    .join('\n');
+  return `Running ${projectConfigs.length} projects:\n${projectsList}\n`;
+}
+function getProjectNameListElement(projectConfig) {
+  const name = (0, _getProjectDisplayName.default)(projectConfig);
+  const elementContent = name
+    ? _chalk().default.bold(name)
+    : '<unnamed project>';
+  return `- ${elementContent}`;
+}

frontend/node_modules/@jest/core/build/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+import {AggregatedResult} from '@jest/test-result';
+import {BaseReporter} from '@jest/reporters';
+import type {ChangedFiles} from 'jest-changed-files';
+import type {Config} from '@jest/types';
+import {Reporter} from '@jest/reporters';
+import {ReporterContext} from '@jest/reporters';
+import {Test} from '@jest/test-result';
+import type {TestContext} from '@jest/test-result';
+import type {TestRunnerContext} from 'jest-runner';
+import type {TestWatcher} from 'jest-watcher';
+
+export declare function createTestScheduler(
+  globalConfig: Config.GlobalConfig,
+  context: TestSchedulerContext,
+): Promise<TestScheduler>;
+
+declare type Filter = (testPaths: Array<string>) => Promise<{
+  filtered: Array<FilterResult>;
+}>;
+
+declare type FilterResult = {
+  test: string;
+  message: string;
+};
+
+export declare function getVersion(): string;
+
+declare type ReporterConstructor = new (
+  globalConfig: Config.GlobalConfig,
+  reporterConfig: Record<string, unknown>,
+  reporterContext: ReporterContext,
+) => BaseReporter;
+
+export declare function runCLI(
+  argv: Config.Argv,
+  projects: Array<string>,
+): Promise<{
+  results: AggregatedResult;
+  globalConfig: Config.GlobalConfig;
+}>;
+
+declare type SearchResult = {
+  noSCM?: boolean;
+  stats?: Stats;
+  collectCoverageFrom?: Set<string>;
+  tests: Array<Test>;
+  total?: number;
+};
+
+export declare class SearchSource {
+  private readonly _context;
+  private _dependencyResolver;
+  private readonly _testPathCases;
+  constructor(context: TestContext);
+  private _getOrBuildDependencyResolver;
+  private _filterTestPathsWithStats;
+  private _getAllTestPaths;
+  isTestFilePath(path: string): boolean;
+  findMatchingTests(testPathPattern: string): SearchResult;
+  findRelatedTests(
+    allPaths: Set<string>,
+    collectCoverage: boolean,
+  ): Promise<SearchResult>;
+  findTestsByPaths(paths: Array<string>): SearchResult;
+  findRelatedTestsFromPattern(
+    paths: Array<string>,
+    collectCoverage: boolean,
+  ): Promise<SearchResult>;
+  findTestRelatedToChangedFiles(
+    changedFilesInfo: ChangedFiles,
+    collectCoverage: boolean,
+  ): Promise<SearchResult>;
+  private _getTestPaths;
+  filterPathsWin32(paths: Array<string>): Array<string>;
+  getTestPaths(
+    globalConfig: Config.GlobalConfig,
+    changedFiles?: ChangedFiles,
+    filter?: Filter,
+  ): Promise<SearchResult>;
+  findRelatedSourcesFromTestsInChangedFiles(
+    changedFilesInfo: ChangedFiles,
+  ): Promise<Array<string>>;
+}
+
+declare type Stats = {
+  roots: number;
+  testMatch: number;
+  testPathIgnorePatterns: number;
+  testRegex: number;
+  testPathPattern?: number;
+};
+
+declare class TestScheduler {
+  private readonly _context;
+  private readonly _dispatcher;
+  private readonly _globalConfig;
+  constructor(globalConfig: Config.GlobalConfig, context: TestSchedulerContext);
+  addReporter(reporter: Reporter): void;
+  removeReporter(reporterConstructor: ReporterConstructor): void;
+  scheduleTests(
+    tests: Array<Test>,
+    watcher: TestWatcher,
+  ): Promise<AggregatedResult>;
+  private _partitionTests;
+  _setupReporters(): Promise<void>;
+  private _addCustomReporter;
+  private _bailIfNeeded;
+}
+
+declare type TestSchedulerContext = ReporterContext & TestRunnerContext;
+
+export {};

frontend/node_modules/@jest/core/build/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'SearchSource', {
+  enumerable: true,
+  get: function () {
+    return _SearchSource.default;
+  }
+});
+Object.defineProperty(exports, 'createTestScheduler', {
+  enumerable: true,
+  get: function () {
+    return _TestScheduler.createTestScheduler;
+  }
+});
+Object.defineProperty(exports, 'getVersion', {
+  enumerable: true,
+  get: function () {
+    return _version.default;
+  }
+});
+Object.defineProperty(exports, 'runCLI', {
+  enumerable: true,
+  get: function () {
+    return _cli.runCLI;
+  }
+});
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+var _TestScheduler = require('./TestScheduler');
+var _cli = require('./cli');
+var _version = _interopRequireDefault(require('./version'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}

frontend/node_modules/@jest/core/build/lib/activeFiltersMessage.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+const activeFilters = globalConfig => {
+  const {testNamePattern, testPathPattern} = globalConfig;
+  if (testNamePattern || testPathPattern) {
+    const filters = [
+      testPathPattern
+        ? _chalk().default.dim('filename ') +
+          _chalk().default.yellow(`/${testPathPattern}/`)
+        : null,
+      testNamePattern
+        ? _chalk().default.dim('test name ') +
+          _chalk().default.yellow(`/${testNamePattern}/`)
+        : null
+    ]
+      .filter(_jestUtil().isNonNullable)
+      .join(', ');
+    const messages = `\n${_chalk().default.bold('Active Filters: ')}${filters}`;
+    return messages;
+  }
+  return '';
+};
+var _default = activeFilters;
+exports.default = _default;

frontend/node_modules/@jest/core/build/lib/createContext.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = createContext;
+function _jestRuntime() {
+  const data = _interopRequireDefault(require('jest-runtime'));
+  _jestRuntime = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function createContext(config, {hasteFS, moduleMap}) {
+  return {
+    config,
+    hasteFS,
+    moduleMap,
+    resolver: _jestRuntime().default.createResolver(config, moduleMap)
+  };
+}

frontend/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = handleDeprecationWarnings;
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+function handleDeprecationWarnings(pipe, stdin = process.stdin) {
+  return new Promise((resolve, reject) => {
+    if (typeof stdin.setRawMode === 'function') {
+      const messages = [
+        _chalk().default.red('There are deprecation warnings.\n'),
+        `${_chalk().default.dim(' \u203A Press ')}Enter${_chalk().default.dim(
+          ' to continue.'
+        )}`,
+        `${_chalk().default.dim(' \u203A Press ')}Esc${_chalk().default.dim(
+          ' to exit.'
+        )}`
+      ];
+      pipe.write(messages.join('\n'));
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding('utf8');
+      // this is a string since we set encoding above
+      stdin.on('data', key => {
+        if (key === _jestWatcher().KEYS.ENTER) {
+          resolve();
+        } else if (
+          [
+            _jestWatcher().KEYS.ESCAPE,
+            _jestWatcher().KEYS.CONTROL_C,
+            _jestWatcher().KEYS.CONTROL_D
+          ].indexOf(key) !== -1
+        ) {
+          reject();
+        }
+      });
+    } else {
+      resolve();
+    }
+  });
+}

frontend/node_modules/@jest/core/build/lib/isValidPath.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = isValidPath;
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+  _jestSnapshot = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+function isValidPath(globalConfig, filePath) {
+  return (
+    !filePath.includes(globalConfig.coverageDirectory) &&
+    !(0, _jestSnapshot().isSnapshotPath)(filePath)
+  );
+}

frontend/node_modules/@jest/core/build/lib/logDebugMessages.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = logDebugMessages;
+/**
+ * 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.
+ */
+
+const VERSION = require('../../package.json').version;
+
+// if the output here changes, update `getConfig` in e2e/runJest.ts
+function logDebugMessages(globalConfig, configs, outputStream) {
+  const output = {
+    configs,
+    globalConfig,
+    version: VERSION
+  };
+  outputStream.write(`${JSON.stringify(output, null, '  ')}\n`);
+}

frontend/node_modules/@jest/core/build/lib/updateGlobalConfig.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = updateGlobalConfig;
+function _jestRegexUtil() {
+  const data = require('jest-regex-util');
+  _jestRegexUtil = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+function updateGlobalConfig(globalConfig, options = {}) {
+  const newConfig = {
+    ...globalConfig
+  };
+  if (options.mode === 'watch') {
+    newConfig.watch = true;
+    newConfig.watchAll = false;
+  } else if (options.mode === 'watchAll') {
+    newConfig.watch = false;
+    newConfig.watchAll = true;
+  }
+  if (options.testNamePattern !== undefined) {
+    newConfig.testNamePattern = options.testNamePattern || '';
+  }
+  if (options.testPathPattern !== undefined) {
+    newConfig.testPathPattern =
+      (0, _jestRegexUtil().replacePathSepForRegex)(options.testPathPattern) ||
+      '';
+  }
+  newConfig.onlyChanged =
+    !newConfig.watchAll &&
+    !newConfig.testNamePattern &&
+    !newConfig.testPathPattern;
+  if (typeof options.bail === 'boolean') {
+    newConfig.bail = options.bail ? 1 : 0;
+  } else if (options.bail !== undefined) {
+    newConfig.bail = options.bail;
+  }
+  if (options.changedSince !== undefined) {
+    newConfig.changedSince = options.changedSince;
+  }
+  if (options.collectCoverage !== undefined) {
+    newConfig.collectCoverage = options.collectCoverage || false;
+  }
+  if (options.collectCoverageFrom !== undefined) {
+    newConfig.collectCoverageFrom = options.collectCoverageFrom;
+  }
+  if (options.coverageDirectory !== undefined) {
+    newConfig.coverageDirectory = options.coverageDirectory;
+  }
+  if (options.coverageReporters !== undefined) {
+    newConfig.coverageReporters = options.coverageReporters;
+  }
+  if (options.findRelatedTests !== undefined) {
+    newConfig.findRelatedTests = options.findRelatedTests;
+  }
+  if (options.nonFlagArgs !== undefined) {
+    newConfig.nonFlagArgs = options.nonFlagArgs;
+  }
+  if (options.noSCM) {
+    newConfig.noSCM = true;
+  }
+  if (options.notify !== undefined) {
+    newConfig.notify = options.notify || false;
+  }
+  if (options.notifyMode !== undefined) {
+    newConfig.notifyMode = options.notifyMode;
+  }
+  if (options.onlyFailures !== undefined) {
+    newConfig.onlyFailures = options.onlyFailures || false;
+  }
+  if (options.passWithNoTests !== undefined) {
+    newConfig.passWithNoTests = true;
+  }
+  if (options.reporters !== undefined) {
+    newConfig.reporters = options.reporters;
+  }
+  if (options.updateSnapshot !== undefined) {
+    newConfig.updateSnapshot = options.updateSnapshot;
+  }
+  if (options.verbose !== undefined) {
+    newConfig.verbose = options.verbose || false;
+  }
+  return Object.freeze(newConfig);
+}

frontend/node_modules/@jest/core/build/lib/watchPluginsHelpers.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getSortedUsageRows = exports.filterInteractivePlugins = void 0;
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+const filterInteractivePlugins = (watchPlugins, globalConfig) => {
+  const usageInfos = watchPlugins.map(
+    p => p.getUsageInfo && p.getUsageInfo(globalConfig)
+  );
+  return watchPlugins.filter((_plugin, i) => {
+    const usageInfo = usageInfos[i];
+    if (usageInfo) {
+      const {key} = usageInfo;
+      return !usageInfos.slice(i + 1).some(u => !!u && key === u.key);
+    }
+    return false;
+  });
+};
+exports.filterInteractivePlugins = filterInteractivePlugins;
+const getSortedUsageRows = (watchPlugins, globalConfig) =>
+  filterInteractivePlugins(watchPlugins, globalConfig)
+    .sort((a, b) => {
+      if (a.isInternal && b.isInternal) {
+        // internal plugins in the order we specify them
+        return 0;
+      }
+      if (a.isInternal !== b.isInternal) {
+        // external plugins afterwards
+        return a.isInternal ? -1 : 1;
+      }
+      const usageInfoA = a.getUsageInfo && a.getUsageInfo(globalConfig);
+      const usageInfoB = b.getUsageInfo && b.getUsageInfo(globalConfig);
+      if (usageInfoA && usageInfoB) {
+        // external plugins in alphabetical order
+        return usageInfoA.key.localeCompare(usageInfoB.key);
+      }
+      return 0;
+    })
+    .map(p => p.getUsageInfo && p.getUsageInfo(globalConfig))
+    .filter(_jestUtil().isNonNullable);
+exports.getSortedUsageRows = getSortedUsageRows;

frontend/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _FailedTestsInteractiveMode = _interopRequireDefault(
+  require('../FailedTestsInteractiveMode')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+class FailedTestsInteractivePlugin extends _jestWatcher().BaseWatchPlugin {
+  _failedTestAssertions;
+  _manager = new _FailedTestsInteractiveMode.default(this._stdout);
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._failedTestAssertions = this.getFailedTestAssertions(results);
+      if (this._manager.isActive()) this._manager.updateWithResults(results);
+    });
+  }
+  getUsageInfo() {
+    if (this._failedTestAssertions?.length) {
+      return {
+        key: 'i',
+        prompt: 'run failing tests interactively'
+      };
+    }
+    return null;
+  }
+  onKey(key) {
+    if (this._manager.isActive()) {
+      this._manager.put(key);
+    }
+  }
+  run(_, updateConfigAndRun) {
+    return new Promise(resolve => {
+      if (
+        !this._failedTestAssertions ||
+        this._failedTestAssertions.length === 0
+      ) {
+        resolve();
+        return;
+      }
+      this._manager.run(this._failedTestAssertions, failure => {
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern: failure ? `^${failure.fullName}$` : '',
+          testPathPattern: failure?.path || ''
+        });
+        if (!this._manager.isActive()) {
+          resolve();
+        }
+      });
+    });
+  }
+  getFailedTestAssertions(results) {
+    const failedTestPaths = [];
+    if (
+      // skip if no failed tests
+      results.numFailedTests === 0 ||
+      // skip if missing test results
+      !results.testResults ||
+      // skip if unmatched snapshots are present
+      results.snapshot.unmatched
+    ) {
+      return failedTestPaths;
+    }
+    results.testResults.forEach(testResult => {
+      testResult.testResults.forEach(result => {
+        if (result.status === 'failed') {
+          failedTestPaths.push({
+            fullName: result.fullName,
+            path: testResult.testFilePath
+          });
+        }
+      });
+    });
+    return failedTestPaths;
+  }
+}
+exports.default = FailedTestsInteractivePlugin;

frontend/node_modules/@jest/core/build/plugins/Quit.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+class QuitPlugin extends _jestWatcher().BaseWatchPlugin {
+  isInternal;
+  constructor(options) {
+    super(options);
+    this.isInternal = true;
+  }
+  async run() {
+    if (typeof this._stdin.setRawMode === 'function') {
+      this._stdin.setRawMode(false);
+    }
+    this._stdout.write('\n');
+    process.exit(0);
+  }
+  getUsageInfo() {
+    return {
+      key: 'q',
+      prompt: 'quit watch mode'
+    };
+  }
+}
+var _default = QuitPlugin;
+exports.default = _default;

frontend/node_modules/@jest/core/build/plugins/TestNamePattern.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _TestNamePatternPrompt = _interopRequireDefault(
+  require('../TestNamePatternPrompt')
+);
+var _activeFiltersMessage = _interopRequireDefault(
+  require('../lib/activeFiltersMessage')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+class TestNamePatternPlugin extends _jestWatcher().BaseWatchPlugin {
+  _prompt;
+  isInternal;
+  constructor(options) {
+    super(options);
+    this._prompt = new (_jestWatcher().Prompt)();
+    this.isInternal = true;
+  }
+  getUsageInfo() {
+    return {
+      key: 't',
+      prompt: 'filter by a test name regex pattern'
+    };
+  }
+  onKey(key) {
+    this._prompt.put(key);
+  }
+  run(globalConfig, updateConfigAndRun) {
+    return new Promise((res, rej) => {
+      const testNamePatternPrompt = new _TestNamePatternPrompt.default(
+        this._stdout,
+        this._prompt
+      );
+      testNamePatternPrompt.run(
+        value => {
+          updateConfigAndRun({
+            mode: 'watch',
+            testNamePattern: value
+          });
+          res();
+        },
+        rej,
+        {
+          header: (0, _activeFiltersMessage.default)(globalConfig)
+        }
+      );
+    });
+  }
+}
+var _default = TestNamePatternPlugin;
+exports.default = _default;

frontend/node_modules/@jest/core/build/plugins/TestPathPattern.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _TestPathPatternPrompt = _interopRequireDefault(
+  require('../TestPathPatternPrompt')
+);
+var _activeFiltersMessage = _interopRequireDefault(
+  require('../lib/activeFiltersMessage')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+class TestPathPatternPlugin extends _jestWatcher().BaseWatchPlugin {
+  _prompt;
+  isInternal;
+  constructor(options) {
+    super(options);
+    this._prompt = new (_jestWatcher().Prompt)();
+    this.isInternal = true;
+  }
+  getUsageInfo() {
+    return {
+      key: 'p',
+      prompt: 'filter by a filename regex pattern'
+    };
+  }
+  onKey(key) {
+    this._prompt.put(key);
+  }
+  run(globalConfig, updateConfigAndRun) {
+    return new Promise((res, rej) => {
+      const testPathPatternPrompt = new _TestPathPatternPrompt.default(
+        this._stdout,
+        this._prompt
+      );
+      testPathPatternPrompt.run(
+        value => {
+          updateConfigAndRun({
+            mode: 'watch',
+            testPathPattern: value
+          });
+          res();
+        },
+        rej,
+        {
+          header: (0, _activeFiltersMessage.default)(globalConfig)
+        }
+      );
+    });
+  }
+}
+var _default = TestPathPatternPlugin;
+exports.default = _default;

frontend/node_modules/@jest/core/build/plugins/UpdateSnapshots.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+
+class UpdateSnapshotsPlugin extends _jestWatcher().BaseWatchPlugin {
+  _hasSnapshotFailure;
+  isInternal;
+  constructor(options) {
+    super(options);
+    this.isInternal = true;
+    this._hasSnapshotFailure = false;
+  }
+  run(_globalConfig, updateConfigAndRun) {
+    updateConfigAndRun({
+      updateSnapshot: 'all'
+    });
+    return Promise.resolve(false);
+  }
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._hasSnapshotFailure = results.snapshot.failure;
+    });
+  }
+  getUsageInfo() {
+    if (this._hasSnapshotFailure) {
+      return {
+        key: 'u',
+        prompt: 'update failing snapshots'
+      };
+    }
+    return null;
+  }
+}
+var _default = UpdateSnapshotsPlugin;
+exports.default = _default;

frontend/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _SnapshotInteractiveMode = _interopRequireDefault(
+  require('../SnapshotInteractiveMode')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+
+class UpdateSnapshotInteractivePlugin extends _jestWatcher().BaseWatchPlugin {
+  _snapshotInteractiveMode = new _SnapshotInteractiveMode.default(this._stdout);
+  _failedSnapshotTestAssertions = [];
+  isInternal = true;
+  getFailedSnapshotTestAssertions(testResults) {
+    const failedTestPaths = [];
+    if (testResults.numFailedTests === 0 || !testResults.testResults) {
+      return failedTestPaths;
+    }
+    testResults.testResults.forEach(testResult => {
+      if (testResult.snapshot && testResult.snapshot.unmatched) {
+        testResult.testResults.forEach(result => {
+          if (result.status === 'failed') {
+            failedTestPaths.push({
+              fullName: result.fullName,
+              path: testResult.testFilePath
+            });
+          }
+        });
+      }
+    });
+    return failedTestPaths;
+  }
+  apply(hooks) {
+    hooks.onTestRunComplete(results => {
+      this._failedSnapshotTestAssertions =
+        this.getFailedSnapshotTestAssertions(results);
+      if (this._snapshotInteractiveMode.isActive()) {
+        this._snapshotInteractiveMode.updateWithResults(results);
+      }
+    });
+  }
+  onKey(key) {
+    if (this._snapshotInteractiveMode.isActive()) {
+      this._snapshotInteractiveMode.put(key);
+    }
+  }
+  run(_globalConfig, updateConfigAndRun) {
+    if (this._failedSnapshotTestAssertions.length) {
+      return new Promise(res => {
+        this._snapshotInteractiveMode.run(
+          this._failedSnapshotTestAssertions,
+          (assertion, shouldUpdateSnapshot) => {
+            updateConfigAndRun({
+              mode: 'watch',
+              testNamePattern: assertion ? `^${assertion.fullName}$` : '',
+              testPathPattern: assertion ? assertion.path : '',
+              updateSnapshot: shouldUpdateSnapshot ? 'all' : 'none'
+            });
+            if (!this._snapshotInteractiveMode.isActive()) {
+              res();
+            }
+          }
+        );
+      });
+    } else {
+      return Promise.resolve();
+    }
+  }
+  getUsageInfo() {
+    if (this._failedSnapshotTestAssertions?.length > 0) {
+      return {
+        key: 'i',
+        prompt: 'update failing snapshots interactively'
+      };
+    }
+    return null;
+  }
+}
+var _default = UpdateSnapshotInteractivePlugin;
+exports.default = _default;

frontend/node_modules/@jest/core/build/runGlobalHook.js

@@ -0,0 +1,133 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = runGlobalHook;
+function util() {
+  const data = _interopRequireWildcard(require('util'));
+  util = function () {
+    return data;
+  };
+  return data;
+}
+function _transform() {
+  const data = require('@jest/transform');
+  _transform = function () {
+    return data;
+  };
+  return data;
+}
+function _prettyFormat() {
+  const data = _interopRequireDefault(require('pretty-format'));
+  _prettyFormat = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+/**
+ * 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.
+ */
+
+async function runGlobalHook({allTests, globalConfig, moduleName}) {
+  const globalModulePaths = new Set(
+    allTests.map(test => test.context.config[moduleName])
+  );
+  if (globalConfig[moduleName]) {
+    globalModulePaths.add(globalConfig[moduleName]);
+  }
+  if (globalModulePaths.size > 0) {
+    for (const modulePath of globalModulePaths) {
+      if (!modulePath) {
+        continue;
+      }
+      const correctConfig = allTests.find(
+        t => t.context.config[moduleName] === modulePath
+      );
+      const projectConfig = correctConfig
+        ? correctConfig.context.config
+        : // Fallback to first config
+          allTests[0].context.config;
+      const transformer = await (0, _transform().createScriptTransformer)(
+        projectConfig
+      );
+      try {
+        await transformer.requireAndTranspileModule(
+          modulePath,
+          async globalModule => {
+            if (typeof globalModule !== 'function') {
+              throw new TypeError(
+                `${moduleName} file must export a function at ${modulePath}`
+              );
+            }
+            await globalModule(globalConfig, projectConfig);
+          }
+        );
+      } catch (error) {
+        if (
+          util().types.isNativeError(error) &&
+          (Object.getOwnPropertyDescriptor(error, 'message')?.writable ||
+            Object.getOwnPropertyDescriptor(
+              Object.getPrototypeOf(error),
+              'message'
+            )?.writable)
+        ) {
+          error.message = `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${error.message}`;
+          throw error;
+        }
+        throw new Error(
+          `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${(0,
+          _prettyFormat().default)(error, {
+            maxDepth: 3
+          })}`
+        );
+      }
+    }
+  }
+}

frontend/node_modules/@jest/core/build/runJest.js

@@ -0,0 +1,391 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = runJest;
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _perf_hooks() {
+  const data = require('perf_hooks');
+  _perf_hooks = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+  _exit = function () {
+    return data;
+  };
+  return data;
+}
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+function _console() {
+  const data = require('@jest/console');
+  _console = function () {
+    return data;
+  };
+  return data;
+}
+function _testResult() {
+  const data = require('@jest/test-result');
+  _testResult = function () {
+    return data;
+  };
+  return data;
+}
+function _jestResolve() {
+  const data = _interopRequireDefault(require('jest-resolve'));
+  _jestResolve = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+var _TestScheduler = require('./TestScheduler');
+var _collectHandles = _interopRequireDefault(require('./collectHandles'));
+var _getNoTestsFoundMessage = _interopRequireDefault(
+  require('./getNoTestsFoundMessage')
+);
+var _runGlobalHook = _interopRequireDefault(require('./runGlobalHook'));
+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;
+}
+/**
+ * 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.
+ */
+
+const getTestPaths = async (
+  globalConfig,
+  source,
+  outputStream,
+  changedFiles,
+  jestHooks,
+  filter
+) => {
+  const data = await source.getTestPaths(globalConfig, changedFiles, filter);
+  if (!data.tests.length && globalConfig.onlyChanged && data.noSCM) {
+    new (_console().CustomConsole)(outputStream, outputStream).log(
+      'Jest can only find uncommitted changed files in a git or hg ' +
+        'repository. If you make your project a git or hg ' +
+        'repository (`git init` or `hg init`), Jest will be able ' +
+        'to only run tests related to files changed since the last ' +
+        'commit.'
+    );
+  }
+  const shouldTestArray = await Promise.all(
+    data.tests.map(test =>
+      jestHooks.shouldRunTestSuite({
+        config: test.context.config,
+        duration: test.duration,
+        testPath: test.path
+      })
+    )
+  );
+  const filteredTests = data.tests.filter((_test, i) => shouldTestArray[i]);
+  return {
+    ...data,
+    allTests: filteredTests.length,
+    tests: filteredTests
+  };
+};
+const processResults = async (runResults, options) => {
+  const {
+    outputFile,
+    json: isJSON,
+    onComplete,
+    outputStream,
+    testResultsProcessor,
+    collectHandles
+  } = options;
+  if (collectHandles) {
+    runResults.openHandles = await collectHandles();
+  } else {
+    runResults.openHandles = [];
+  }
+  if (testResultsProcessor) {
+    const processor = await (0, _jestUtil().requireOrImportModule)(
+      testResultsProcessor
+    );
+    runResults = await processor(runResults);
+  }
+  if (isJSON) {
+    if (outputFile) {
+      const cwd = (0, _jestUtil().tryRealpath)(process.cwd());
+      const filePath = path().resolve(cwd, outputFile);
+      fs().writeFileSync(
+        filePath,
+        `${JSON.stringify((0, _testResult().formatTestResults)(runResults))}\n`
+      );
+      outputStream.write(
+        `Test results written to: ${path().relative(cwd, filePath)}\n`
+      );
+    } else {
+      process.stdout.write(
+        `${JSON.stringify((0, _testResult().formatTestResults)(runResults))}\n`
+      );
+    }
+  }
+  onComplete?.(runResults);
+};
+const testSchedulerContext = {
+  firstRun: true,
+  previousSuccess: true
+};
+async function runJest({
+  contexts,
+  globalConfig,
+  outputStream,
+  testWatcher,
+  jestHooks = new (_jestWatcher().JestHook)().getEmitter(),
+  startRun,
+  changedFilesPromise,
+  onComplete,
+  failedTestsCache,
+  filter
+}) {
+  // Clear cache for required modules - there might be different resolutions
+  // from Jest's config loading to running the tests
+  _jestResolve().default.clearDefaultResolverCache();
+  const Sequencer = await (0, _jestUtil().requireOrImportModule)(
+    globalConfig.testSequencer
+  );
+  const sequencer = new Sequencer();
+  let allTests = [];
+  if (changedFilesPromise && globalConfig.watch) {
+    const {repos} = await changedFilesPromise;
+    const noSCM = Object.keys(repos).every(scm => repos[scm].size === 0);
+    if (noSCM) {
+      process.stderr.write(
+        `\n${_chalk().default.bold(
+          '--watch'
+        )} is not supported without git/hg, please use --watchAll\n`
+      );
+      (0, _exit().default)(1);
+    }
+  }
+  const searchSources = contexts.map(
+    context => new _SearchSource.default(context)
+  );
+  _perf_hooks().performance.mark('jest/getTestPaths:start');
+  const testRunData = await Promise.all(
+    contexts.map(async (context, index) => {
+      const searchSource = searchSources[index];
+      const matches = await getTestPaths(
+        globalConfig,
+        searchSource,
+        outputStream,
+        changedFilesPromise && (await changedFilesPromise),
+        jestHooks,
+        filter
+      );
+      allTests = allTests.concat(matches.tests);
+      return {
+        context,
+        matches
+      };
+    })
+  );
+  _perf_hooks().performance.mark('jest/getTestPaths:end');
+  if (globalConfig.shard) {
+    if (typeof sequencer.shard !== 'function') {
+      throw new Error(
+        `Shard ${globalConfig.shard.shardIndex}/${globalConfig.shard.shardCount} requested, but test sequencer ${Sequencer.name} in ${globalConfig.testSequencer} has no shard method.`
+      );
+    }
+    allTests = await sequencer.shard(allTests, globalConfig.shard);
+  }
+  allTests = await sequencer.sort(allTests);
+  if (globalConfig.listTests) {
+    const testsPaths = Array.from(new Set(allTests.map(test => test.path)));
+    /* eslint-disable no-console */
+    if (globalConfig.json) {
+      console.log(JSON.stringify(testsPaths));
+    } else {
+      console.log(testsPaths.join('\n'));
+    }
+    /* eslint-enable */
+
+    onComplete &&
+      onComplete((0, _testResult().makeEmptyAggregatedTestResult)());
+    return;
+  }
+  if (globalConfig.onlyFailures) {
+    if (failedTestsCache) {
+      allTests = failedTestsCache.filterTests(allTests);
+    } else {
+      allTests = await sequencer.allFailedTests(allTests);
+    }
+  }
+  const hasTests = allTests.length > 0;
+  if (!hasTests) {
+    const {exitWith0, message: noTestsFoundMessage} = (0,
+    _getNoTestsFoundMessage.default)(testRunData, globalConfig);
+    if (exitWith0) {
+      new (_console().CustomConsole)(outputStream, outputStream).log(
+        noTestsFoundMessage
+      );
+    } else {
+      new (_console().CustomConsole)(outputStream, outputStream).error(
+        noTestsFoundMessage
+      );
+      (0, _exit().default)(1);
+    }
+  } else if (
+    allTests.length === 1 &&
+    globalConfig.silent !== true &&
+    globalConfig.verbose !== false
+  ) {
+    const newConfig = {
+      ...globalConfig,
+      verbose: true
+    };
+    globalConfig = Object.freeze(newConfig);
+  }
+  let collectHandles;
+  if (globalConfig.detectOpenHandles) {
+    collectHandles = (0, _collectHandles.default)();
+  }
+  if (hasTests) {
+    _perf_hooks().performance.mark('jest/globalSetup:start');
+    await (0, _runGlobalHook.default)({
+      allTests,
+      globalConfig,
+      moduleName: 'globalSetup'
+    });
+    _perf_hooks().performance.mark('jest/globalSetup:end');
+  }
+  if (changedFilesPromise) {
+    const changedFilesInfo = await changedFilesPromise;
+    if (changedFilesInfo.changedFiles) {
+      testSchedulerContext.changedFiles = changedFilesInfo.changedFiles;
+      const sourcesRelatedToTestsInChangedFilesArray = (
+        await Promise.all(
+          contexts.map(async (_, index) => {
+            const searchSource = searchSources[index];
+            return searchSource.findRelatedSourcesFromTestsInChangedFiles(
+              changedFilesInfo
+            );
+          })
+        )
+      ).reduce((total, paths) => total.concat(paths), []);
+      testSchedulerContext.sourcesRelatedToTestsInChangedFiles = new Set(
+        sourcesRelatedToTestsInChangedFilesArray
+      );
+    }
+  }
+  const scheduler = await (0, _TestScheduler.createTestScheduler)(
+    globalConfig,
+    {
+      startRun,
+      ...testSchedulerContext
+    }
+  );
+
+  // @ts-expect-error - second arg is unsupported (but harmless) in Node 14
+  _perf_hooks().performance.mark('jest/scheduleAndRun:start', {
+    detail: {
+      numTests: allTests.length
+    }
+  });
+  const results = await scheduler.scheduleTests(allTests, testWatcher);
+  _perf_hooks().performance.mark('jest/scheduleAndRun:end');
+  _perf_hooks().performance.mark('jest/cacheResults:start');
+  sequencer.cacheResults(allTests, results);
+  _perf_hooks().performance.mark('jest/cacheResults:end');
+  if (hasTests) {
+    _perf_hooks().performance.mark('jest/globalTeardown:start');
+    await (0, _runGlobalHook.default)({
+      allTests,
+      globalConfig,
+      moduleName: 'globalTeardown'
+    });
+    _perf_hooks().performance.mark('jest/globalTeardown:end');
+  }
+  _perf_hooks().performance.mark('jest/processResults:start');
+  await processResults(results, {
+    collectHandles,
+    json: globalConfig.json,
+    onComplete,
+    outputFile: globalConfig.outputFile,
+    outputStream,
+    testResultsProcessor: globalConfig.testResultsProcessor
+  });
+  _perf_hooks().performance.mark('jest/processResults:end');
+}

frontend/node_modules/@jest/core/build/testSchedulerHelper.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.shouldRunInBand = shouldRunInBand;
+/**
+ * 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.
+ */
+
+const SLOW_TEST_TIME = 1000;
+function shouldRunInBand(
+  tests,
+  timings,
+  {
+    detectOpenHandles,
+    maxWorkers,
+    runInBand,
+    watch,
+    watchAll,
+    workerIdleMemoryLimit
+  }
+) {
+  // If user asked for run in band, respect that.
+  // detectOpenHandles makes no sense without runInBand, because it cannot detect leaks in workers
+  if (runInBand || detectOpenHandles) {
+    return true;
+  }
+
+  /*
+   * If we are using watch/watchAll mode, don't schedule anything in the main
+   * thread to keep the TTY responsive and to prevent watch mode crashes caused
+   * by leaks (improper test teardown).
+   */
+  if (watch || watchAll) {
+    return false;
+  }
+
+  /*
+   * Otherwise, run in band if we only have one test or one worker available.
+   * Also, if we are confident from previous runs that the tests will finish
+   * quickly we also run in band to reduce the overhead of spawning workers.
+   */
+  const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME);
+  const oneWorkerOrLess = maxWorkers <= 1;
+  const oneTestOrLess = tests.length <= 1;
+  return (
+    // When specifying a memory limit, workers should be used
+    !workerIdleMemoryLimit &&
+    (oneWorkerOrLess ||
+      oneTestOrLess ||
+      (tests.length <= 20 && timings.length > 0 && areFastTests))
+  );
+}

frontend/node_modules/@jest/core/build/types.js

@@ -0,0 +1 @@
+'use strict';

frontend/node_modules/@jest/core/build/version.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = getVersion;
+/**
+ * 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.
+ */
+
+// Cannot be `import` as it's not under TS root dir
+const {version: VERSION} = require('../package.json');
+function getVersion() {
+  return VERSION;
+}

frontend/node_modules/@jest/core/build/watch.js

@@ -0,0 +1,666 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = watch;
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _ansiEscapes() {
+  const data = _interopRequireDefault(require('ansi-escapes'));
+  _ansiEscapes = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _exit() {
+  const data = _interopRequireDefault(require('exit'));
+  _exit = function () {
+    return data;
+  };
+  return data;
+}
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+  _slash = function () {
+    return data;
+  };
+  return data;
+}
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+  _jestMessageUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestUtil() {
+  const data = require('jest-util');
+  _jestUtil = function () {
+    return data;
+  };
+  return data;
+}
+function _jestValidate() {
+  const data = require('jest-validate');
+  _jestValidate = function () {
+    return data;
+  };
+  return data;
+}
+function _jestWatcher() {
+  const data = require('jest-watcher');
+  _jestWatcher = function () {
+    return data;
+  };
+  return data;
+}
+var _FailedTestsCache = _interopRequireDefault(require('./FailedTestsCache'));
+var _SearchSource = _interopRequireDefault(require('./SearchSource'));
+var _getChangedFilesPromise = _interopRequireDefault(
+  require('./getChangedFilesPromise')
+);
+var _activeFiltersMessage = _interopRequireDefault(
+  require('./lib/activeFiltersMessage')
+);
+var _createContext = _interopRequireDefault(require('./lib/createContext'));
+var _isValidPath = _interopRequireDefault(require('./lib/isValidPath'));
+var _updateGlobalConfig = _interopRequireDefault(
+  require('./lib/updateGlobalConfig')
+);
+var _watchPluginsHelpers = require('./lib/watchPluginsHelpers');
+var _FailedTestsInteractive = _interopRequireDefault(
+  require('./plugins/FailedTestsInteractive')
+);
+var _Quit = _interopRequireDefault(require('./plugins/Quit'));
+var _TestNamePattern = _interopRequireDefault(
+  require('./plugins/TestNamePattern')
+);
+var _TestPathPattern = _interopRequireDefault(
+  require('./plugins/TestPathPattern')
+);
+var _UpdateSnapshots = _interopRequireDefault(
+  require('./plugins/UpdateSnapshots')
+);
+var _UpdateSnapshotsInteractive = _interopRequireDefault(
+  require('./plugins/UpdateSnapshotsInteractive')
+);
+var _runJest = _interopRequireDefault(require('./runJest'));
+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;
+}
+/**
+ * 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.
+ */
+
+const {print: preRunMessagePrint} = _jestUtil().preRunMessage;
+let hasExitListener = false;
+const INTERNAL_PLUGINS = [
+  _FailedTestsInteractive.default,
+  _TestPathPattern.default,
+  _TestNamePattern.default,
+  _UpdateSnapshots.default,
+  _UpdateSnapshotsInteractive.default,
+  _Quit.default
+];
+const RESERVED_KEY_PLUGINS = new Map([
+  [
+    _UpdateSnapshots.default,
+    {
+      forbiddenOverwriteMessage: 'updating snapshots',
+      key: 'u'
+    }
+  ],
+  [
+    _UpdateSnapshotsInteractive.default,
+    {
+      forbiddenOverwriteMessage: 'updating snapshots interactively',
+      key: 'i'
+    }
+  ],
+  [
+    _Quit.default,
+    {
+      forbiddenOverwriteMessage: 'quitting watch mode'
+    }
+  ]
+]);
+async function watch(
+  initialGlobalConfig,
+  contexts,
+  outputStream,
+  hasteMapInstances,
+  stdin = process.stdin,
+  hooks = new (_jestWatcher().JestHook)(),
+  filter
+) {
+  // `globalConfig` will be constantly updated and reassigned as a result of
+  // watch mode interactions.
+  let globalConfig = initialGlobalConfig;
+  let activePlugin;
+  globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+    mode: globalConfig.watch ? 'watch' : 'watchAll',
+    passWithNoTests: true
+  });
+  const updateConfigAndRun = ({
+    bail,
+    changedSince,
+    collectCoverage,
+    collectCoverageFrom,
+    coverageDirectory,
+    coverageReporters,
+    findRelatedTests,
+    mode,
+    nonFlagArgs,
+    notify,
+    notifyMode,
+    onlyFailures,
+    reporters,
+    testNamePattern,
+    testPathPattern,
+    updateSnapshot,
+    verbose
+  } = {}) => {
+    const previousUpdateSnapshot = globalConfig.updateSnapshot;
+    globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+      bail,
+      changedSince,
+      collectCoverage,
+      collectCoverageFrom,
+      coverageDirectory,
+      coverageReporters,
+      findRelatedTests,
+      mode,
+      nonFlagArgs,
+      notify,
+      notifyMode,
+      onlyFailures,
+      reporters,
+      testNamePattern,
+      testPathPattern,
+      updateSnapshot,
+      verbose
+    });
+    startRun(globalConfig);
+    globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+      // updateSnapshot is not sticky after a run.
+      updateSnapshot:
+        previousUpdateSnapshot === 'all' ? 'none' : previousUpdateSnapshot
+    });
+  };
+  const watchPlugins = INTERNAL_PLUGINS.map(
+    InternalPlugin =>
+      new InternalPlugin({
+        stdin,
+        stdout: outputStream
+      })
+  );
+  watchPlugins.forEach(plugin => {
+    const hookSubscriber = hooks.getSubscriber();
+    if (plugin.apply) {
+      plugin.apply(hookSubscriber);
+    }
+  });
+  if (globalConfig.watchPlugins != null) {
+    const watchPluginKeys = new Map();
+    for (const plugin of watchPlugins) {
+      const reservedInfo = RESERVED_KEY_PLUGINS.get(plugin.constructor) || {};
+      const key = reservedInfo.key || getPluginKey(plugin, globalConfig);
+      if (!key) {
+        continue;
+      }
+      const {forbiddenOverwriteMessage} = reservedInfo;
+      watchPluginKeys.set(key, {
+        forbiddenOverwriteMessage,
+        overwritable: forbiddenOverwriteMessage == null,
+        plugin
+      });
+    }
+    for (const pluginWithConfig of globalConfig.watchPlugins) {
+      let plugin;
+      try {
+        const ThirdPartyPlugin = await (0, _jestUtil().requireOrImportModule)(
+          pluginWithConfig.path
+        );
+        plugin = new ThirdPartyPlugin({
+          config: pluginWithConfig.config,
+          stdin,
+          stdout: outputStream
+        });
+      } catch (error) {
+        const errorWithContext = new Error(
+          `Failed to initialize watch plugin "${_chalk().default.bold(
+            (0, _slash().default)(
+              path().relative(process.cwd(), pluginWithConfig.path)
+            )
+          )}":\n\n${(0, _jestMessageUtil().formatExecError)(
+            error,
+            contexts[0].config,
+            {
+              noStackTrace: false
+            }
+          )}`
+        );
+        delete errorWithContext.stack;
+        return Promise.reject(errorWithContext);
+      }
+      checkForConflicts(watchPluginKeys, plugin, globalConfig);
+      const hookSubscriber = hooks.getSubscriber();
+      if (plugin.apply) {
+        plugin.apply(hookSubscriber);
+      }
+      watchPlugins.push(plugin);
+    }
+  }
+  const failedTestsCache = new _FailedTestsCache.default();
+  let searchSources = contexts.map(context => ({
+    context,
+    searchSource: new _SearchSource.default(context)
+  }));
+  let isRunning = false;
+  let testWatcher;
+  let shouldDisplayWatchUsage = true;
+  let isWatchUsageDisplayed = false;
+  const emitFileChange = () => {
+    if (hooks.isUsed('onFileChange')) {
+      const projects = searchSources.map(({context, searchSource}) => ({
+        config: context.config,
+        testPaths: searchSource.findMatchingTests('').tests.map(t => t.path)
+      }));
+      hooks.getEmitter().onFileChange({
+        projects
+      });
+    }
+  };
+  emitFileChange();
+  hasteMapInstances.forEach((hasteMapInstance, index) => {
+    hasteMapInstance.on('change', ({eventsQueue, hasteFS, moduleMap}) => {
+      const validPaths = eventsQueue.filter(({filePath}) =>
+        (0, _isValidPath.default)(globalConfig, filePath)
+      );
+      if (validPaths.length) {
+        const context = (contexts[index] = (0, _createContext.default)(
+          contexts[index].config,
+          {
+            hasteFS,
+            moduleMap
+          }
+        ));
+        activePlugin = null;
+        searchSources = searchSources.slice();
+        searchSources[index] = {
+          context,
+          searchSource: new _SearchSource.default(context)
+        };
+        emitFileChange();
+        startRun(globalConfig);
+      }
+    });
+  });
+  if (!hasExitListener) {
+    hasExitListener = true;
+    process.on('exit', () => {
+      if (activePlugin) {
+        outputStream.write(_ansiEscapes().default.cursorDown());
+        outputStream.write(_ansiEscapes().default.eraseDown);
+      }
+    });
+  }
+  const startRun = globalConfig => {
+    if (isRunning) {
+      return Promise.resolve(null);
+    }
+    testWatcher = new (_jestWatcher().TestWatcher)({
+      isWatchMode: true
+    });
+    _jestUtil().isInteractive &&
+      outputStream.write(_jestUtil().specialChars.CLEAR);
+    preRunMessagePrint(outputStream);
+    isRunning = true;
+    const configs = contexts.map(context => context.config);
+    const changedFilesPromise = (0, _getChangedFilesPromise.default)(
+      globalConfig,
+      configs
+    );
+    return (0, _runJest.default)({
+      changedFilesPromise,
+      contexts,
+      failedTestsCache,
+      filter,
+      globalConfig,
+      jestHooks: hooks.getEmitter(),
+      onComplete: results => {
+        isRunning = false;
+        hooks.getEmitter().onTestRunComplete(results);
+
+        // Create a new testWatcher instance so that re-runs won't be blocked.
+        // The old instance that was passed to Jest will still be interrupted
+        // and prevent test runs from the previous run.
+        testWatcher = new (_jestWatcher().TestWatcher)({
+          isWatchMode: true
+        });
+
+        // Do not show any Watch Usage related stuff when running in a
+        // non-interactive environment
+        if (_jestUtil().isInteractive) {
+          if (shouldDisplayWatchUsage) {
+            outputStream.write(usage(globalConfig, watchPlugins));
+            shouldDisplayWatchUsage = false; // hide Watch Usage after first run
+            isWatchUsageDisplayed = true;
+          } else {
+            outputStream.write(showToggleUsagePrompt());
+            shouldDisplayWatchUsage = false;
+            isWatchUsageDisplayed = false;
+          }
+        } else {
+          outputStream.write('\n');
+        }
+        failedTestsCache.setTestResults(results.testResults);
+      },
+      outputStream,
+      startRun,
+      testWatcher
+    }).catch(error =>
+      // Errors thrown inside `runJest`, e.g. by resolvers, are caught here for
+      // continuous watch mode execution. We need to reprint them to the
+      // terminal and give just a little bit of extra space so they fit below
+      // `preRunMessagePrint` message nicely.
+      console.error(
+        `\n\n${(0, _jestMessageUtil().formatExecError)(
+          error,
+          contexts[0].config,
+          {
+            noStackTrace: false
+          }
+        )}`
+      )
+    );
+  };
+  const onKeypress = key => {
+    if (
+      key === _jestWatcher().KEYS.CONTROL_C ||
+      key === _jestWatcher().KEYS.CONTROL_D
+    ) {
+      if (typeof stdin.setRawMode === 'function') {
+        stdin.setRawMode(false);
+      }
+      outputStream.write('\n');
+      (0, _exit().default)(0);
+      return;
+    }
+    if (activePlugin != null && activePlugin.onKey) {
+      // if a plugin is activate, Jest should let it handle keystrokes, so ignore
+      // them here
+      activePlugin.onKey(key);
+      return;
+    }
+
+    // Abort test run
+    const pluginKeys = (0, _watchPluginsHelpers.getSortedUsageRows)(
+      watchPlugins,
+      globalConfig
+    ).map(usage => Number(usage.key).toString(16));
+    if (
+      isRunning &&
+      testWatcher &&
+      ['q', _jestWatcher().KEYS.ENTER, 'a', 'o', 'f']
+        .concat(pluginKeys)
+        .includes(key)
+    ) {
+      testWatcher.setState({
+        interrupted: true
+      });
+      return;
+    }
+    const matchingWatchPlugin = (0,
+    _watchPluginsHelpers.filterInteractivePlugins)(
+      watchPlugins,
+      globalConfig
+    ).find(plugin => getPluginKey(plugin, globalConfig) === key);
+    if (matchingWatchPlugin != null) {
+      if (isRunning) {
+        testWatcher.setState({
+          interrupted: true
+        });
+        return;
+      }
+      // "activate" the plugin, which has jest ignore keystrokes so the plugin
+      // can handle them
+      activePlugin = matchingWatchPlugin;
+      if (activePlugin.run) {
+        activePlugin.run(globalConfig, updateConfigAndRun).then(
+          shouldRerun => {
+            activePlugin = null;
+            if (shouldRerun) {
+              updateConfigAndRun();
+            }
+          },
+          () => {
+            activePlugin = null;
+            onCancelPatternPrompt();
+          }
+        );
+      } else {
+        activePlugin = null;
+      }
+    }
+    switch (key) {
+      case _jestWatcher().KEYS.ENTER:
+        startRun(globalConfig);
+        break;
+      case 'a':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          mode: 'watchAll',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        startRun(globalConfig);
+        break;
+      case 'c':
+        updateConfigAndRun({
+          mode: 'watch',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        break;
+      case 'f':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          onlyFailures: !globalConfig.onlyFailures
+        });
+        startRun(globalConfig);
+        break;
+      case 'o':
+        globalConfig = (0, _updateGlobalConfig.default)(globalConfig, {
+          mode: 'watch',
+          testNamePattern: '',
+          testPathPattern: ''
+        });
+        startRun(globalConfig);
+        break;
+      case '?':
+        break;
+      case 'w':
+        if (!shouldDisplayWatchUsage && !isWatchUsageDisplayed) {
+          outputStream.write(_ansiEscapes().default.cursorUp());
+          outputStream.write(_ansiEscapes().default.eraseDown);
+          outputStream.write(usage(globalConfig, watchPlugins));
+          isWatchUsageDisplayed = true;
+          shouldDisplayWatchUsage = false;
+        }
+        break;
+    }
+  };
+  const onCancelPatternPrompt = () => {
+    outputStream.write(_ansiEscapes().default.cursorHide);
+    outputStream.write(_jestUtil().specialChars.CLEAR);
+    outputStream.write(usage(globalConfig, watchPlugins));
+    outputStream.write(_ansiEscapes().default.cursorShow);
+  };
+  if (typeof stdin.setRawMode === 'function') {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    stdin.on('data', onKeypress);
+  }
+  startRun(globalConfig);
+  return Promise.resolve();
+}
+const checkForConflicts = (watchPluginKeys, plugin, globalConfig) => {
+  const key = getPluginKey(plugin, globalConfig);
+  if (!key) {
+    return;
+  }
+  const conflictor = watchPluginKeys.get(key);
+  if (!conflictor || conflictor.overwritable) {
+    watchPluginKeys.set(key, {
+      overwritable: false,
+      plugin
+    });
+    return;
+  }
+  let error;
+  if (conflictor.forbiddenOverwriteMessage) {
+    error = `
+  Watch plugin ${_chalk().default.bold.red(
+    getPluginIdentifier(plugin)
+  )} attempted to register key ${_chalk().default.bold.red(`<${key}>`)},
+  that is reserved internally for ${_chalk().default.bold.red(
+    conflictor.forbiddenOverwriteMessage
+  )}.
+  Please change the configuration key for this plugin.`.trim();
+  } else {
+    const plugins = [conflictor.plugin, plugin]
+      .map(p => _chalk().default.bold.red(getPluginIdentifier(p)))
+      .join(' and ');
+    error = `
+  Watch plugins ${plugins} both attempted to register key ${_chalk().default.bold.red(
+      `<${key}>`
+    )}.
+  Please change the key configuration for one of the conflicting plugins to avoid overlap.`.trim();
+  }
+  throw new (_jestValidate().ValidationError)(
+    'Watch plugin configuration error',
+    error
+  );
+};
+const getPluginIdentifier = plugin =>
+  // This breaks as `displayName` is not defined as a static, but since
+  // WatchPlugin is an interface, and it is my understanding interface
+  // static fields are not definable anymore, no idea how to circumvent
+  // this :-(
+  // @ts-expect-error: leave `displayName` be.
+  plugin.constructor.displayName || plugin.constructor.name;
+const getPluginKey = (plugin, globalConfig) => {
+  if (typeof plugin.getUsageInfo === 'function') {
+    return (
+      plugin.getUsageInfo(globalConfig) || {
+        key: null
+      }
+    ).key;
+  }
+  return null;
+};
+const usage = (globalConfig, watchPlugins, delimiter = '\n') => {
+  const messages = [
+    (0, _activeFiltersMessage.default)(globalConfig),
+    globalConfig.testPathPattern || globalConfig.testNamePattern
+      ? `${_chalk().default.dim(' \u203A Press ')}c${_chalk().default.dim(
+          ' to clear filters.'
+        )}`
+      : null,
+    `\n${_chalk().default.bold('Watch Usage')}`,
+    globalConfig.watch
+      ? `${_chalk().default.dim(' \u203A Press ')}a${_chalk().default.dim(
+          ' to run all tests.'
+        )}`
+      : null,
+    globalConfig.onlyFailures
+      ? `${_chalk().default.dim(' \u203A Press ')}f${_chalk().default.dim(
+          ' to quit "only failed tests" mode.'
+        )}`
+      : `${_chalk().default.dim(' \u203A Press ')}f${_chalk().default.dim(
+          ' to run only failed tests.'
+        )}`,
+    (globalConfig.watchAll ||
+      globalConfig.testPathPattern ||
+      globalConfig.testNamePattern) &&
+    !globalConfig.noSCM
+      ? `${_chalk().default.dim(' \u203A Press ')}o${_chalk().default.dim(
+          ' to only run tests related to changed files.'
+        )}`
+      : null,
+    ...(0, _watchPluginsHelpers.getSortedUsageRows)(
+      watchPlugins,
+      globalConfig
+    ).map(
+      plugin =>
+        `${_chalk().default.dim(' \u203A Press')} ${
+          plugin.key
+        } ${_chalk().default.dim(`to ${plugin.prompt}.`)}`
+    ),
+    `${_chalk().default.dim(' \u203A Press ')}Enter${_chalk().default.dim(
+      ' to trigger a test run.'
+    )}`
+  ];
+  return `${messages.filter(message => !!message).join(delimiter)}\n`;
+};
+const showToggleUsagePrompt = () =>
+  '\n' +
+  `${_chalk().default.bold('Watch Usage: ')}${_chalk().default.dim(
+    'Press '
+  )}w${_chalk().default.dim(' to show more.')}`;

frontend/node_modules/@jest/core/node_modules/ansi-styles/index.d.ts

@@ -0,0 +1,167 @@
+declare namespace ansiStyles {
+	interface CSPair {
+		/**
+		The ANSI terminal control sequence for starting this style.
+		*/
+		readonly open: string;
+
+		/**
+		The ANSI terminal control sequence for ending this style.
+		*/
+		readonly close: string;
+	}
+
+	interface ColorBase {
+		/**
+		The ANSI terminal control sequence for ending this color.
+		*/
+		readonly close: string;
+
+		ansi256(code: number): string;
+
+		ansi16m(red: number, green: number, blue: number): string;
+	}
+
+	interface Modifier {
+		/**
+		Resets the current color chain.
+		*/
+		readonly reset: CSPair;
+
+		/**
+		Make text bold.
+		*/
+		readonly bold: CSPair;
+
+		/**
+		Emitting only a small amount of light.
+		*/
+		readonly dim: CSPair;
+
+		/**
+		Make text italic. (Not widely supported)
+		*/
+		readonly italic: CSPair;
+
+		/**
+		Make text underline. (Not widely supported)
+		*/
+		readonly underline: CSPair;
+
+		/**
+		Make text overline.
+
+		Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
+		*/
+		readonly overline: CSPair;
+
+		/**
+		Inverse background and foreground colors.
+		*/
+		readonly inverse: CSPair;
+
+		/**
+		Prints the text, but makes it invisible.
+		*/
+		readonly hidden: CSPair;
+
+		/**
+		Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: CSPair;
+	}
+
+	interface ForegroundColor {
+		readonly black: CSPair;
+		readonly red: CSPair;
+		readonly green: CSPair;
+		readonly yellow: CSPair;
+		readonly blue: CSPair;
+		readonly cyan: CSPair;
+		readonly magenta: CSPair;
+		readonly white: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly gray: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly grey: CSPair;
+
+		readonly blackBright: CSPair;
+		readonly redBright: CSPair;
+		readonly greenBright: CSPair;
+		readonly yellowBright: CSPair;
+		readonly blueBright: CSPair;
+		readonly cyanBright: CSPair;
+		readonly magentaBright: CSPair;
+		readonly whiteBright: CSPair;
+	}
+
+	interface BackgroundColor {
+		readonly bgBlack: CSPair;
+		readonly bgRed: CSPair;
+		readonly bgGreen: CSPair;
+		readonly bgYellow: CSPair;
+		readonly bgBlue: CSPair;
+		readonly bgCyan: CSPair;
+		readonly bgMagenta: CSPair;
+		readonly bgWhite: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: CSPair;
+
+		readonly bgBlackBright: CSPair;
+		readonly bgRedBright: CSPair;
+		readonly bgGreenBright: CSPair;
+		readonly bgYellowBright: CSPair;
+		readonly bgBlueBright: CSPair;
+		readonly bgCyanBright: CSPair;
+		readonly bgMagentaBright: CSPair;
+		readonly bgWhiteBright: CSPair;
+	}
+
+	interface ConvertColor {
+		/**
+		Convert from the RGB color space to the ANSI 256 color space.
+
+		@param red - (`0...255`)
+		@param green - (`0...255`)
+		@param blue - (`0...255`)
+		*/
+		rgbToAnsi256(red: number, green: number, blue: number): number;
+
+		/**
+		Convert from the RGB HEX color space to the RGB color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hexToRgb(hex: string): [red: number, green: number, blue: number];
+
+		/**
+		Convert from the RGB HEX color space to the ANSI 256 color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hexToAnsi256(hex: string): number;
+	}
+}
+
+declare const ansiStyles: {
+	readonly modifier: ansiStyles.Modifier;
+	readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
+	readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+	readonly codes: ReadonlyMap<number, number>;
+} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier & ansiStyles.ConvertColor;
+
+export = ansiStyles;

frontend/node_modules/@jest/core/node_modules/ansi-styles/index.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			overline: [53, 55],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	styles.color.ansi256 = wrapAnsi256();
+	styles.color.ansi16m = wrapAnsi16m();
+	styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles, {
+		rgbToAnsi256: {
+			value: (red, green, blue) => {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16 +
+					(36 * Math.round(red / 255 * 5)) +
+					(6 * Math.round(green / 255 * 5)) +
+					Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value: hex => {
+				const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let {colorString} = matches.groups;
+
+				if (colorString.length === 3) {
+					colorString = colorString.split('').map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+			enumerable: false
+		}
+	});
+
+	return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});

frontend/node_modules/@jest/core/node_modules/ansi-styles/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

frontend/node_modules/@jest/core/node_modules/ansi-styles/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "ansi-styles",
+	"version": "5.2.0",
+	"description": "ANSI escape codes for styling strings in the terminal",
+	"license": "MIT",
+	"repository": "chalk/ansi-styles",
+	"funding": "https://github.com/chalk/ansi-styles?sponsor=1",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"svg-term-cli": "^2.1.1",
+		"tsd": "^0.14.0",
+		"xo": "^0.37.1"
+	}
+}

frontend/node_modules/@jest/core/node_modules/ansi-styles/readme.md

@@ -0,0 +1,144 @@
+# ansi-styles
+
+> [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
+
+<img src="screenshot.svg" width="900">
+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 256/truecolor
+// NOTE: When converting from truecolor to 256 colors, the original color
+//       may be degraded to fit the new color palette. This means terminals
+//       that do not support 16 million colors will best-match the
+//       original color.
+console.log(`${style.color.ansi256(style.rgbToAnsi256(199, 20, 250))}Hello World${style.color.close}`)
+console.log(`${style.color.ansi16m(...style.hexToRgb('#abcdef'))}Hello World${style.color.close}`)
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `overline` *Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.*
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` allows converting between various color formats and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi256(style.rgbToAnsi256(100, 200, 15)); // RGB to 256 color ansi foreground code
+style.bgColor.ansi256(style.hexToAnsi256('#C0FFEE')); // HEX to 256 color ansi foreground code
+
+style.color.ansi16m(100, 200, 15); // RGB to 16 million color foreground code
+style.bgColor.ansi16m(...style.hexToRgb('#C0FFEE')); // Hex (RGB) to 16 million color foreground code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

frontend/node_modules/@jest/core/node_modules/pretty-format/LICENSE

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

frontend/node_modules/@jest/core/node_modules/pretty-format/README.md

@@ -0,0 +1,463 @@
+# pretty-format
+
+Stringify any JavaScript value.
+
+- Serialize built-in JavaScript types.
+- Serialize application-specific data types with built-in or user-defined plugins.
+
+## Installation
+
+```sh
+$ yarn add pretty-format
+```
+
+## Usage
+
+```js
+const {format: prettyFormat} = require('pretty-format'); // CommonJS
+```
+
+```js
+import {format as prettyFormat} from 'pretty-format'; // ES2015 modules
+```
+
+```js
+const val = {object: {}};
+val.circularReference = val;
+val[Symbol('foo')] = 'foo';
+val.map = new Map([['prop', 'value']]);
+val.array = [-0, Infinity, NaN];
+
+console.log(prettyFormat(val));
+/*
+Object {
+  "array": Array [
+    -0,
+    Infinity,
+    NaN,
+  ],
+  "circularReference": [Circular],
+  "map": Map {
+    "prop" => "value",
+  },
+  "object": Object {},
+  Symbol(foo): "foo",
+}
+*/
+```
+
+## Usage with options
+
+```js
+function onClick() {}
+
+console.log(prettyFormat(onClick));
+/*
+[Function onClick]
+*/
+
+const options = {
+  printFunctionName: false,
+};
+console.log(prettyFormat(onClick, options));
+/*
+[Function]
+*/
+```
+
+<!-- prettier-ignore -->
+| key                   | type             | default     | description                                                                             |
+| :-------------------- | :--------------- | :---------- | :-------------------------------------------------------------------------------------- |
+| `callToJSON`          | `boolean`        | `true`      | call `toJSON` method (if it exists) on objects                                          |
+| `compareKeys`         | `function\|null` | `undefined` | compare function used when sorting object keys, `null` can be used to skip over sorting |
+| `escapeRegex`         | `boolean`        | `false`     | escape special characters in regular expressions                                        |
+| `escapeString`        | `boolean`        | `true`      | escape special characters in strings                                                    |
+| `highlight`           | `boolean`        | `false`     | highlight syntax with colors in terminal (some plugins)                                 |
+| `indent`              | `number`         | `2`         | spaces in each level of indentation                                                     |
+| `maxDepth`            | `number`         | `Infinity`  | levels to print in arrays, objects, elements, and so on                                 |
+| `maxWidth`            | `number`         | `Infinity`  | number of elements to print in arrays, sets, and so on                                  |
+| `min`                 | `boolean`        | `false`     | minimize added space: no indentation nor line breaks                                    |
+| `plugins`             | `array`          | `[]`        | plugins to serialize application-specific data types                                    |
+| `printBasicPrototype` | `boolean`        | `false`     | print the prototype for plain objects and arrays                                        |
+| `printFunctionName`   | `boolean`        | `true`      | include or omit the name of a function                                                  |
+| `theme`               | `object`         |             | colors to highlight syntax in terminal                                                  |
+
+Property values of `theme` are from [ansi-styles colors](https://github.com/chalk/ansi-styles#colors)
+
+```js
+const DEFAULT_THEME = {
+  comment: 'gray',
+  content: 'reset',
+  prop: 'yellow',
+  tag: 'cyan',
+  value: 'green',
+};
+```
+
+## Usage with plugins
+
+The `pretty-format` package provides some built-in plugins, including:
+
+- `ReactElement` for elements from `react`
+- `ReactTestComponent` for test objects from `react-test-renderer`
+
+```js
+// CommonJS
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {format: prettyFormat, plugins} = require('pretty-format');
+
+const {ReactElement, ReactTestComponent} = plugins;
+```
+
+```js
+// ES2015 modules and destructuring assignment
+import React from 'react';
+import renderer from 'react-test-renderer';
+import {plugins, format as prettyFormat} from 'pretty-format';
+
+const {ReactElement, ReactTestComponent} = plugins;
+```
+
+```js
+const onClick = () => {};
+const element = React.createElement('button', {onClick}, 'Hello World');
+
+const formatted1 = prettyFormat(element, {
+  plugins: [ReactElement],
+  printFunctionName: false,
+});
+const formatted2 = prettyFormat(renderer.create(element).toJSON(), {
+  plugins: [ReactTestComponent],
+  printFunctionName: false,
+});
+/*
+<button
+  onClick=[Function]
+>
+  Hello World
+</button>
+*/
+```
+
+## Usage in Jest
+
+For snapshot tests, Jest uses `pretty-format` with options that include some of its built-in plugins. For this purpose, plugins are also known as **snapshot serializers**.
+
+To serialize application-specific data types, you can add modules to `devDependencies` of a project, and then:
+
+In an **individual** test file, you can add a module as follows. It precedes any modules from Jest configuration.
+
+```js
+import serializer from 'my-serializer-module';
+expect.addSnapshotSerializer(serializer);
+
+// tests which have `expect(value).toMatchSnapshot()` assertions
+```
+
+For **all** test files, you can specify modules in Jest configuration. They precede built-in plugins for React, HTML, and Immutable.js data types. For example, in a `package.json` file:
+
+```json
+{
+  "jest": {
+    "snapshotSerializers": ["my-serializer-module"]
+  }
+}
+```
+
+## Writing plugins
+
+A plugin is a JavaScript object.
+
+If `options` has a `plugins` array: for the first plugin whose `test(val)` method returns a truthy value, then `prettyFormat(val, options)` returns the result from either:
+
+- `serialize(val, …)` method of the **improved** interface (available in **version 21** or later)
+- `print(val, …)` method of the **original** interface (if plugin does not have `serialize` method)
+
+### test
+
+Write `test` so it can receive `val` argument of any type. To serialize **objects** which have certain properties, then a guarded expression like `val != null && …` or more concise `val && …` prevents the following errors:
+
+- `TypeError: Cannot read property 'whatever' of null`
+- `TypeError: Cannot read property 'whatever' of undefined`
+
+For example, `test` method of built-in `ReactElement` plugin:
+
+```js
+const elementSymbol = Symbol.for('react.element');
+const test = val => val && val.$$typeof === elementSymbol;
+```
+
+Pay attention to efficiency in `test` because `pretty-format` calls it often.
+
+### serialize
+
+The **improved** interface is available in **version 21** or later.
+
+Write `serialize` to return a string, given the arguments:
+
+- `val` which “passed the test”
+- unchanging `config` object: derived from `options`
+- current `indentation` string: concatenate to `indent` from `config`
+- current `depth` number: compare to `maxDepth` from `config`
+- current `refs` array: find circular references in objects
+- `printer` callback function: serialize children
+
+### config
+
+<!-- prettier-ignore -->
+| key                 | type             | description                                                                             |
+| :------------------ | :--------------- | :-------------------------------------------------------------------------------------- |
+| `callToJSON`        | `boolean`        | call `toJSON` method (if it exists) on objects                                          |
+| `compareKeys`       | `function\|null` | compare function used when sorting object keys, `null` can be used to skip over sorting |
+| `colors`            | `Object`         | escape codes for colors to highlight syntax                                             |
+| `escapeRegex`       | `boolean`        | escape special characters in regular expressions                                        |
+| `escapeString`      | `boolean`        | escape special characters in strings                                                    |
+| `indent`            | `string`         | spaces in each level of indentation                                                     |
+| `maxDepth`          | `number`         | levels to print in arrays, objects, elements, and so on                                 |
+| `min`               | `boolean`        | minimize added space: no indentation nor line breaks                                    |
+| `plugins`           | `array`          | plugins to serialize application-specific data types                                    |
+| `printFunctionName` | `boolean`        | include or omit the name of a function                                                  |
+| `spacingInner`      | `string`         | spacing to separate items in a list                                                     |
+| `spacingOuter`      | `string`         | spacing to enclose a list of items                                                      |
+
+Each property of `colors` in `config` corresponds to a property of `theme` in `options`:
+
+- the key is the same (for example, `tag`)
+- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
+
+Some properties in `config` are derived from `min` in `options`:
+
+- `spacingInner` and `spacingOuter` are **newline** if `min` is `false`
+- `spacingInner` is **space** and `spacingOuter` is **empty string** if `min` is `true`
+
+### Example of serialize and test
+
+This plugin is a pattern you can apply to serialize composite data types. Side note: `pretty-format` does not need a plugin to serialize arrays.
+
+```js
+// We reused more code when we factored out a function for child items
+// that is independent of depth, name, and enclosing punctuation (see below).
+const SEPARATOR = ',';
+function serializeItems(items, config, indentation, depth, refs, printer) {
+  if (items.length === 0) {
+    return '';
+  }
+  const indentationItems = indentation + config.indent;
+  return (
+    config.spacingOuter +
+    items
+      .map(
+        item =>
+          indentationItems +
+          printer(item, config, indentationItems, depth, refs), // callback
+      )
+      .join(SEPARATOR + config.spacingInner) +
+    (config.min ? '' : SEPARATOR) + // following the last item
+    config.spacingOuter +
+    indentation
+  );
+}
+
+const plugin = {
+  test(val) {
+    return Array.isArray(val);
+  },
+  serialize(array, config, indentation, depth, refs, printer) {
+    const name = array.constructor.name;
+    return ++depth > config.maxDepth
+      ? `[${name}]`
+      : `${config.min ? '' : `${name} `}[${serializeItems(
+          array,
+          config,
+          indentation,
+          depth,
+          refs,
+          printer,
+        )}]`;
+  },
+};
+```
+
+```js
+const val = {
+  filter: 'completed',
+  items: [
+    {
+      text: 'Write test',
+      completed: true,
+    },
+    {
+      text: 'Write serialize',
+      completed: true,
+    },
+  ],
+};
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+  "filter": "completed",
+  "items": Array [
+    Object {
+      "completed": true,
+      "text": "Write test",
+    },
+    Object {
+      "completed": true,
+      "text": "Write serialize",
+    },
+  ],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    indent: 4,
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+    "filter": "completed",
+    "items": Array [
+        Object {
+            "completed": true,
+            "text": "Write test",
+        },
+        Object {
+            "completed": true,
+            "text": "Write serialize",
+        },
+    ],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    maxDepth: 1,
+    plugins: [plugin],
+  }),
+);
+/*
+Object {
+  "filter": "completed",
+  "items": [Array],
+}
+*/
+```
+
+```js
+console.log(
+  prettyFormat(val, {
+    min: true,
+    plugins: [plugin],
+  }),
+);
+/*
+{"filter": "completed", "items": [{"completed": true, "text": "Write test"}, {"completed": true, "text": "Write serialize"}]}
+*/
+```
+
+### print
+
+The **original** interface is adequate for plugins:
+
+- that **do not** depend on options other than `highlight` or `min`
+- that **do not** depend on `depth` or `refs` in recursive traversal, and
+- if values either
+  - do **not** require indentation, or
+  - do **not** occur as children of JavaScript data structures (for example, array)
+
+Write `print` to return a string, given the arguments:
+
+- `val` which “passed the test”
+- current `printer(valChild)` callback function: serialize children
+- current `indenter(lines)` callback function: indent lines at the next level
+- unchanging `config` object: derived from `options`
+- unchanging `colors` object: derived from `options`
+
+The 3 properties of `config` are `min` in `options` and:
+
+- `spacing` and `edgeSpacing` are **newline** if `min` is `false`
+- `spacing` is **space** and `edgeSpacing` is **empty string** if `min` is `true`
+
+Each property of `colors` corresponds to a property of `theme` in `options`:
+
+- the key is the same (for example, `tag`)
+- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
+
+### Example of print and test
+
+This plugin prints functions with the **number of named arguments** excluding rest argument.
+
+```js
+const plugin = {
+  print(val) {
+    return `[Function ${val.name || 'anonymous'} ${val.length}]`;
+  },
+  test(val) {
+    return typeof val === 'function';
+  },
+};
+```
+
+```js
+const val = {
+  onClick(event) {},
+  render() {},
+};
+
+prettyFormat(val, {
+  plugins: [plugin],
+});
+/*
+Object {
+  "onClick": [Function onClick 1],
+  "render": [Function render 0],
+}
+*/
+
+prettyFormat(val);
+/*
+Object {
+  "onClick": [Function onClick],
+  "render": [Function render],
+}
+*/
+```
+
+This plugin **ignores** the `printFunctionName` option. That limitation of the original `print` interface is a reason to use the improved `serialize` interface, described above.
+
+```js
+prettyFormat(val, {
+  plugins: [pluginOld],
+  printFunctionName: false,
+});
+/*
+Object {
+  "onClick": [Function onClick 1],
+  "render": [Function render 0],
+}
+*/
+
+prettyFormat(val, {
+  printFunctionName: false,
+});
+/*
+Object {
+  "onClick": [Function],
+  "render": [Function],
+}
+*/
+```

frontend/node_modules/@jest/core/node_modules/pretty-format/build/collections.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.printIteratorEntries = printIteratorEntries;
+exports.printIteratorValues = printIteratorValues;
+exports.printListItems = printListItems;
+exports.printObjectProperties = printObjectProperties;
+/**
+ * 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.
+ *
+ */
+
+const getKeysOfEnumerableProperties = (object, compareKeys) => {
+  const rawKeys = Object.keys(object);
+  const keys = compareKeys !== null ? rawKeys.sort(compareKeys) : rawKeys;
+  if (Object.getOwnPropertySymbols) {
+    Object.getOwnPropertySymbols(object).forEach(symbol => {
+      if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+        keys.push(symbol);
+      }
+    });
+  }
+  return keys;
+};
+
+/**
+ * Return entries (for example, of a map)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+function printIteratorEntries(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  // Too bad, so sad that separator for ECMAScript Map has been ' => '
+  // What a distracting diff if you change a data structure to/from
+  // ECMAScript Object or Immutable.Map/OrderedMap which use the default.
+  separator = ': '
+) {
+  let result = '';
+  let width = 0;
+  let current = iterator.next();
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    while (!current.done) {
+      result += indentationNext;
+      if (width++ === config.maxWidth) {
+        result += '…';
+        break;
+      }
+      const name = printer(
+        current.value[0],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      const value = printer(
+        current.value[1],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      result += name + separator + value;
+      current = iterator.next();
+      if (!current.done) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+
+/**
+ * Return values (for example, of a set)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (braces or brackets)
+ */
+function printIteratorValues(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) {
+  let result = '';
+  let width = 0;
+  let current = iterator.next();
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    while (!current.done) {
+      result += indentationNext;
+      if (width++ === config.maxWidth) {
+        result += '…';
+        break;
+      }
+      result += printer(current.value, config, indentationNext, depth, refs);
+      current = iterator.next();
+      if (!current.done) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+
+/**
+ * Return items (for example, of an array)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, brackets)
+ **/
+function printListItems(list, config, indentation, depth, refs, printer) {
+  let result = '';
+  if (list.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    for (let i = 0; i < list.length; i++) {
+      result += indentationNext;
+      if (i === config.maxWidth) {
+        result += '…';
+        break;
+      }
+      if (i in list) {
+        result += printer(list[i], config, indentationNext, depth, refs);
+      }
+      if (i < list.length - 1) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+
+/**
+ * Return properties of an object
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+function printObjectProperties(val, config, indentation, depth, refs, printer) {
+  let result = '';
+  const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+  if (keys.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const name = printer(key, config, indentationNext, depth, refs);
+      const value = printer(val[key], config, indentationNext, depth, refs);
+      result += `${indentationNext + name}: ${value}`;
+      if (i < keys.length - 1) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}

frontend/node_modules/@jest/core/node_modules/pretty-format/build/index.d.ts

@@ -0,0 +1,163 @@
+/**
+ * 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.
+ */
+import type {SnapshotFormat} from '@jest/schemas';
+
+export declare type Colors = {
+  comment: {
+    close: string;
+    open: string;
+  };
+  content: {
+    close: string;
+    open: string;
+  };
+  prop: {
+    close: string;
+    open: string;
+  };
+  tag: {
+    close: string;
+    open: string;
+  };
+  value: {
+    close: string;
+    open: string;
+  };
+};
+
+export declare type CompareKeys =
+  | ((a: string, b: string) => number)
+  | null
+  | undefined;
+
+export declare type Config = {
+  callToJSON: boolean;
+  compareKeys: CompareKeys;
+  colors: Colors;
+  escapeRegex: boolean;
+  escapeString: boolean;
+  indent: string;
+  maxDepth: number;
+  maxWidth: number;
+  min: boolean;
+  plugins: Plugins;
+  printBasicPrototype: boolean;
+  printFunctionName: boolean;
+  spacingInner: string;
+  spacingOuter: string;
+};
+
+export declare const DEFAULT_OPTIONS: {
+  callToJSON: true;
+  compareKeys: undefined;
+  escapeRegex: false;
+  escapeString: true;
+  highlight: false;
+  indent: number;
+  maxDepth: number;
+  maxWidth: number;
+  min: false;
+  plugins: never[];
+  printBasicPrototype: true;
+  printFunctionName: true;
+  theme: Required<{
+    readonly comment?: string | undefined;
+    readonly content?: string | undefined;
+    readonly prop?: string | undefined;
+    readonly tag?: string | undefined;
+    readonly value?: string | undefined;
+  }>;
+};
+
+/**
+ * Returns a presentation string of your `val` object
+ * @param val any potential JavaScript object
+ * @param options Custom settings
+ */
+declare function format(val: unknown, options?: OptionsReceived): string;
+export default format;
+export {format};
+
+declare type Indent = (arg0: string) => string;
+
+export declare type NewPlugin = {
+  serialize: (
+    val: any,
+    config: Config,
+    indentation: string,
+    depth: number,
+    refs: Refs,
+    printer: Printer,
+  ) => string;
+  test: Test;
+};
+
+export declare type OldPlugin = {
+  print: (
+    val: unknown,
+    print: Print,
+    indent: Indent,
+    options: PluginOptions,
+    colors: Colors,
+  ) => string;
+  test: Test;
+};
+
+export declare interface Options
+  extends Omit<RequiredOptions, 'compareKeys' | 'theme'> {
+  compareKeys: CompareKeys;
+  theme: Required<RequiredOptions['theme']>;
+}
+
+export declare type OptionsReceived = PrettyFormatOptions;
+
+declare type Plugin_2 = NewPlugin | OldPlugin;
+export {Plugin_2 as Plugin};
+
+declare type PluginOptions = {
+  edgeSpacing: string;
+  min: boolean;
+  spacing: string;
+};
+
+export declare type Plugins = Array<Plugin_2>;
+
+export declare const plugins: {
+  AsymmetricMatcher: NewPlugin;
+  DOMCollection: NewPlugin;
+  DOMElement: NewPlugin;
+  Immutable: NewPlugin;
+  ReactElement: NewPlugin;
+  ReactTestComponent: NewPlugin;
+};
+
+export declare interface PrettyFormatOptions
+  extends Omit<SnapshotFormat, 'compareKeys'> {
+  compareKeys?: CompareKeys;
+  plugins?: Plugins;
+}
+
+declare type Print = (arg0: unknown) => string;
+
+export declare type Printer = (
+  val: unknown,
+  config: Config,
+  indentation: string,
+  depth: number,
+  refs: Refs,
+  hasCalledToJSON?: boolean,
+) => string;
+
+export declare type Refs = Array<unknown>;
+
+declare type RequiredOptions = Required<PrettyFormatOptions>;
+
+declare type Test = (arg0: any) => boolean;
+
+export declare type Theme = Options['theme'];
+
+export {};

frontend/node_modules/@jest/core/node_modules/pretty-format/build/index.js

@@ -0,0 +1,478 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = exports.DEFAULT_OPTIONS = void 0;
+exports.format = format;
+exports.plugins = void 0;
+var _ansiStyles = _interopRequireDefault(require('ansi-styles'));
+var _collections = require('./collections');
+var _AsymmetricMatcher = _interopRequireDefault(
+  require('./plugins/AsymmetricMatcher')
+);
+var _DOMCollection = _interopRequireDefault(require('./plugins/DOMCollection'));
+var _DOMElement = _interopRequireDefault(require('./plugins/DOMElement'));
+var _Immutable = _interopRequireDefault(require('./plugins/Immutable'));
+var _ReactElement = _interopRequireDefault(require('./plugins/ReactElement'));
+var _ReactTestComponent = _interopRequireDefault(
+  require('./plugins/ReactTestComponent')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+
+const toString = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+
+/**
+ * Explicitly comparing typeof constructor to function avoids undefined as name
+ * when mock identity-obj-proxy returns the key as the value for any key.
+ */
+const getConstructorName = val =>
+  (typeof val.constructor === 'function' && val.constructor.name) || 'Object';
+
+/* global window */
+/** Is val is equal to global window object? Works even if it does not exist :) */
+const isWindow = val => typeof window !== 'undefined' && val === window;
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/gi;
+class PrettyFormatPluginError extends Error {
+  constructor(message, stack) {
+    super(message);
+    this.stack = stack;
+    this.name = this.constructor.name;
+  }
+}
+function isToStringedArrayType(toStringed) {
+  return (
+    toStringed === '[object Array]' ||
+    toStringed === '[object ArrayBuffer]' ||
+    toStringed === '[object DataView]' ||
+    toStringed === '[object Float32Array]' ||
+    toStringed === '[object Float64Array]' ||
+    toStringed === '[object Int8Array]' ||
+    toStringed === '[object Int16Array]' ||
+    toStringed === '[object Int32Array]' ||
+    toStringed === '[object Uint8Array]' ||
+    toStringed === '[object Uint8ClampedArray]' ||
+    toStringed === '[object Uint16Array]' ||
+    toStringed === '[object Uint32Array]'
+  );
+}
+function printNumber(val) {
+  return Object.is(val, -0) ? '-0' : String(val);
+}
+function printBigInt(val) {
+  return String(`${val}n`);
+}
+function printFunction(val, printFunctionName) {
+  if (!printFunctionName) {
+    return '[Function]';
+  }
+  return `[Function ${val.name || 'anonymous'}]`;
+}
+function printSymbol(val) {
+  return String(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+}
+function printError(val) {
+  return `[${errorToString.call(val)}]`;
+}
+
+/**
+ * The first port of call for printing an object, handles most of the
+ * data-types in JS.
+ */
+function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+  if (val === true || val === false) {
+    return `${val}`;
+  }
+  if (val === undefined) {
+    return 'undefined';
+  }
+  if (val === null) {
+    return 'null';
+  }
+  const typeOf = typeof val;
+  if (typeOf === 'number') {
+    return printNumber(val);
+  }
+  if (typeOf === 'bigint') {
+    return printBigInt(val);
+  }
+  if (typeOf === 'string') {
+    if (escapeString) {
+      return `"${val.replace(/"|\\/g, '\\$&')}"`;
+    }
+    return `"${val}"`;
+  }
+  if (typeOf === 'function') {
+    return printFunction(val, printFunctionName);
+  }
+  if (typeOf === 'symbol') {
+    return printSymbol(val);
+  }
+  const toStringed = toString.call(val);
+  if (toStringed === '[object WeakMap]') {
+    return 'WeakMap {}';
+  }
+  if (toStringed === '[object WeakSet]') {
+    return 'WeakSet {}';
+  }
+  if (
+    toStringed === '[object Function]' ||
+    toStringed === '[object GeneratorFunction]'
+  ) {
+    return printFunction(val, printFunctionName);
+  }
+  if (toStringed === '[object Symbol]') {
+    return printSymbol(val);
+  }
+  if (toStringed === '[object Date]') {
+    return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+  }
+  if (toStringed === '[object Error]') {
+    return printError(val);
+  }
+  if (toStringed === '[object RegExp]') {
+    if (escapeRegex) {
+      // https://github.com/benjamingr/RegExp.escape/blob/main/polyfill.js
+      return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    return regExpToString.call(val);
+  }
+  if (val instanceof Error) {
+    return printError(val);
+  }
+  return null;
+}
+
+/**
+ * Handles more complex objects ( such as objects with circular references.
+ * maps and sets etc )
+ */
+function printComplexValue(
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  hasCalledToJSON
+) {
+  if (refs.indexOf(val) !== -1) {
+    return '[Circular]';
+  }
+  refs = refs.slice();
+  refs.push(val);
+  const hitMaxDepth = ++depth > config.maxDepth;
+  const min = config.min;
+  if (
+    config.callToJSON &&
+    !hitMaxDepth &&
+    val.toJSON &&
+    typeof val.toJSON === 'function' &&
+    !hasCalledToJSON
+  ) {
+    return printer(val.toJSON(), config, indentation, depth, refs, true);
+  }
+  const toStringed = toString.call(val);
+  if (toStringed === '[object Arguments]') {
+    return hitMaxDepth
+      ? '[Arguments]'
+      : `${min ? '' : 'Arguments '}[${(0, _collections.printListItems)(
+          val,
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )}]`;
+  }
+  if (isToStringedArrayType(toStringed)) {
+    return hitMaxDepth
+      ? `[${val.constructor.name}]`
+      : `${
+          min
+            ? ''
+            : !config.printBasicPrototype && val.constructor.name === 'Array'
+            ? ''
+            : `${val.constructor.name} `
+        }[${(0, _collections.printListItems)(
+          val,
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )}]`;
+  }
+  if (toStringed === '[object Map]') {
+    return hitMaxDepth
+      ? '[Map]'
+      : `Map {${(0, _collections.printIteratorEntries)(
+          val.entries(),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer,
+          ' => '
+        )}}`;
+  }
+  if (toStringed === '[object Set]') {
+    return hitMaxDepth
+      ? '[Set]'
+      : `Set {${(0, _collections.printIteratorValues)(
+          val.values(),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )}}`;
+  }
+
+  // Avoid failure to serialize global window object in jsdom test environment.
+  // For example, not even relevant if window is prop of React element.
+  return hitMaxDepth || isWindow(val)
+    ? `[${getConstructorName(val)}]`
+    : `${
+        min
+          ? ''
+          : !config.printBasicPrototype && getConstructorName(val) === 'Object'
+          ? ''
+          : `${getConstructorName(val)} `
+      }{${(0, _collections.printObjectProperties)(
+        val,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      )}}`;
+}
+function isNewPlugin(plugin) {
+  return plugin.serialize != null;
+}
+function printPlugin(plugin, val, config, indentation, depth, refs) {
+  let printed;
+  try {
+    printed = isNewPlugin(plugin)
+      ? plugin.serialize(val, config, indentation, depth, refs, printer)
+      : plugin.print(
+          val,
+          valChild => printer(valChild, config, indentation, depth, refs),
+          str => {
+            const indentationNext = indentation + config.indent;
+            return (
+              indentationNext +
+              str.replace(NEWLINE_REGEXP, `\n${indentationNext}`)
+            );
+          },
+          {
+            edgeSpacing: config.spacingOuter,
+            min: config.min,
+            spacing: config.spacingInner
+          },
+          config.colors
+        );
+  } catch (error) {
+    throw new PrettyFormatPluginError(error.message, error.stack);
+  }
+  if (typeof printed !== 'string') {
+    throw new Error(
+      `pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`
+    );
+  }
+  return printed;
+}
+function findPlugin(plugins, val) {
+  for (let p = 0; p < plugins.length; p++) {
+    try {
+      if (plugins[p].test(val)) {
+        return plugins[p];
+      }
+    } catch (error) {
+      throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+  }
+  return null;
+}
+function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+  const plugin = findPlugin(config.plugins, val);
+  if (plugin !== null) {
+    return printPlugin(plugin, val, config, indentation, depth, refs);
+  }
+  const basicResult = printBasicValue(
+    val,
+    config.printFunctionName,
+    config.escapeRegex,
+    config.escapeString
+  );
+  if (basicResult !== null) {
+    return basicResult;
+  }
+  return printComplexValue(
+    val,
+    config,
+    indentation,
+    depth,
+    refs,
+    hasCalledToJSON
+  );
+}
+const DEFAULT_THEME = {
+  comment: 'gray',
+  content: 'reset',
+  prop: 'yellow',
+  tag: 'cyan',
+  value: 'green'
+};
+const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+
+// could be replaced by `satisfies` operator in the future: https://github.com/microsoft/TypeScript/issues/47920
+const toOptionsSubtype = options => options;
+const DEFAULT_OPTIONS = toOptionsSubtype({
+  callToJSON: true,
+  compareKeys: undefined,
+  escapeRegex: false,
+  escapeString: true,
+  highlight: false,
+  indent: 2,
+  maxDepth: Infinity,
+  maxWidth: Infinity,
+  min: false,
+  plugins: [],
+  printBasicPrototype: true,
+  printFunctionName: true,
+  theme: DEFAULT_THEME
+});
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+function validateOptions(options) {
+  Object.keys(options).forEach(key => {
+    if (!Object.prototype.hasOwnProperty.call(DEFAULT_OPTIONS, key)) {
+      throw new Error(`pretty-format: Unknown option "${key}".`);
+    }
+  });
+  if (options.min && options.indent !== undefined && options.indent !== 0) {
+    throw new Error(
+      'pretty-format: Options "min" and "indent" cannot be used together.'
+    );
+  }
+  if (options.theme !== undefined) {
+    if (options.theme === null) {
+      throw new Error('pretty-format: Option "theme" must not be null.');
+    }
+    if (typeof options.theme !== 'object') {
+      throw new Error(
+        `pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`
+      );
+    }
+  }
+}
+const getColorsHighlight = options =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    const value =
+      options.theme && options.theme[key] !== undefined
+        ? options.theme[key]
+        : DEFAULT_THEME[key];
+    const color = value && _ansiStyles.default[value];
+    if (
+      color &&
+      typeof color.close === 'string' &&
+      typeof color.open === 'string'
+    ) {
+      colors[key] = color;
+    } else {
+      throw new Error(
+        `pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`
+      );
+    }
+    return colors;
+  }, Object.create(null));
+const getColorsEmpty = () =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    colors[key] = {
+      close: '',
+      open: ''
+    };
+    return colors;
+  }, Object.create(null));
+const getPrintFunctionName = options =>
+  options?.printFunctionName ?? DEFAULT_OPTIONS.printFunctionName;
+const getEscapeRegex = options =>
+  options?.escapeRegex ?? DEFAULT_OPTIONS.escapeRegex;
+const getEscapeString = options =>
+  options?.escapeString ?? DEFAULT_OPTIONS.escapeString;
+const getConfig = options => ({
+  callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS.callToJSON,
+  colors: options?.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+  compareKeys:
+    typeof options?.compareKeys === 'function' || options?.compareKeys === null
+      ? options.compareKeys
+      : DEFAULT_OPTIONS.compareKeys,
+  escapeRegex: getEscapeRegex(options),
+  escapeString: getEscapeString(options),
+  indent: options?.min
+    ? ''
+    : createIndent(options?.indent ?? DEFAULT_OPTIONS.indent),
+  maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS.maxDepth,
+  maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS.maxWidth,
+  min: options?.min ?? DEFAULT_OPTIONS.min,
+  plugins: options?.plugins ?? DEFAULT_OPTIONS.plugins,
+  printBasicPrototype: options?.printBasicPrototype ?? true,
+  printFunctionName: getPrintFunctionName(options),
+  spacingInner: options?.min ? ' ' : '\n',
+  spacingOuter: options?.min ? '' : '\n'
+});
+function createIndent(indent) {
+  return new Array(indent + 1).join(' ');
+}
+
+/**
+ * Returns a presentation string of your `val` object
+ * @param val any potential JavaScript object
+ * @param options Custom settings
+ */
+function format(val, options) {
+  if (options) {
+    validateOptions(options);
+    if (options.plugins) {
+      const plugin = findPlugin(options.plugins, val);
+      if (plugin !== null) {
+        return printPlugin(plugin, val, getConfig(options), '', 0, []);
+      }
+    }
+  }
+  const basicResult = printBasicValue(
+    val,
+    getPrintFunctionName(options),
+    getEscapeRegex(options),
+    getEscapeString(options)
+  );
+  if (basicResult !== null) {
+    return basicResult;
+  }
+  return printComplexValue(val, getConfig(options), '', 0, []);
+}
+const plugins = {
+  AsymmetricMatcher: _AsymmetricMatcher.default,
+  DOMCollection: _DOMCollection.default,
+  DOMElement: _DOMElement.default,
+  Immutable: _Immutable.default,
+  ReactElement: _ReactElement.default,
+  ReactTestComponent: _ReactTestComponent.default
+};
+exports.plugins = plugins;
+var _default = format;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/AsymmetricMatcher.js

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var _collections = require('../collections');
+var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+/**
+ * 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.
+ */
+const asymmetricMatcher =
+  typeof Symbol === 'function' && Symbol.for
+    ? Symbol.for('jest.asymmetricMatcher')
+    : 0x1357a5;
+const SPACE = ' ';
+const serialize = (val, config, indentation, depth, refs, printer) => {
+  const stringedValue = val.toString();
+  if (
+    stringedValue === 'ArrayContaining' ||
+    stringedValue === 'ArrayNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return `[${stringedValue}]`;
+    }
+    return `${stringedValue + SPACE}[${(0, _collections.printListItems)(
+      val.sample,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    )}]`;
+  }
+  if (
+    stringedValue === 'ObjectContaining' ||
+    stringedValue === 'ObjectNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return `[${stringedValue}]`;
+    }
+    return `${stringedValue + SPACE}{${(0, _collections.printObjectProperties)(
+      val.sample,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer
+    )}}`;
+  }
+  if (
+    stringedValue === 'StringMatching' ||
+    stringedValue === 'StringNotMatching'
+  ) {
+    return (
+      stringedValue +
+      SPACE +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+  if (
+    stringedValue === 'StringContaining' ||
+    stringedValue === 'StringNotContaining'
+  ) {
+    return (
+      stringedValue +
+      SPACE +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+  if (typeof val.toAsymmetricMatcher !== 'function') {
+    throw new Error(
+      `Asymmetric matcher ${val.constructor.name} does not implement toAsymmetricMatcher()`
+    );
+  }
+  return val.toAsymmetricMatcher();
+};
+exports.serialize = serialize;
+const test = val => val && val.$$typeof === asymmetricMatcher;
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/DOMCollection.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var _collections = require('../collections');
+/**
+ * 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.
+ */
+
+const SPACE = ' ';
+const OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
+const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+const testName = name =>
+  OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+const test = val =>
+  val &&
+  val.constructor &&
+  !!val.constructor.name &&
+  testName(val.constructor.name);
+exports.test = test;
+const isNamedNodeMap = collection =>
+  collection.constructor.name === 'NamedNodeMap';
+const serialize = (collection, config, indentation, depth, refs, printer) => {
+  const name = collection.constructor.name;
+  if (++depth > config.maxDepth) {
+    return `[${name}]`;
+  }
+  return (
+    (config.min ? '' : name + SPACE) +
+    (OBJECT_NAMES.indexOf(name) !== -1
+      ? `{${(0, _collections.printObjectProperties)(
+          isNamedNodeMap(collection)
+            ? Array.from(collection).reduce((props, attribute) => {
+                props[attribute.name] = attribute.value;
+                return props;
+              }, {})
+            : {
+                ...collection
+              },
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )}}`
+      : `[${(0, _collections.printListItems)(
+          Array.from(collection),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )}]`)
+  );
+};
+exports.serialize = serialize;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/DOMElement.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var _markup = require('./lib/markup');
+/**
+ * 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.
+ */
+
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const FRAGMENT_NODE = 11;
+const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+const testHasAttribute = val => {
+  try {
+    return typeof val.hasAttribute === 'function' && val.hasAttribute('is');
+  } catch {
+    return false;
+  }
+};
+const testNode = val => {
+  const constructorName = val.constructor.name;
+  const {nodeType, tagName} = val;
+  const isCustomElement =
+    (typeof tagName === 'string' && tagName.includes('-')) ||
+    testHasAttribute(val);
+  return (
+    (nodeType === ELEMENT_NODE &&
+      (ELEMENT_REGEXP.test(constructorName) || isCustomElement)) ||
+    (nodeType === TEXT_NODE && constructorName === 'Text') ||
+    (nodeType === COMMENT_NODE && constructorName === 'Comment') ||
+    (nodeType === FRAGMENT_NODE && constructorName === 'DocumentFragment')
+  );
+};
+const test = val => val?.constructor?.name && testNode(val);
+exports.test = test;
+function nodeIsText(node) {
+  return node.nodeType === TEXT_NODE;
+}
+function nodeIsComment(node) {
+  return node.nodeType === COMMENT_NODE;
+}
+function nodeIsFragment(node) {
+  return node.nodeType === FRAGMENT_NODE;
+}
+const serialize = (node, config, indentation, depth, refs, printer) => {
+  if (nodeIsText(node)) {
+    return (0, _markup.printText)(node.data, config);
+  }
+  if (nodeIsComment(node)) {
+    return (0, _markup.printComment)(node.data, config);
+  }
+  const type = nodeIsFragment(node)
+    ? 'DocumentFragment'
+    : node.tagName.toLowerCase();
+  if (++depth > config.maxDepth) {
+    return (0, _markup.printElementAsLeaf)(type, config);
+  }
+  return (0, _markup.printElement)(
+    type,
+    (0, _markup.printProps)(
+      nodeIsFragment(node)
+        ? []
+        : Array.from(node.attributes, attr => attr.name).sort(),
+      nodeIsFragment(node)
+        ? {}
+        : Array.from(node.attributes).reduce((props, attribute) => {
+            props[attribute.name] = attribute.value;
+            return props;
+          }, {}),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    (0, _markup.printChildren)(
+      Array.prototype.slice.call(node.childNodes || node.children),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    config,
+    indentation
+  );
+};
+exports.serialize = serialize;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/Immutable.js

@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var _collections = require('../collections');
+/**
+ * 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.
+ */
+
+// SENTINEL constants are from https://github.com/facebook/immutable-js
+const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
+const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+const getImmutableName = name => `Immutable.${name}`;
+const printAsLeaf = name => `[${name}]`;
+const SPACE = ' ';
+const LAZY = '…'; // Seq is lazy if it calls a method like filter
+
+const printImmutableEntries = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : `${getImmutableName(type) + SPACE}{${(0,
+      _collections.printIteratorEntries)(
+        val.entries(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      )}}`;
+
+// Record has an entries method because it is a collection in immutable v3.
+// Return an iterator for Immutable Record from version v3 or v4.
+function getRecordEntries(val) {
+  let i = 0;
+  return {
+    next() {
+      if (i < val._keys.length) {
+        const key = val._keys[i++];
+        return {
+          done: false,
+          value: [key, val.get(key)]
+        };
+      }
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+  };
+}
+const printImmutableRecord = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) => {
+  // _name property is defined only for an Immutable Record instance
+  // which was constructed with a second optional descriptive name arg
+  const name = getImmutableName(val._name || 'Record');
+  return ++depth > config.maxDepth
+    ? printAsLeaf(name)
+    : `${name + SPACE}{${(0, _collections.printIteratorEntries)(
+        getRecordEntries(val),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      )}}`;
+};
+const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
+  const name = getImmutableName('Seq');
+  if (++depth > config.maxDepth) {
+    return printAsLeaf(name);
+  }
+  if (val[IS_KEYED_SENTINEL]) {
+    return `${name + SPACE}{${
+      // from Immutable collection of entries or from ECMAScript object
+      val._iter || val._object
+        ? (0, _collections.printIteratorEntries)(
+            val.entries(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          )
+        : LAZY
+    }}`;
+  }
+  return `${name + SPACE}[${
+    val._iter ||
+    // from Immutable collection of values
+    val._array ||
+    // from ECMAScript array
+    val._collection ||
+    // from ECMAScript collection in immutable v4
+    val._iterable // from ECMAScript collection in immutable v3
+      ? (0, _collections.printIteratorValues)(
+          val.values(),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )
+      : LAZY
+  }]`;
+};
+const printImmutableValues = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : `${getImmutableName(type) + SPACE}[${(0,
+      _collections.printIteratorValues)(
+        val.values(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      )}]`;
+const serialize = (val, config, indentation, depth, refs, printer) => {
+  if (val[IS_MAP_SENTINEL]) {
+    return printImmutableEntries(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
+    );
+  }
+  if (val[IS_LIST_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'List'
+    );
+  }
+  if (val[IS_SET_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
+    );
+  }
+  if (val[IS_STACK_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'Stack'
+    );
+  }
+  if (val[IS_SEQ_SENTINEL]) {
+    return printImmutableSeq(val, config, indentation, depth, refs, printer);
+  }
+
+  // For compatibility with immutable v3 and v4, let record be the default.
+  return printImmutableRecord(val, config, indentation, depth, refs, printer);
+};
+
+// Explicitly comparing sentinel properties to true avoids false positive
+// when mock identity-obj-proxy returns the key as the value for any key.
+exports.serialize = serialize;
+const test = val =>
+  val &&
+  (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/ReactElement.js

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var ReactIs = _interopRequireWildcard(require('react-is'));
+var _markup = require('./lib/markup');
+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;
+}
+/**
+ * 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.
+ */
+
+// Given element.props.children, or subtree during recursive traversal,
+// return flattened array of children.
+const getChildren = (arg, children = []) => {
+  if (Array.isArray(arg)) {
+    arg.forEach(item => {
+      getChildren(item, children);
+    });
+  } else if (arg != null && arg !== false) {
+    children.push(arg);
+  }
+  return children;
+};
+const getType = element => {
+  const type = element.type;
+  if (typeof type === 'string') {
+    return type;
+  }
+  if (typeof type === 'function') {
+    return type.displayName || type.name || 'Unknown';
+  }
+  if (ReactIs.isFragment(element)) {
+    return 'React.Fragment';
+  }
+  if (ReactIs.isSuspense(element)) {
+    return 'React.Suspense';
+  }
+  if (typeof type === 'object' && type !== null) {
+    if (ReactIs.isContextProvider(element)) {
+      return 'Context.Provider';
+    }
+    if (ReactIs.isContextConsumer(element)) {
+      return 'Context.Consumer';
+    }
+    if (ReactIs.isForwardRef(element)) {
+      if (type.displayName) {
+        return type.displayName;
+      }
+      const functionName = type.render.displayName || type.render.name || '';
+      return functionName !== '' ? `ForwardRef(${functionName})` : 'ForwardRef';
+    }
+    if (ReactIs.isMemo(element)) {
+      const functionName =
+        type.displayName || type.type.displayName || type.type.name || '';
+      return functionName !== '' ? `Memo(${functionName})` : 'Memo';
+    }
+  }
+  return 'UNDEFINED';
+};
+const getPropKeys = element => {
+  const {props} = element;
+  return Object.keys(props)
+    .filter(key => key !== 'children' && props[key] !== undefined)
+    .sort();
+};
+const serialize = (element, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup.printElementAsLeaf)(getType(element), config)
+    : (0, _markup.printElement)(
+        getType(element),
+        (0, _markup.printProps)(
+          getPropKeys(element),
+          element.props,
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        (0, _markup.printChildren)(
+          getChildren(element.props.children),
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        config,
+        indentation
+      );
+exports.serialize = serialize;
+const test = val => val != null && ReactIs.isElement(val);
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/ReactTestComponent.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.test = exports.serialize = exports.default = void 0;
+var _markup = require('./lib/markup');
+var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+/**
+ * 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.
+ */
+// Child can be `number` in Stack renderer but not in Fiber renderer.
+
+const testSymbol =
+  typeof Symbol === 'function' && Symbol.for
+    ? Symbol.for('react.test.json')
+    : 0xea71357;
+const getPropKeys = object => {
+  const {props} = object;
+  return props
+    ? Object.keys(props)
+        .filter(key => props[key] !== undefined)
+        .sort()
+    : [];
+};
+const serialize = (object, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup.printElementAsLeaf)(object.type, config)
+    : (0, _markup.printElement)(
+        object.type,
+        object.props
+          ? (0, _markup.printProps)(
+              getPropKeys(object),
+              object.props,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        object.children
+          ? (0, _markup.printChildren)(
+              object.children,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        config,
+        indentation
+      );
+exports.serialize = serialize;
+const test = val => val && val.$$typeof === testSymbol;
+exports.test = test;
+const plugin = {
+  serialize,
+  test
+};
+var _default = plugin;
+exports.default = _default;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/lib/escapeHTML.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = escapeHTML;
+/**
+ * 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.
+ */
+
+function escapeHTML(str) {
+  return str.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

frontend/node_modules/@jest/core/node_modules/pretty-format/build/plugins/lib/markup.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.printText =
+  exports.printProps =
+  exports.printElementAsLeaf =
+  exports.printElement =
+  exports.printComment =
+  exports.printChildren =
+    void 0;
+var _escapeHTML = _interopRequireDefault(require('./escapeHTML'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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.
+ */
+
+// Return empty string if keys is empty.
+const printProps = (keys, props, config, indentation, depth, refs, printer) => {
+  const indentationNext = indentation + config.indent;
+  const colors = config.colors;
+  return keys
+    .map(key => {
+      const value = props[key];
+      let printed = printer(value, config, indentationNext, depth, refs);
+      if (typeof value !== 'string') {
+        if (printed.indexOf('\n') !== -1) {
+          printed =
+            config.spacingOuter +
+            indentationNext +
+            printed +
+            config.spacingOuter +
+            indentation;
+        }
+        printed = `{${printed}}`;
+      }
+      return `${
+        config.spacingInner +
+        indentation +
+        colors.prop.open +
+        key +
+        colors.prop.close
+      }=${colors.value.open}${printed}${colors.value.close}`;
+    })
+    .join('');
+};
+
+// Return empty string if children is empty.
+exports.printProps = printProps;
+const printChildren = (children, config, indentation, depth, refs, printer) =>
+  children
+    .map(
+      child =>
+        config.spacingOuter +
+        indentation +
+        (typeof child === 'string'
+          ? printText(child, config)
+          : printer(child, config, indentation, depth, refs))
+    )
+    .join('');
+exports.printChildren = printChildren;
+const printText = (text, config) => {
+  const contentColor = config.colors.content;
+  return (
+    contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close
+  );
+};
+exports.printText = printText;
+const printComment = (comment, config) => {
+  const commentColor = config.colors.comment;
+  return `${commentColor.open}<!--${(0, _escapeHTML.default)(comment)}-->${
+    commentColor.close
+  }`;
+};
+
+// Separate the functions to format props, children, and element,
+// so a plugin could override a particular function, if needed.
+// Too bad, so sad: the traditional (but unnecessary) space
+// in a self-closing tagColor requires a second test of printedProps.
+exports.printComment = printComment;
+const printElement = (
+  type,
+  printedProps,
+  printedChildren,
+  config,
+  indentation
+) => {
+  const tagColor = config.colors.tag;
+  return `${tagColor.open}<${type}${
+    printedProps &&
+    tagColor.close +
+      printedProps +
+      config.spacingOuter +
+      indentation +
+      tagColor.open
+  }${
+    printedChildren
+      ? `>${tagColor.close}${printedChildren}${config.spacingOuter}${indentation}${tagColor.open}</${type}`
+      : `${printedProps && !config.min ? '' : ' '}/`
+  }>${tagColor.close}`;
+};
+exports.printElement = printElement;
+const printElementAsLeaf = (type, config) => {
+  const tagColor = config.colors.tag;
+  return `${tagColor.open}<${type}${tagColor.close} …${tagColor.open} />${tagColor.close}`;
+};
+exports.printElementAsLeaf = printElementAsLeaf;

frontend/node_modules/@jest/core/node_modules/pretty-format/build/types.js

@@ -0,0 +1 @@
+'use strict';

frontend/node_modules/@jest/core/node_modules/pretty-format/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "pretty-format",
+  "version": "29.7.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/pretty-format"
+  },
+  "license": "MIT",
+  "description": "Stringify any JavaScript value.",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "James Kyle <me@thejameskyle.com>",
+  "dependencies": {
+    "@jest/schemas": "^29.6.3",
+    "ansi-styles": "^5.0.0",
+    "react-is": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^17.0.3",
+    "@types/react-is": "^18.0.0",
+    "@types/react-test-renderer": "17.0.2",
+    "immutable": "^4.0.0",
+    "jest-util": "^29.7.0",
+    "react": "17.0.2",
+    "react-dom": "^17.0.1",
+    "react-test-renderer": "17.0.2"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
+}

frontend/node_modules/@jest/core/node_modules/react-is/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.

frontend/node_modules/@jest/core/node_modules/react-is/README.md

@@ -0,0 +1,104 @@
+# `react-is`
+
+This package allows you to test arbitrary values and see if they're a particular React element type.
+
+## Installation
+
+```sh
+# Yarn
+yarn add react-is
+
+# NPM
+npm install react-is
+```
+
+## Usage
+
+### Determining if a Component is Valid
+
+```js
+import React from "react";
+import * as ReactIs from "react-is";
+
+class ClassComponent extends React.Component {
+  render() {
+    return React.createElement("div");
+  }
+}
+
+const FunctionComponent = () => React.createElement("div");
+
+const ForwardRefComponent = React.forwardRef((props, ref) =>
+  React.createElement(Component, { forwardedRef: ref, ...props })
+);
+
+const Context = React.createContext(false);
+
+ReactIs.isValidElementType("div"); // true
+ReactIs.isValidElementType(ClassComponent); // true
+ReactIs.isValidElementType(FunctionComponent); // true
+ReactIs.isValidElementType(ForwardRefComponent); // true
+ReactIs.isValidElementType(Context.Provider); // true
+ReactIs.isValidElementType(Context.Consumer); // true
+ReactIs.isValidElementType(React.createFactory("div")); // true
+```
+
+### Determining an Element's Type
+
+#### Context
+
+```js
+import React from "react";
+import * as ReactIs from 'react-is';
+
+const ThemeContext = React.createContext("blue");
+
+ReactIs.isContextConsumer(<ThemeContext.Consumer />); // true
+ReactIs.isContextProvider(<ThemeContext.Provider />); // true
+ReactIs.typeOf(<ThemeContext.Provider />) === ReactIs.ContextProvider; // true
+ReactIs.typeOf(<ThemeContext.Consumer />) === ReactIs.ContextConsumer; // true
+```
+
+#### Element
+
+```js
+import React from "react";
+import * as ReactIs from 'react-is';
+
+ReactIs.isElement(<div />); // true
+ReactIs.typeOf(<div />) === ReactIs.Element; // true
+```
+
+#### Fragment
+
+```js
+import React from "react";
+import * as ReactIs from 'react-is';
+
+ReactIs.isFragment(<></>); // true
+ReactIs.typeOf(<></>) === ReactIs.Fragment; // true
+```
+
+#### Portal
+
+```js
+import React from "react";
+import ReactDOM from "react-dom";
+import * as ReactIs from 'react-is';
+
+const div = document.createElement("div");
+const portal = ReactDOM.createPortal(<div />, div);
+
+ReactIs.isPortal(portal); // true
+ReactIs.typeOf(portal) === ReactIs.Portal; // true
+```
+
+#### StrictMode
+
+```js
+import React from "react";
+import * as ReactIs from 'react-is';
+
+ReactIs.isStrictMode(<React.StrictMode />); // true
+ReactIs.typeOf(<React.StrictMode />) === ReactIs.StrictMode; // true
+```

frontend/node_modules/@jest/core/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,221 @@
+/**
+ * @license React
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+'use strict';
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+var REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+var REACT_MEMO_TYPE = Symbol.for('react.memo');
+var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+
+// -----------------------------------------------------------------------------
+
+var enableScopeAPI = false; // Experimental Create Event Handle API.
+var enableCacheElement = false;
+var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+// stuff. Intended to enable React core members to more easily debug scheduling
+// issues in DEV builds.
+
+var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+var REACT_MODULE_REFERENCE;
+
+{
+  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+}
+
+function isValidElementType(type) {
+  if (typeof type === 'string' || typeof type === 'function') {
+    return true;
+  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+    return true;
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+    // types supported by any Flight configuration anywhere since
+    // we don't know which Flight build this will end up being used
+    // with.
+    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+          case REACT_SUSPENSE_LIST_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_SERVER_CONTEXT_TYPE:
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+}
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false;
+var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isConcurrentMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+      hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+function isSuspenseList(object) {
+  return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+}
+
+exports.ContextConsumer = ContextConsumer;
+exports.ContextProvider = ContextProvider;
+exports.Element = Element;
+exports.ForwardRef = ForwardRef;
+exports.Fragment = Fragment;
+exports.Lazy = Lazy;
+exports.Memo = Memo;
+exports.Portal = Portal;
+exports.Profiler = Profiler;
+exports.StrictMode = StrictMode;
+exports.Suspense = Suspense;
+exports.SuspenseList = SuspenseList;
+exports.isAsyncMode = isAsyncMode;
+exports.isConcurrentMode = isConcurrentMode;
+exports.isContextConsumer = isContextConsumer;
+exports.isContextProvider = isContextProvider;
+exports.isElement = isElement;
+exports.isForwardRef = isForwardRef;
+exports.isFragment = isFragment;
+exports.isLazy = isLazy;
+exports.isMemo = isMemo;
+exports.isPortal = isPortal;
+exports.isProfiler = isProfiler;
+exports.isStrictMode = isStrictMode;
+exports.isSuspense = isSuspense;
+exports.isSuspenseList = isSuspenseList;
+exports.isValidElementType = isValidElementType;
+exports.typeOf = typeOf;
+  })();
+}

frontend/node_modules/@jest/core/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,14 @@
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var b=Symbol.for("react.element"),c=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),e=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.for("react.provider"),h=Symbol.for("react.context"),k=Symbol.for("react.server_context"),l=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),n=Symbol.for("react.suspense_list"),p=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),t=Symbol.for("react.offscreen"),u;u=Symbol.for("react.module.reference");
+function v(a){if("object"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;
+exports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};
+exports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};
+exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||"object"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;

frontend/node_modules/@jest/core/node_modules/react-is/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/react-is.production.min.js');
+} else {
+  module.exports = require('./cjs/react-is.development.js');
+}

frontend/node_modules/@jest/core/node_modules/react-is/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "react-is",
+  "version": "18.3.1",
+  "description": "Brand checking of React Elements.",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/react.git",
+    "directory": "packages/react-is"
+  },
+  "keywords": [
+    "react"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/facebook/react/issues"
+  },
+  "homepage": "https://reactjs.org/",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "index.js",
+    "cjs/",
+    "umd/"
+  ]
+}

frontend/node_modules/@jest/core/node_modules/react-is/umd/react-is.development.js

@@ -0,0 +1,220 @@
+/**
+ * @license React
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.ReactIs = {}));
+}(this, (function (exports) { 'use strict';
+
+  // ATTENTION
+  // When adding new symbols to this file,
+  // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+  // The Symbol used to tag the ReactElement-like types.
+  var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+  var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+  var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+  var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+  var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+  var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+  var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+  var REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+  var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+  var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+  var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+  var REACT_MEMO_TYPE = Symbol.for('react.memo');
+  var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+  var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+
+  // -----------------------------------------------------------------------------
+
+  var enableScopeAPI = false; // Experimental Create Event Handle API.
+  var enableCacheElement = false;
+  var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+  var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+  // stuff. Intended to enable React core members to more easily debug scheduling
+  // issues in DEV builds.
+
+  var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+  var REACT_MODULE_REFERENCE;
+
+  {
+    REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+  }
+
+  function isValidElementType(type) {
+    if (typeof type === 'string' || typeof type === 'function') {
+      return true;
+    } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+    if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+      return true;
+    }
+
+    if (typeof type === 'object' && type !== null) {
+      if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function typeOf(object) {
+    if (typeof object === 'object' && object !== null) {
+      var $$typeof = object.$$typeof;
+
+      switch ($$typeof) {
+        case REACT_ELEMENT_TYPE:
+          var type = object.type;
+
+          switch (type) {
+            case REACT_FRAGMENT_TYPE:
+            case REACT_PROFILER_TYPE:
+            case REACT_STRICT_MODE_TYPE:
+            case REACT_SUSPENSE_TYPE:
+            case REACT_SUSPENSE_LIST_TYPE:
+              return type;
+
+            default:
+              var $$typeofType = type && type.$$typeof;
+
+              switch ($$typeofType) {
+                case REACT_SERVER_CONTEXT_TYPE:
+                case REACT_CONTEXT_TYPE:
+                case REACT_FORWARD_REF_TYPE:
+                case REACT_LAZY_TYPE:
+                case REACT_MEMO_TYPE:
+                case REACT_PROVIDER_TYPE:
+                  return $$typeofType;
+
+                default:
+                  return $$typeof;
+              }
+
+          }
+
+        case REACT_PORTAL_TYPE:
+          return $$typeof;
+      }
+    }
+
+    return undefined;
+  }
+  var ContextConsumer = REACT_CONTEXT_TYPE;
+  var ContextProvider = REACT_PROVIDER_TYPE;
+  var Element = REACT_ELEMENT_TYPE;
+  var ForwardRef = REACT_FORWARD_REF_TYPE;
+  var Fragment = REACT_FRAGMENT_TYPE;
+  var Lazy = REACT_LAZY_TYPE;
+  var Memo = REACT_MEMO_TYPE;
+  var Portal = REACT_PORTAL_TYPE;
+  var Profiler = REACT_PROFILER_TYPE;
+  var StrictMode = REACT_STRICT_MODE_TYPE;
+  var Suspense = REACT_SUSPENSE_TYPE;
+  var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+  var hasWarnedAboutDeprecatedIsAsyncMode = false;
+  var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
+
+  function isAsyncMode(object) {
+    {
+      if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+        hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+        console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+      }
+    }
+
+    return false;
+  }
+  function isConcurrentMode(object) {
+    {
+      if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+        hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
+
+        console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+      }
+    }
+
+    return false;
+  }
+  function isContextConsumer(object) {
+    return typeOf(object) === REACT_CONTEXT_TYPE;
+  }
+  function isContextProvider(object) {
+    return typeOf(object) === REACT_PROVIDER_TYPE;
+  }
+  function isElement(object) {
+    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+  }
+  function isForwardRef(object) {
+    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+  }
+  function isFragment(object) {
+    return typeOf(object) === REACT_FRAGMENT_TYPE;
+  }
+  function isLazy(object) {
+    return typeOf(object) === REACT_LAZY_TYPE;
+  }
+  function isMemo(object) {
+    return typeOf(object) === REACT_MEMO_TYPE;
+  }
+  function isPortal(object) {
+    return typeOf(object) === REACT_PORTAL_TYPE;
+  }
+  function isProfiler(object) {
+    return typeOf(object) === REACT_PROFILER_TYPE;
+  }
+  function isStrictMode(object) {
+    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+  }
+  function isSuspense(object) {
+    return typeOf(object) === REACT_SUSPENSE_TYPE;
+  }
+  function isSuspenseList(object) {
+    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+  }
+
+  exports.ContextConsumer = ContextConsumer;
+  exports.ContextProvider = ContextProvider;
+  exports.Element = Element;
+  exports.ForwardRef = ForwardRef;
+  exports.Fragment = Fragment;
+  exports.Lazy = Lazy;
+  exports.Memo = Memo;
+  exports.Portal = Portal;
+  exports.Profiler = Profiler;
+  exports.StrictMode = StrictMode;
+  exports.Suspense = Suspense;
+  exports.SuspenseList = SuspenseList;
+  exports.isAsyncMode = isAsyncMode;
+  exports.isConcurrentMode = isConcurrentMode;
+  exports.isContextConsumer = isContextConsumer;
+  exports.isContextProvider = isContextProvider;
+  exports.isElement = isElement;
+  exports.isForwardRef = isForwardRef;
+  exports.isFragment = isFragment;
+  exports.isLazy = isLazy;
+  exports.isMemo = isMemo;
+  exports.isPortal = isPortal;
+  exports.isProfiler = isProfiler;
+  exports.isStrictMode = isStrictMode;
+  exports.isSuspense = isSuspense;
+  exports.isSuspenseList = isSuspenseList;
+  exports.isValidElementType = isValidElementType;
+  exports.typeOf = typeOf;
+
+})));

frontend/node_modules/@jest/core/node_modules/react-is/umd/react-is.production.min.js

@@ -0,0 +1,15 @@
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+(function(){'use strict';(function(b,c){"object"===typeof exports&&"undefined"!==typeof module?c(exports):"function"===typeof define&&define.amd?define(["exports"],c):(b=b||self,c(b.ReactIs={}))})(this,function(b){function c(a){if("object"===typeof a&&null!==a){var b=a.$$typeof;switch(b){case q:switch(a=a.type,a){case d:case e:case f:case g:case h:return a;default:switch(a=a&&a.$$typeof,a){case t:case k:case l:case m:case n:case p:return a;default:return b}}case r:return b}}}var q=Symbol.for("react.element"),
+r=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),f=Symbol.for("react.strict_mode"),e=Symbol.for("react.profiler"),p=Symbol.for("react.provider"),k=Symbol.for("react.context"),t=Symbol.for("react.server_context"),l=Symbol.for("react.forward_ref"),g=Symbol.for("react.suspense"),h=Symbol.for("react.suspense_list"),n=Symbol.for("react.memo"),m=Symbol.for("react.lazy"),u=Symbol.for("react.offscreen");var v=Symbol.for("react.module.reference");b.ContextConsumer=k;b.ContextProvider=p;b.Element=
+q;b.ForwardRef=l;b.Fragment=d;b.Lazy=m;b.Memo=n;b.Portal=r;b.Profiler=e;b.StrictMode=f;b.Suspense=g;b.SuspenseList=h;b.isAsyncMode=function(a){return!1};b.isConcurrentMode=function(a){return!1};b.isContextConsumer=function(a){return c(a)===k};b.isContextProvider=function(a){return c(a)===p};b.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===q};b.isForwardRef=function(a){return c(a)===l};b.isFragment=function(a){return c(a)===d};b.isLazy=function(a){return c(a)===m};b.isMemo=
+function(a){return c(a)===n};b.isPortal=function(a){return c(a)===r};b.isProfiler=function(a){return c(a)===e};b.isStrictMode=function(a){return c(a)===f};b.isSuspense=function(a){return c(a)===g};b.isSuspenseList=function(a){return c(a)===h};b.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===d||a===e||a===f||a===g||a===h||a===u||"object"===typeof a&&null!==a&&(a.$$typeof===m||a.$$typeof===n||a.$$typeof===p||a.$$typeof===k||a.$$typeof===l||a.$$typeof===v||void 0!==
+a.getModuleId)?!0:!1};b.typeOf=c});
+})();

frontend/node_modules/@jest/core/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@jest/core",
+  "description": "Delightful JavaScript Testing.",
+  "version": "29.7.0",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@jest/console": "^29.7.0",
+    "@jest/reporters": "^29.7.0",
+    "@jest/test-result": "^29.7.0",
+    "@jest/transform": "^29.7.0",
+    "@jest/types": "^29.6.3",
+    "@types/node": "*",
+    "ansi-escapes": "^4.2.1",
+    "chalk": "^4.0.0",
+    "ci-info": "^3.2.0",
+    "exit": "^0.1.2",
+    "graceful-fs": "^4.2.9",
+    "jest-changed-files": "^29.7.0",
+    "jest-config": "^29.7.0",
+    "jest-haste-map": "^29.7.0",
+    "jest-message-util": "^29.7.0",
+    "jest-regex-util": "^29.6.3",
+    "jest-resolve": "^29.7.0",
+    "jest-resolve-dependencies": "^29.7.0",
+    "jest-runner": "^29.7.0",
+    "jest-runtime": "^29.7.0",
+    "jest-snapshot": "^29.7.0",
+    "jest-util": "^29.7.0",
+    "jest-validate": "^29.7.0",
+    "jest-watcher": "^29.7.0",
+    "micromatch": "^4.0.4",
+    "pretty-format": "^29.7.0",
+    "slash": "^3.0.0",
+    "strip-ansi": "^6.0.0"
+  },
+  "devDependencies": {
+    "@jest/test-sequencer": "^29.7.0",
+    "@jest/test-utils": "^29.7.0",
+    "@types/exit": "^0.1.30",
+    "@types/graceful-fs": "^4.1.3",
+    "@types/micromatch": "^4.0.1"
+  },
+  "peerDependencies": {
+    "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "node-notifier": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest-core"
+  },
+  "bugs": {
+    "url": "https://github.com/jestjs/jest/issues"
+  },
+  "homepage": "https://jestjs.io/",
+  "license": "MIT",
+  "keywords": [
+    "ava",
+    "babel",
+    "coverage",
+    "easy",
+    "expect",
+    "facebook",
+    "immersive",
+    "instant",
+    "jasmine",
+    "jest",
+    "jsdom",
+    "mocha",
+    "mocking",
+    "painless",
+    "qunit",
+    "runner",
+    "sandboxed",
+    "snapshot",
+    "tap",
+    "tape",
+    "test",
+    "testing",
+    "typescript",
+    "watch"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
+}