Add node modules and compiled JavaScript from main (#54)

Co-authored-by: Oliver King <oking3@uncc.edu>

node_modules/@jest/transform/build/enhanceUnexpectedTokenMessage.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = handlePotentialSyntaxError;
+exports.enhanceUnexpectedTokenMessage = enhanceUnexpectedTokenMessage;
+
+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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const DOT = ' \u2022 ';
+
+function handlePotentialSyntaxError(e) {
+  if (e.codeFrame) {
+    e.stack = `${e.message}\n${e.codeFrame}`;
+  }
+
+  if (
+    // `instanceof` might come from the wrong context
+    e.name === 'SyntaxError' &&
+    !e.message.includes(' expected')
+  ) {
+    throw enhanceUnexpectedTokenMessage(e);
+  }
+
+  return e;
+}
+
+function enhanceUnexpectedTokenMessage(e) {
+  e.stack = `${_chalk().default.bold.red(
+    'Jest encountered an unexpected token'
+  )}
+
+Jest failed to parse a file. This happens e.g. when your code or its dependencies use non-standard JavaScript syntax, or when Jest is not configured to support such syntax.
+
+Out of the box Jest supports Babel, which will be used to transform your files into valid JS based on your Babel configuration.
+
+By default "node_modules" folder is ignored by transformers.
+
+Here's what you can do:
+${DOT}If you are trying to use ECMAScript Modules, see ${_chalk().default.underline(
+    'https://jestjs.io/docs/ecmascript-modules'
+  )} for how to enable it.
+${DOT}If you are trying to use TypeScript, see ${_chalk().default.underline(
+    'https://jestjs.io/docs/getting-started#using-typescript'
+  )}
+${DOT}To have some of your "node_modules" files transformed, you can specify a custom ${_chalk().default.bold(
+    '"transformIgnorePatterns"'
+  )} in your config.
+${DOT}If you need a custom transformation specify a ${_chalk().default.bold(
+    '"transform"'
+  )} option in your config.
+${DOT}If you simply want to mock your non-JS modules (e.g. binary assets) you can stub them out with the ${_chalk().default.bold(
+    '"moduleNameMapper"'
+  )} config option.
+
+You'll find more details and examples of these config options in the docs:
+${_chalk().default.cyan('https://jestjs.io/docs/configuration')}
+For information about custom transformations, see:
+${_chalk().default.cyan('https://jestjs.io/docs/code-transformation')}
+
+${_chalk().default.bold.red('Details:')}
+
+${e.stack}`;
+  return e;
+}

node_modules/@jest/transform/build/index.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type {Config} from '@jest/types';
+import type {EncodedSourceMap} from '@jridgewell/trace-mapping';
+import type {TransformTypes} from '@jest/types';
+
+export declare interface AsyncTransformer<TransformerConfig = unknown> {
+  /**
+   * Indicates if the transformer is capable of instrumenting the code for code coverage.
+   *
+   * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
+   * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
+   */
+  canInstrument?: boolean;
+  getCacheKey?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => string;
+  getCacheKeyAsync?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => Promise<string>;
+  process?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => TransformedSource;
+  processAsync: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => Promise<TransformedSource>;
+}
+
+export declare interface CallerTransformOptions {
+  supportsDynamicImport: boolean;
+  supportsExportNamespaceFrom: boolean;
+  supportsStaticESM: boolean;
+  supportsTopLevelAwait: boolean;
+}
+
+export declare function createScriptTransformer(
+  config: Config.ProjectConfig,
+  cacheFS?: StringMap,
+): Promise<ScriptTransformer>;
+
+export declare function createTranspilingRequire(
+  config: Config.ProjectConfig,
+): Promise<
+  <TModuleType = unknown>(
+    resolverPath: string,
+    applyInteropRequireDefault?: boolean,
+  ) => Promise<TModuleType>
+>;
+
+declare interface ErrorWithCodeFrame extends Error {
+  codeFrame?: string;
+}
+
+declare interface FixedRawSourceMap extends Omit<EncodedSourceMap, 'version'> {
+  version: number;
+}
+
+export declare function handlePotentialSyntaxError(
+  e: ErrorWithCodeFrame,
+): ErrorWithCodeFrame;
+
+declare interface ReducedTransformOptions extends CallerTransformOptions {
+  instrument: boolean;
+}
+
+declare interface RequireAndTranspileModuleOptions
+  extends ReducedTransformOptions {
+  applyInteropRequireDefault: boolean;
+}
+
+export declare type ScriptTransformer = ScriptTransformer_2;
+
+declare class ScriptTransformer_2 {
+  private readonly _config;
+  private readonly _cacheFS;
+  private readonly _cache;
+  private readonly _transformCache;
+  private _transformsAreLoaded;
+  constructor(_config: Config.ProjectConfig, _cacheFS: StringMap);
+  private _buildCacheKeyFromFileInfo;
+  private _getCacheKey;
+  private _getCacheKeyAsync;
+  private _createFolderFromCacheKey;
+  private _getFileCachePath;
+  private _getFileCachePathAsync;
+  private _getTransformPath;
+  loadTransformers(): Promise<void>;
+  private _getTransformer;
+  private _instrumentFile;
+  private _buildTransformResult;
+  transformSource(
+    filepath: string,
+    content: string,
+    options: ReducedTransformOptions,
+  ): TransformResult;
+  transformSourceAsync(
+    filepath: string,
+    content: string,
+    options: ReducedTransformOptions,
+  ): Promise<TransformResult>;
+  private _transformAndBuildScriptAsync;
+  private _transformAndBuildScript;
+  transformAsync(
+    filename: string,
+    options: TransformationOptions,
+    fileSource?: string,
+  ): Promise<TransformResult>;
+  transform(
+    filename: string,
+    options: TransformationOptions,
+    fileSource?: string,
+  ): TransformResult;
+  transformJson(
+    filename: string,
+    options: TransformationOptions,
+    fileSource: string,
+  ): string;
+  requireAndTranspileModule<ModuleType = unknown>(
+    moduleName: string,
+    callback?: (module: ModuleType) => void | Promise<void>,
+    options?: RequireAndTranspileModuleOptions,
+  ): Promise<ModuleType>;
+  shouldTransform(filename: string): boolean;
+}
+
+export declare function shouldInstrument(
+  filename: string,
+  options: ShouldInstrumentOptions,
+  config: Config.ProjectConfig,
+): boolean;
+
+export declare interface ShouldInstrumentOptions
+  extends Pick<
+    Config.GlobalConfig,
+    | 'collectCoverage'
+    | 'collectCoverageFrom'
+    | 'collectCoverageOnlyFrom'
+    | 'coverageProvider'
+  > {
+  changedFiles?: Set<string>;
+  sourcesRelatedToTestsInChangedFiles?: Set<string>;
+}
+
+declare type StringMap = Map<string, string>;
+
+export declare interface SyncTransformer<TransformerConfig = unknown> {
+  /**
+   * Indicates if the transformer is capable of instrumenting the code for code coverage.
+   *
+   * If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
+   * If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
+   */
+  canInstrument?: boolean;
+  getCacheKey?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => string;
+  getCacheKeyAsync?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => Promise<string>;
+  process: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => TransformedSource;
+  processAsync?: (
+    sourceText: string,
+    sourcePath: string,
+    options: TransformOptions<TransformerConfig>,
+  ) => Promise<TransformedSource>;
+}
+
+export declare interface TransformationOptions
+  extends ShouldInstrumentOptions,
+    CallerTransformOptions {
+  isInternalModule?: boolean;
+}
+
+export declare type TransformedSource = {
+  code: string;
+  map?: FixedRawSourceMap | string | null;
+};
+
+/**
+ * We have both sync (`process`) and async (`processAsync`) code transformation, which both can be provided.
+ * `require` will always use `process`, and `import` will use `processAsync` if it exists, otherwise fall back to `process`.
+ * Meaning, if you use `import` exclusively you do not need `process`, but in most cases supplying both makes sense:
+ * Jest transpiles on demand rather than ahead of time, so the sync one needs to exist.
+ *
+ * For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers
+ */
+declare type Transformer_2<TransformerConfig = unknown> =
+  | SyncTransformer<TransformerConfig>
+  | AsyncTransformer<TransformerConfig>;
+export {Transformer_2 as Transformer};
+
+export declare type TransformerCreator<
+  X extends Transformer_2<TransformerConfig>,
+  TransformerConfig = unknown,
+> = (transformerConfig?: TransformerConfig) => X;
+
+export declare interface TransformOptions<TransformerConfig = unknown>
+  extends ReducedTransformOptions {
+  /** Cached file system which is used by `jest-runtime` to improve performance. */
+  cacheFS: StringMap;
+  /** Jest configuration of currently running project. */
+  config: Config.ProjectConfig;
+  /** Stringified version of the `config` - useful in cache busting. */
+  configString: string;
+  /** Transformer configuration passed through `transform` option by the user. */
+  transformerConfig: TransformerConfig;
+}
+
+export declare type TransformResult = TransformTypes.TransformResult;
+
+export {};

node_modules/@jest/transform/build/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'createScriptTransformer', {
+  enumerable: true,
+  get: function () {
+    return _ScriptTransformer.createScriptTransformer;
+  }
+});
+Object.defineProperty(exports, 'createTranspilingRequire', {
+  enumerable: true,
+  get: function () {
+    return _ScriptTransformer.createTranspilingRequire;
+  }
+});
+Object.defineProperty(exports, 'handlePotentialSyntaxError', {
+  enumerable: true,
+  get: function () {
+    return _enhanceUnexpectedTokenMessage.default;
+  }
+});
+Object.defineProperty(exports, 'shouldInstrument', {
+  enumerable: true,
+  get: function () {
+    return _shouldInstrument.default;
+  }
+});
+
+var _ScriptTransformer = require('./ScriptTransformer');
+
+var _shouldInstrument = _interopRequireDefault(require('./shouldInstrument'));
+
+var _enhanceUnexpectedTokenMessage = _interopRequireDefault(
+  require('./enhanceUnexpectedTokenMessage')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}

