Add node modules and new code for release (#39)

Co-authored-by: tbarnes94 <tbarnes94@users.noreply.github.com>

node_modules/jest-haste-map/node_modules/@jest/types/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.

node_modules/jest-haste-map/node_modules/@jest/types/build/Circus.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type * as Global from './Global';
+declare type Process = NodeJS.Process;
+export declare type DoneFn = Global.DoneFn;
+export declare type BlockFn = Global.BlockFn;
+export declare type BlockName = Global.BlockName;
+export declare type BlockMode = void | 'skip' | 'only' | 'todo';
+export declare type TestMode = BlockMode;
+export declare type TestName = Global.TestName;
+export declare type TestFn = Global.TestFn;
+export declare type HookFn = Global.HookFn;
+export declare type AsyncFn = TestFn | HookFn;
+export declare type SharedHookType = 'afterAll' | 'beforeAll';
+export declare type HookType = SharedHookType | 'afterEach' | 'beforeEach';
+export declare type TestContext = Record<string, any>;
+export declare type Exception = any;
+export declare type FormattedError = string;
+export declare type Hook = {
+    asyncError: Error;
+    fn: HookFn;
+    type: HookType;
+    parent: DescribeBlock;
+    timeout: number | undefined | null;
+};
+export interface EventHandler {
+    (event: AsyncEvent, state: State): void | Promise<void>;
+    (event: SyncEvent, state: State): void;
+}
+export declare type Event = SyncEvent | AsyncEvent;
+export declare type SyncEvent = {
+    asyncError: Error;
+    mode: BlockMode;
+    name: 'start_describe_definition';
+    blockName: BlockName;
+} | {
+    mode: BlockMode;
+    name: 'finish_describe_definition';
+    blockName: BlockName;
+} | {
+    asyncError: Error;
+    name: 'add_hook';
+    hookType: HookType;
+    fn: HookFn;
+    timeout: number | undefined;
+} | {
+    asyncError: Error;
+    name: 'add_test';
+    testName: TestName;
+    fn?: TestFn;
+    mode?: TestMode;
+    timeout: number | undefined;
+} | {
+    name: 'error';
+    error: Exception;
+};
+export declare type AsyncEvent = {
+    name: 'setup';
+    testNamePattern?: string;
+    parentProcess: Process;
+} | {
+    name: 'include_test_location_in_result';
+} | {
+    name: 'hook_start';
+    hook: Hook;
+} | {
+    name: 'hook_success';
+    describeBlock?: DescribeBlock;
+    test?: TestEntry;
+    hook: Hook;
+} | {
+    name: 'hook_failure';
+    error: string | Exception;
+    describeBlock?: DescribeBlock;
+    test?: TestEntry;
+    hook: Hook;
+} | {
+    name: 'test_fn_start';
+    test: TestEntry;
+} | {
+    name: 'test_fn_success';
+    test: TestEntry;
+} | {
+    name: 'test_fn_failure';
+    error: Exception;
+    test: TestEntry;
+} | {
+    name: 'test_retry';
+    test: TestEntry;
+} | {
+    name: 'test_start';
+    test: TestEntry;
+} | {
+    name: 'test_skip';
+    test: TestEntry;
+} | {
+    name: 'test_todo';
+    test: TestEntry;
+} | {
+    name: 'test_done';
+    test: TestEntry;
+} | {
+    name: 'run_describe_start';
+    describeBlock: DescribeBlock;
+} | {
+    name: 'run_describe_finish';
+    describeBlock: DescribeBlock;
+} | {
+    name: 'run_start';
+} | {
+    name: 'run_finish';
+} | {
+    name: 'teardown';
+};
+export declare type MatcherResults = {
+    actual: unknown;
+    expected: unknown;
+    name: string;
+    pass: boolean;
+};
+export declare type TestStatus = 'skip' | 'done' | 'todo';
+export declare type TestResult = {
+    duration?: number | null;
+    errors: Array<FormattedError>;
+    errorsDetailed: Array<MatcherResults | unknown>;
+    invocations: number;
+    status: TestStatus;
+    location?: {
+        column: number;
+        line: number;
+    } | null;
+    testPath: Array<TestName | BlockName>;
+};
+export declare type RunResult = {
+    unhandledErrors: Array<FormattedError>;
+    testResults: TestResults;
+};
+export declare type TestResults = Array<TestResult>;
+export declare type GlobalErrorHandlers = {
+    uncaughtException: Array<(exception: Exception) => void>;
+    unhandledRejection: Array<(exception: Exception, promise: Promise<any>) => void>;
+};
+export declare type State = {
+    currentDescribeBlock: DescribeBlock;
+    currentlyRunningTest?: TestEntry | null;
+    expand?: boolean;
+    hasFocusedTests: boolean;
+    hasStarted: boolean;
+    originalGlobalErrorHandlers?: GlobalErrorHandlers;
+    parentProcess: Process | null;
+    rootDescribeBlock: DescribeBlock;
+    testNamePattern?: RegExp | null;
+    testTimeout: number;
+    unhandledErrors: Array<Exception>;
+    includeTestLocationInResult: boolean;
+};
+export declare type DescribeBlock = {
+    type: 'describeBlock';
+    children: Array<DescribeBlock | TestEntry>;
+    hooks: Array<Hook>;
+    mode: BlockMode;
+    name: BlockName;
+    parent?: DescribeBlock;
+    /** @deprecated Please get from `children` array instead */
+    tests: Array<TestEntry>;
+};
+export declare type TestError = Exception | [Exception | undefined, Exception];
+export declare type TestEntry = {
+    type: 'test';
+    asyncError: Exception;
+    errors: Array<TestError>;
+    fn?: TestFn;
+    invocations: number;
+    mode: TestMode;
+    name: TestName;
+    parent: DescribeBlock;
+    startedAt?: number | null;
+    duration?: number | null;
+    status?: TestStatus | null;
+    timeout?: number;
+};
+export {};

node_modules/jest-haste-map/node_modules/@jest/types/build/Circus.js

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

node_modules/jest-haste-map/node_modules/@jest/types/build/Config.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { Arguments } from 'yargs';
+import type { ReportOptions } from 'istanbul-reports';
+import type { ForegroundColor } from 'chalk';
+declare type CoverageProvider = 'babel' | 'v8';
+export declare type Path = string;
+export declare type Glob = string;
+export declare type HasteConfig = {
+    computeSha1?: boolean;
+    defaultPlatform?: string | null;
+    hasteImplModulePath?: string;
+    platforms?: Array<string>;
+    throwOnModuleCollision?: boolean;
+};
+export declare type CoverageReporterName = keyof ReportOptions;
+export declare type CoverageReporterWithOptions<K = CoverageReporterName> = K extends CoverageReporterName ? ReportOptions[K] extends never ? never : [K, Partial<ReportOptions[K]>] : never;
+export declare type CoverageReporters = Array<CoverageReporterName | CoverageReporterWithOptions>;
+export declare type ReporterConfig = [string, Record<string, unknown>];
+export declare type TransformerConfig = [string, Record<string, unknown>];
+export interface ConfigGlobals {
+    [K: string]: unknown;
+}
+export declare type DefaultOptions = {
+    automock: boolean;
+    bail: number;
+    cache: boolean;
+    cacheDirectory: Path;
+    changedFilesWithAncestor: boolean;
+    clearMocks: boolean;
+    collectCoverage: boolean;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageReporters: Array<CoverageReporterName>;
+    coverageProvider: CoverageProvider;
+    errorOnDeprecated: boolean;
+    expand: boolean;
+    forceCoverageMatch: Array<Glob>;
+    globals: ConfigGlobals;
+    haste: HasteConfig;
+    maxConcurrency: number;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleNameMapper: Record<string, string | Array<string>>;
+    modulePathIgnorePatterns: Array<string>;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: NotifyMode;
+    prettierPath: string;
+    resetMocks: boolean;
+    resetModules: boolean;
+    restoreMocks: boolean;
+    roots: Array<Path>;
+    runTestsByPath: boolean;
+    runner: 'jest-runner';
+    setupFiles: Array<Path>;
+    setupFilesAfterEnv: Array<Path>;
+    skipFilter: boolean;
+    slowTestThreshold: number;
+    snapshotSerializers: Array<Path>;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, any>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: Array<Glob>;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: Array<string>;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    timers: 'real' | 'fake';
+    transformIgnorePatterns: Array<Glob>;
+    useStderr: boolean;
+    watch: boolean;
+    watchPathIgnorePatterns: Array<string>;
+    watchman: boolean;
+};
+export declare type DisplayName = {
+    name: string;
+    color: typeof ForegroundColor;
+};
+export declare type InitialOptionsWithRootDir = InitialOptions & Required<Pick<InitialOptions, 'rootDir'>>;
+export declare type InitialOptions = Partial<{
+    automock: boolean;
+    bail: boolean | number;
+    cache: boolean;
+    cacheDirectory: Path;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: Array<Glob>;
+    collectCoverageOnlyFrom: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageProvider: CoverageProvider;
+    coverageReporters: CoverageReporters;
+    coverageThreshold: {
+        global: {
+            [key: string]: number;
+        };
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | DisplayName;
+    expand: boolean;
+    extraGlobals: Array<string>;
+    filter: Path;
+    findRelatedTests: boolean;
+    forceCoverageMatch: Array<Glob>;
+    forceExit: boolean;
+    json: boolean;
+    globals: ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: HasteConfig;
+    reporters: Array<string | ReporterConfig>;
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    mapCoverage: boolean;
+    maxConcurrency: number;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleLoader: Path;
+    moduleNameMapper: {
+        [key: string]: string | Array<string>;
+    };
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths: Array<string>;
+    name: string;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    outputFile: Path;
+    passWithNoTests: boolean;
+    preprocessorIgnorePatterns: Array<Glob>;
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: Array<Glob>;
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: Path | null | undefined;
+    restoreMocks: boolean;
+    rootDir: Path;
+    roots: Array<Path>;
+    runner: string;
+    runTestsByPath: boolean;
+    scriptPreprocessor: string;
+    setupFiles: Array<Path>;
+    setupTestFrameworkScriptFile: Path;
+    setupFilesAfterEnv: Array<Path>;
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: Path;
+    snapshotSerializers: Array<Path>;
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, any>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: Array<Glob>;
+    testNamePattern: string;
+    testPathDirs: Array<Path>;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: string | Array<string>;
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number;
+    timers: 'real' | 'fake';
+    transform: {
+        [regex: string]: Path | TransformerConfig;
+    };
+    transformIgnorePatterns: Array<Glob>;
+    watchPathIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns: Array<string>;
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: Array<string | [string, Record<string, any>]>;
+}>;
+export declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type NotifyMode = 'always' | 'failure' | 'success' | 'change' | 'success-change' | 'failure-change';
+export declare type CoverageThresholdValue = {
+    branches?: number;
+    functions?: number;
+    lines?: number;
+    statements?: number;
+};
+declare type CoverageThreshold = {
+    [path: string]: CoverageThresholdValue;
+    global: CoverageThresholdValue;
+};
+export declare type GlobalConfig = {
+    bail: number;
+    changedSince?: string;
+    changedFilesWithAncestor: boolean;
+    collectCoverage: boolean;
+    collectCoverageFrom: Array<Glob>;
+    collectCoverageOnlyFrom?: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns?: Array<string>;
+    coverageProvider: CoverageProvider;
+    coverageReporters: CoverageReporters;
+    coverageThreshold?: CoverageThreshold;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    enabledTestsMap?: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    expand: boolean;
+    filter?: Path;
+    findRelatedTests: boolean;
+    forceExit: boolean;
+    json: boolean;
+    globalSetup?: string;
+    globalTeardown?: string;
+    lastCommit: boolean;
+    logHeapUsage: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: number;
+    noStackTrace: boolean;
+    nonFlagArgs: Array<string>;
+    noSCM?: boolean;
+    notify: boolean;
+    notifyMode: NotifyMode;
+    outputFile?: Path;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    passWithNoTests: boolean;
+    projects: Array<Glob>;
+    replname?: string;
+    reporters?: Array<string | ReporterConfig>;
+    runTestsByPath: boolean;
+    rootDir: Path;
+    silent?: boolean;
+    skipFilter: boolean;
+    errorOnDeprecated: boolean;
+    testFailureExitCode: number;
+    testNamePattern?: string;
+    testPathPattern: string;
+    testResultsProcessor?: string;
+    testSequencer: string;
+    testTimeout?: number;
+    updateSnapshot: SnapshotUpdateState;
+    useStderr: boolean;
+    verbose?: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins?: Array<{
+        path: string;
+        config: Record<string, any>;
+    }> | null;
+};
+export declare type ProjectConfig = {
+    automock: boolean;
+    cache: boolean;
+    cacheDirectory: Path;
+    clearMocks: boolean;
+    coveragePathIgnorePatterns: Array<string>;
+    cwd: Path;
+    dependencyExtractor?: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName?: DisplayName;
+    errorOnDeprecated: boolean;
+    extraGlobals: Array<keyof NodeJS.Global>;
+    filter?: Path;
+    forceCoverageMatch: Array<Glob>;
+    globalSetup?: string;
+    globalTeardown?: string;
+    globals: ConfigGlobals;
+    haste: HasteConfig;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleLoader?: Path;
+    moduleNameMapper: Array<[string, string]>;
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths?: Array<string>;
+    name: string;
+    prettierPath: string;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver?: Path;
+    restoreMocks: boolean;
+    rootDir: Path;
+    roots: Array<Path>;
+    runner: string;
+    setupFiles: Array<Path>;
+    setupFilesAfterEnv: Array<Path>;
+    skipFilter: boolean;
+    skipNodeResolution?: boolean;
+    slowTestThreshold: number;
+    snapshotResolver?: Path;
+    snapshotSerializers: Array<Path>;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, any>;
+    testMatch: Array<Glob>;
+    testLocationInResults: boolean;
+    testPathIgnorePatterns: Array<string>;
+    testRegex: Array<string | RegExp>;
+    testRunner: string;
+    testURL: string;
+    timers: 'real' | 'fake' | 'modern' | 'legacy';
+    transform: Array<[string, Path, Record<string, unknown>]>;
+    transformIgnorePatterns: Array<Glob>;
+    watchPathIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns?: Array<string>;
+};
+export declare type Argv = Arguments<Partial<{
+    all: boolean;
+    automock: boolean;
+    bail: boolean | number;
+    cache: boolean;
+    cacheDirectory: string;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    ci: boolean;
+    clearCache: boolean;
+    clearMocks: boolean;
+    collectCoverage: boolean;
+    collectCoverageFrom: string;
+    collectCoverageOnlyFrom: Array<string>;
+    color: boolean;
+    colors: boolean;
+    config: string;
+    coverage: boolean;
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: Array<string>;
+    coverageReporters: Array<string>;
+    coverageThreshold: string;
+    debug: boolean;
+    env: string;
+    expand: boolean;
+    findRelatedTests: boolean;
+    forceExit: boolean;
+    globals: string;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: string;
+    init: boolean;
+    json: boolean;
+    lastCommit: boolean;
+    logHeapUsage: boolean;
+    maxWorkers: number | string;
+    moduleDirectories: Array<string>;
+    moduleFileExtensions: Array<string>;
+    moduleNameMapper: string;
+    modulePathIgnorePatterns: Array<string>;
+    modulePaths: Array<string>;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    outputFile: string;
+    preset: string | null | undefined;
+    projects: Array<string>;
+    prettierPath: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: Array<string>;
+    runInBand: boolean;
+    selectProjects: Array<string>;
+    setupFiles: Array<string>;
+    setupFilesAfterEnv: Array<string>;
+    showConfig: boolean;
+    silent: boolean;
+    snapshotSerializers: Array<string>;
+    testEnvironment: string;
+    testFailureExitCode: string | null | undefined;
+    testMatch: Array<string>;
+    testNamePattern: string;
+    testPathIgnorePatterns: Array<string>;
+    testPathPattern: Array<string>;
+    testRegex: string | Array<string>;
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number | null | undefined;
+    timers: string;
+    transform: string;
+    transformIgnorePatterns: Array<string>;
+    unmockedModulePathPatterns: Array<string> | null | undefined;
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose: boolean;
+    version: boolean;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPathIgnorePatterns: Array<string>;
+}>>;
+export {};

node_modules/jest-haste-map/node_modules/@jest/types/build/Config.js

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

node_modules/jest-haste-map/node_modules/@jest/types/build/Global.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { CoverageMapData } from 'istanbul-lib-coverage';
+export declare type DoneFn = (reason?: string | Error) => void;
+export declare type TestName = string;
+export declare type TestFn = (done?: DoneFn) => Promise<void | undefined | unknown> | void | undefined;
+export declare type ConcurrentTestFn = (done?: DoneFn) => Promise<void | undefined | unknown>;
+export declare type BlockFn = () => void;
+export declare type BlockName = string;
+export declare type HookFn = TestFn;
+export declare type Col = unknown;
+export declare type Row = Array<Col>;
+export declare type Table = Array<Row>;
+export declare type ArrayTable = Table | Row;
+export declare type TemplateTable = TemplateStringsArray;
+export declare type TemplateData = Array<unknown>;
+export declare type EachTable = ArrayTable | TemplateTable;
+export declare type TestCallback = BlockFn | TestFn | ConcurrentTestFn;
+export declare type EachTestFn<EachCallback extends TestCallback> = (...args: Array<any>) => ReturnType<EachCallback>;
+declare type Jasmine = {
+    _DEFAULT_TIMEOUT_INTERVAL?: number;
+    addMatchers: Function;
+};
+declare type Each<EachCallback extends TestCallback> = ((table: EachTable, ...taggedTemplateData: Array<unknown>) => (title: string, test: EachTestFn<EachCallback>, timeout?: number) => void) | (() => void);
+export interface ItBase {
+    (testName: TestName, fn: TestFn, timeout?: number): void;
+    each: Each<TestFn>;
+}
+export interface It extends ItBase {
+    only: ItBase;
+    skip: ItBase;
+    todo: (testName: TestName, ...rest: Array<any>) => void;
+}
+export interface ItConcurrentBase {
+    (testName: string, testFn: ConcurrentTestFn, timeout?: number): void;
+    each: Each<ConcurrentTestFn>;
+}
+export interface ItConcurrentExtended extends ItConcurrentBase {
+    only: ItConcurrentBase;
+    skip: ItConcurrentBase;
+}
+export interface ItConcurrent extends It {
+    concurrent: ItConcurrentExtended;
+}
+export interface DescribeBase {
+    (blockName: BlockName, blockFn: BlockFn): void;
+    each: Each<BlockFn>;
+}
+export interface Describe extends DescribeBase {
+    only: DescribeBase;
+    skip: DescribeBase;
+}
+export interface TestFrameworkGlobals {
+    it: ItConcurrent;
+    test: ItConcurrent;
+    fit: ItBase & {
+        concurrent?: ItConcurrentBase;
+    };
+    xit: ItBase;
+    xtest: ItBase;
+    describe: Describe;
+    xdescribe: DescribeBase;
+    fdescribe: DescribeBase;
+    beforeAll: HookFn;
+    beforeEach: HookFn;
+    afterEach: HookFn;
+    afterAll: HookFn;
+}
+export interface GlobalAdditions extends TestFrameworkGlobals {
+    __coverage__: CoverageMapData;
+    jasmine: Jasmine;
+    fail: () => void;
+    pending: () => void;
+    spyOn: () => void;
+    spyOnProperty: () => void;
+}
+export interface Global extends GlobalAdditions, Omit<NodeJS.Global, keyof GlobalAdditions> {
+    [extras: string]: any;
+}
+export {};

node_modules/jest-haste-map/node_modules/@jest/types/build/Global.js

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

node_modules/jest-haste-map/node_modules/@jest/types/build/TestResult.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+export declare type Milliseconds = number;
+declare type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
+declare type Callsite = {
+    column: number;
+    line: number;
+};
+export declare type AssertionResult = {
+    ancestorTitles: Array<string>;
+    duration?: Milliseconds | null;
+    failureDetails: Array<unknown>;
+    failureMessages: Array<string>;
+    fullName: string;
+    invocations?: number;
+    location?: Callsite | null;
+    numPassingAsserts: number;
+    status: Status;
+    title: string;
+};
+export declare type SerializableError = {
+    code?: unknown;
+    message: string;
+    stack: string | null | undefined;
+    type?: string;
+};
+export {};

node_modules/jest-haste-map/node_modules/@jest/types/build/TestResult.js

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

node_modules/jest-haste-map/node_modules/@jest/types/build/Transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type TransformResult = {
+    code: string;
+    originalCode: string;
+    mapCoverage?: boolean;
+    sourceMapPath: string | null;
+};

node_modules/jest-haste-map/node_modules/@jest/types/build/Transform.js

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

node_modules/jest-haste-map/node_modules/@jest/types/build/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type * as Circus from './Circus';
+import type * as Config from './Config';
+import type * as Global from './Global';
+import type * as TestResult from './TestResult';
+import type * as TransformTypes from './Transform';
+export type { Circus, Config, Global, TestResult, TransformTypes };

node_modules/jest-haste-map/node_modules/@jest/types/build/index.js

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

node_modules/jest-haste-map/node_modules/@jest/types/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@jest/types",
+  "version": "26.3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-types"
+  },
+  "engines": {
+    "node": ">= 10.14.2"
+  },
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "dependencies": {
+    "@types/istanbul-lib-coverage": "^2.0.0",
+    "@types/istanbul-reports": "^3.0.0",
+    "@types/node": "*",
+    "@types/yargs": "^15.0.0",
+    "chalk": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "3a7e06fe855515a848241bb06a6f6e117847443d"
+}