node_modules/@jest/transform/build/runtimeErrorsAndWarnings.js

@@ -0,0 +1,109 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.makeInvalidTransformerError =
+  exports.makeInvalidSyncTransformerError =
+  exports.makeInvalidSourceMapWarning =
+  exports.makeInvalidReturnValueError =
+    void 0;
+
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const BULLET = '\u25cf ';
+const DOCUMENTATION_NOTE = `  ${_chalk().default.bold(
+  'Code Transformation Documentation:'
+)}
+  https://jestjs.io/docs/code-transformation
+`;
+const UPGRADE_NOTE = `  ${_chalk().default.bold(
+  'This error may be caused by a breaking change in Jest 28:'
+)}
+  https://jestjs.io/docs/upgrading-to-jest28#transformer
+`;
+
+const makeInvalidReturnValueError = transformPath =>
+  _chalk().default.red(
+    [
+      _chalk().default.bold(`${BULLET}Invalid return value:`),
+      '  `process()` or/and `processAsync()` method of code transformer found at ',
+      `  "${(0, _slash().default)(transformPath)}" `,
+      '  should return an object or a Promise resolving to an object. The object ',
+      '  must have `code` property with a string of processed code.',
+      ''
+    ].join('\n') +
+      UPGRADE_NOTE +
+      DOCUMENTATION_NOTE
+  );
+
+exports.makeInvalidReturnValueError = makeInvalidReturnValueError;
+
+const makeInvalidSourceMapWarning = (filename, transformPath) =>
+  _chalk().default.yellow(
+    [
+      _chalk().default.bold(`${BULLET}Invalid source map:`),
+      `  The source map for "${(0, _slash().default)(
+        filename
+      )}" returned by "${(0, _slash().default)(transformPath)}" is invalid.`,
+      '  Proceeding without source mapping for that file.'
+    ].join('\n')
+  );
+
+exports.makeInvalidSourceMapWarning = makeInvalidSourceMapWarning;
+
+const makeInvalidSyncTransformerError = transformPath =>
+  _chalk().default.red(
+    [
+      _chalk().default.bold(`${BULLET}Invalid synchronous transformer module:`),
+      `  "${(0, _slash().default)(
+        transformPath
+      )}" specified in the "transform" object of Jest configuration`,
+      '  must export a `process` function.',
+      ''
+    ].join('\n') + DOCUMENTATION_NOTE
+  );
+
+exports.makeInvalidSyncTransformerError = makeInvalidSyncTransformerError;
+
+const makeInvalidTransformerError = transformPath =>
+  _chalk().default.red(
+    [
+      _chalk().default.bold(`${BULLET}Invalid transformer module:`),
+      `  "${(0, _slash().default)(
+        transformPath
+      )}" specified in the "transform" object of Jest configuration`,
+      '  must export a `process` or `processAsync` or `createTransformer` function.',
+      ''
+    ].join('\n') + DOCUMENTATION_NOTE
+  );
+
+exports.makeInvalidTransformerError = makeInvalidTransformerError;

node_modules/@jest/transform/build/shouldInstrument.js

@@ -0,0 +1,207 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = shouldInstrument;
+
+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 _jestRegexUtil() {
+  const data = require('jest-regex-util');
+
+  _jestRegexUtil = 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) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const MOCKS_PATTERN = new RegExp(
+  (0, _jestRegexUtil().escapePathForRegex)(
+    `${path().sep}__mocks__${path().sep}`
+  )
+);
+const cachedRegexes = new Map();
+
+const getRegex = regexStr => {
+  if (!cachedRegexes.has(regexStr)) {
+    cachedRegexes.set(regexStr, new RegExp(regexStr));
+  }
+
+  const regex = cachedRegexes.get(regexStr); // prevent stateful regexes from breaking, just in case
+
+  regex.lastIndex = 0;
+  return regex;
+};
+
+function shouldInstrument(filename, options, config) {
+  if (!options.collectCoverage) {
+    return false;
+  }
+
+  if (
+    config.forceCoverageMatch.length &&
+    _micromatch().default.any(filename, config.forceCoverageMatch)
+  ) {
+    return true;
+  }
+
+  if (
+    !config.testPathIgnorePatterns.some(pattern =>
+      getRegex(pattern).test(filename)
+    )
+  ) {
+    if (config.testRegex.some(regex => new RegExp(regex).test(filename))) {
+      return false;
+    }
+
+    if (
+      (0, _jestUtil().globsToMatcher)(config.testMatch)(
+        (0, _jestUtil().replacePathSepForGlob)(filename)
+      )
+    ) {
+      return false;
+    }
+  }
+
+  if (
+    // This configuration field contains an object in the form of:
+    // {'path/to/file.js': true}
+    options.collectCoverageOnlyFrom &&
+    !options.collectCoverageOnlyFrom[filename]
+  ) {
+    return false;
+  }
+
+  if (
+    // still cover if `only` is specified
+    !options.collectCoverageOnlyFrom &&
+    options.collectCoverageFrom.length &&
+    !(0, _jestUtil().globsToMatcher)(options.collectCoverageFrom)(
+      (0, _jestUtil().replacePathSepForGlob)(
+        path().relative(config.rootDir, filename)
+      )
+    )
+  ) {
+    return false;
+  }
+
+  if (
+    config.coveragePathIgnorePatterns.some(pattern => !!filename.match(pattern))
+  ) {
+    return false;
+  }
+
+  if (config.globalSetup === filename) {
+    return false;
+  }
+
+  if (config.globalTeardown === filename) {
+    return false;
+  }
+
+  if (config.setupFiles.includes(filename)) {
+    return false;
+  }
+
+  if (config.setupFilesAfterEnv.includes(filename)) {
+    return false;
+  }
+
+  if (MOCKS_PATTERN.test(filename)) {
+    return false;
+  }
+
+  if (options.changedFiles && !options.changedFiles.has(filename)) {
+    if (!options.sourcesRelatedToTestsInChangedFiles) {
+      return false;
+    }
+
+    if (!options.sourcesRelatedToTestsInChangedFiles.has(filename)) {
+      return false;
+    }
+  }
+
+  return true;
+}

node_modules/@jest/transform/build/types.js

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