first commit

node_modules/expect/build/ts3.4/asymmetricMatchers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 class AsymmetricMatcher<T> {
+    protected sample: T;
+    $$typeof: symbol;
+    inverse?: boolean;
+    constructor(sample: T);
+}
+declare class Any extends AsymmetricMatcher<any> {
+    constructor(sample: unknown);
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    getExpectedType(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class Anything extends AsymmetricMatcher<void> {
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    toAsymmetricMatcher(): string;
+}
+declare class ArrayContaining extends AsymmetricMatcher<Array<unknown>> {
+    constructor(sample: Array<unknown>, inverse?: boolean);
+    asymmetricMatch(other: Array<unknown>): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class ObjectContaining extends AsymmetricMatcher<Record<string, any>> {
+    constructor(sample: Record<string, any>, inverse?: boolean);
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringContaining extends AsymmetricMatcher<string> {
+    constructor(sample: string, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(sample: string | RegExp, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
+export declare const any: (expectedObject: unknown) => Any;
+export declare const anything: () => Anything;
+export declare const arrayContaining: (sample: unknown[]) => ArrayContaining;
+export declare const arrayNotContaining: (sample: unknown[]) => ArrayContaining;
+export declare const objectContaining: (sample: Record<string, any>) => ObjectContaining;
+export declare const objectNotContaining: (sample: Record<string, any>) => ObjectContaining;
+export declare const stringContaining: (expected: string) => StringContaining;
+export declare const stringNotContaining: (expected: string) => StringContaining;
+export declare const stringMatching: (expected: string | RegExp) => StringMatching;
+export declare const stringNotMatching: (expected: string | RegExp) => StringMatching;
+export {};

node_modules/expect/build/ts3.4/extractExpectedAssertionsErrors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ */
+declare const extractExpectedAssertionsErrors: () => ({
+    actual: any;
+    error: any;
+    expected: number;
+} | {
+    actual: string;
+    error: any;
+    expected: string;
+})[];
+export default extractExpectedAssertionsErrors;

node_modules/expect/build/ts3.4/fakeChalk.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare const allColorsAsFunc: {
+    [x: string]: (str: string) => string;
+};
+export = allColorsAsFunc;

node_modules/expect/build/ts3.4/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { Expect, MatcherState as JestMatcherState, Matchers as MatcherInterface } from './types';
+declare const expectExport: Expect;
+declare namespace expectExport {
+    type MatcherState = JestMatcherState;
+    interface Matchers<R> extends MatcherInterface<R> {
+    }
+}
+export = expectExport;

node_modules/expect/build/ts3.4/jasmineUtils.d.ts

@@ -0,0 +1,8 @@
+import { Tester } from './types';
+export declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
+export declare function isA(typeName: string, value: unknown): boolean;
+export declare function fnNameFor(func: Function): string;
+export declare function isUndefined(obj: any): boolean;
+export declare function hasProperty(obj: object | null, property: string): boolean;
+export declare function isImmutableUnorderedKeyed(maybeKeyed: any): boolean;
+export declare function isImmutableUnorderedSet(maybeSet: any): boolean;

node_modules/expect/build/ts3.4/jestMatchersObject.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { Expect, MatchersObject } from './types';
+export declare const INTERNAL_MATCHER_FLAG: unique symbol;
+export declare const getState: () => any;
+export declare const setState: (state: object) => void;
+export declare const getMatchers: () => MatchersObject;
+export declare const setMatchers: (matchers: MatchersObject, isInternal: boolean, expect: Expect) => void;

node_modules/expect/build/ts3.4/matchers.d.ts

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

node_modules/expect/build/ts3.4/print.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 const printReceivedStringContainExpectedSubstring: (received: string, start: number, length: number) => string;
+export declare const printReceivedStringContainExpectedResult: (received: string, result: RegExpExecArray | null) => string;
+export declare const printReceivedArrayContainExpectedItem: (received: unknown[], index: number) => string;
+export declare const printCloseTo: (receivedDiff: number, expectedDiff: number, precision: number, isNot: boolean) => string;
+export declare const printExpectedConstructorName: (label: string, expected: Function) => string;
+export declare const printExpectedConstructorNameNot: (label: string, expected: Function) => string;
+export declare const printReceivedConstructorName: (label: string, received: Function) => string;
+export declare const printReceivedConstructorNameNot: (label: string, received: Function, expected: Function) => string;

node_modules/expect/build/ts3.4/spyMatchers.d.ts

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

node_modules/expect/build/ts3.4/toThrowMatchers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 { MatchersObject, RawMatcherFn } from './types';
+export declare const createMatcher: (matcherName: string, fromPromise?: boolean | undefined) => RawMatcherFn;
+declare const matchers: MatchersObject;
+export default matchers;

node_modules/expect/build/ts3.4/types.d.ts

@@ -0,0 +1,325 @@
+/**
+ * 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 { Config } from '@jest/types';
+import * as jestMatcherUtils from 'jest-matcher-utils';
+import { INTERNAL_MATCHER_FLAG } from './jestMatchersObject';
+export declare type SyncExpectationResult = {
+    pass: boolean;
+    message: () => string;
+};
+export declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+export declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+export declare type RawMatcherFn = {
+    (received: any, expected: any, options?: any): ExpectationResult;
+    [INTERNAL_MATCHER_FLAG]?: boolean;
+};
+export declare type ThrowingMatcherFn = (actual: any) => void;
+export declare type PromiseMatcherFn = (actual: any) => Promise<void>;
+export declare type Tester = (a: any, b: any) => boolean | undefined;
+export declare type MatcherState = {
+    assertionCalls: number;
+    currentTestName?: string;
+    dontThrow?: () => void;
+    error?: Error;
+    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+    expand?: boolean;
+    expectedAssertionsNumber?: number;
+    isExpectingAssertions?: boolean;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: Config.Path;
+    utils: typeof jestMatcherUtils & {
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+};
+export declare type AsymmetricMatcher = Record<string, any>;
+export declare type MatchersObject = {
+    [id: string]: RawMatcherFn;
+};
+export declare type Expect = {
+    <T = unknown>(actual: T): Matchers<T>;
+    addSnapshotSerializer(arg0: any): void;
+    assertions(arg0: number): void;
+    extend(arg0: any): void;
+    extractExpectedAssertionsErrors: () => Array<{
+        actual: string | number;
+        error: Error;
+        expected: string;
+    }>;
+    getState(): MatcherState;
+    hasAssertions(): void;
+    setState(arg0: any): void;
+    any(expectedObject: any): AsymmetricMatcher;
+    anything(): AsymmetricMatcher;
+    arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+    objectContaining(sample: Record<string, unknown>): AsymmetricMatcher;
+    stringContaining(expected: string): AsymmetricMatcher;
+    stringMatching(expected: string | RegExp): AsymmetricMatcher;
+    [id: string]: AsymmetricMatcher;
+    not: {
+        [id: string]: AsymmetricMatcher;
+    };
+};
+interface Constructable {
+    new (...args: Array<unknown>): unknown;
+}
+export interface Matchers<R> {
+    /**
+     * Ensures the last call to a mock function was provided specific args.
+     */
+    lastCalledWith(...args: Array<unknown>): R;
+    /**
+     * Ensure that the last call to a mock function has returned a specified value.
+     */
+    lastReturnedWith(value: unknown): R;
+    /**
+     * If you know how to test something, `.not` lets you test its opposite.
+     */
+    not: Matchers<R>;
+    /**
+     * Ensure that a mock function is called with specific arguments on an Nth call.
+     */
+    nthCalledWith(nthCall: number, ...args: Array<unknown>): R;
+    /**
+     * Ensure that the nth call to a mock function has returned a specified value.
+     */
+    nthReturnedWith(n: number, value: unknown): R;
+    /**
+     * Use resolves to unwrap the value of a fulfilled promise so any other
+     * matcher can be chained. If the promise is rejected the assertion fails.
+     */
+    resolves: Matchers<Promise<R>>;
+    /**
+     * Unwraps the reason of a rejected promise so any other matcher can be chained.
+     * If the promise is fulfilled the assertion fails.
+     */
+    rejects: Matchers<Promise<R>>;
+    /**
+     * Checks that a value is what you expect. It uses `===` to check strict equality.
+     * Don't use `toBe` with floating-point numbers.
+     */
+    toBe(expected: unknown): R;
+    /**
+     * Ensures that a mock function is called.
+     */
+    toBeCalled(): R;
+    /**
+     * Ensures that a mock function is called an exact number of times.
+     */
+    toBeCalledTimes(expected: number): R;
+    /**
+     * Ensure that a mock function is called with specific arguments.
+     */
+    toBeCalledWith(...args: Array<unknown>): R;
+    /**
+     * Using exact equality with floating point numbers is a bad idea.
+     * Rounding means that intuitive things fail.
+     * The default for numDigits is 2.
+     */
+    toBeCloseTo(expected: number, numDigits?: number): R;
+    /**
+     * Ensure that a variable is not undefined.
+     */
+    toBeDefined(): R;
+    /**
+     * When you don't care what a value is, you just want to
+     * ensure a value is false in a boolean context.
+     */
+    toBeFalsy(): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeGreaterThan(expected: number | bigint): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeGreaterThanOrEqual(expected: number | bigint): R;
+    /**
+     * Ensure that an object is an instance of a class.
+     * This matcher uses `instanceof` underneath.
+     */
+    toBeInstanceOf(expected: Function): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeLessThan(expected: number | bigint): R;
+    /**
+     * For comparing floating point numbers.
+     */
+    toBeLessThanOrEqual(expected: number | bigint): R;
+    /**
+     * This is the same as `.toBe(null)` but the error messages are a bit nicer.
+     * So use `.toBeNull()` when you want to check that something is null.
+     */
+    toBeNull(): R;
+    /**
+     * Use when you don't care what a value is, you just want to ensure a value
+     * is true in a boolean context. In JavaScript, there are six falsy values:
+     * `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy.
+     */
+    toBeTruthy(): R;
+    /**
+     * Used to check that a variable is undefined.
+     */
+    toBeUndefined(): R;
+    /**
+     * Used to check that a variable is NaN.
+     */
+    toBeNaN(): R;
+    /**
+     * Used when you want to check that an item is in a list.
+     * For testing the items in the list, this uses `===`, a strict equality check.
+     */
+    toContain(expected: unknown): R;
+    /**
+     * Used when you want to check that an item is in a list.
+     * For testing the items in the list, this  matcher recursively checks the
+     * equality of all fields, rather than checking for object identity.
+     */
+    toContainEqual(expected: unknown): R;
+    /**
+     * Used when you want to check that two objects have the same value.
+     * This matcher recursively checks the equality of all fields, rather than checking for object identity.
+     */
+    toEqual(expected: unknown): R;
+    /**
+     * Ensures that a mock function is called.
+     */
+    toHaveBeenCalled(): R;
+    /**
+     * Ensures that a mock function is called an exact number of times.
+     */
+    toHaveBeenCalledTimes(expected: number): R;
+    /**
+     * Ensure that a mock function is called with specific arguments.
+     */
+    toHaveBeenCalledWith(...args: Array<unknown>): R;
+    /**
+     * Ensure that a mock function is called with specific arguments on an Nth call.
+     */
+    toHaveBeenNthCalledWith(nthCall: number, ...args: Array<unknown>): R;
+    /**
+     * If you have a mock function, you can use `.toHaveBeenLastCalledWith`
+     * to test what arguments it was last called with.
+     */
+    toHaveBeenLastCalledWith(...args: Array<unknown>): R;
+    /**
+     * Use to test the specific value that a mock function last returned.
+     * If the last call to the mock function threw an error, then this matcher will fail
+     * no matter what value you provided as the expected return value.
+     */
+    toHaveLastReturnedWith(expected: unknown): R;
+    /**
+     * Used to check that an object has a `.length` property
+     * and it is set to a certain numeric value.
+     */
+    toHaveLength(expected: number): R;
+    /**
+     * Use to test the specific value that a mock function returned for the nth call.
+     * If the nth call to the mock function threw an error, then this matcher will fail
+     * no matter what value you provided as the expected return value.
+     */
+    toHaveNthReturnedWith(nthCall: number, expected: unknown): R;
+    /**
+     * Use to check if property at provided reference keyPath exists for an object.
+     * For checking deeply nested properties in an object you may use dot notation or an array containing
+     * the keyPath for deep references.
+     *
+     * Optionally, you can provide a value to check if it's equal to the value present at keyPath
+     * on the target object. This matcher uses 'deep equality' (like `toEqual()`) and recursively checks
+     * the equality of all fields.
+     *
+     * @example
+     *
+     * expect(houseForSale).toHaveProperty('kitchen.area', 20);
+     */
+    toHaveProperty(keyPath: string | Array<string>, value?: unknown): R;
+    /**
+     * Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
+     */
+    toHaveReturned(): R;
+    /**
+     * Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
+     * Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
+     */
+    toHaveReturnedTimes(expected: number): R;
+    /**
+     * Use to ensure that a mock function returned a specific value.
+     */
+    toHaveReturnedWith(expected: unknown): R;
+    /**
+     * Check that a string matches a regular expression.
+     */
+    toMatch(expected: string | RegExp): R;
+    /**
+     * Used to check that a JavaScript object matches a subset of the properties of an object
+     */
+    toMatchObject(expected: Record<string, unknown> | Array<unknown>): R;
+    /**
+     * Ensure that a mock function has returned (as opposed to thrown) at least once.
+     */
+    toReturn(): R;
+    /**
+     * Ensure that a mock function has returned (as opposed to thrown) a specified number of times.
+     */
+    toReturnTimes(count: number): R;
+    /**
+     * Ensure that a mock function has returned a specified value at least once.
+     */
+    toReturnWith(value: unknown): R;
+    /**
+     * Use to test that objects have the same types as well as structure.
+     */
+    toStrictEqual(expected: unknown): R;
+    /**
+     * Used to test that a function throws when it is called.
+     */
+    toThrow(error?: string | Constructable | RegExp | Error): R;
+    /**
+     * If you want to test that a specific error is thrown inside a function.
+     */
+    toThrowError(error?: string | Constructable | RegExp | Error): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/en/snapshot-testing) for more information.
+     */
+    toMatchSnapshot<T extends {
+        [P in keyof R]: unknown;
+    }>(propertyMatchers: Partial<T>, snapshotName?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/en/snapshot-testing) for more information.
+     */
+    toMatchSnapshot(snapshotName?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/en/snapshot-testing) for more information.
+     */
+    toMatchInlineSnapshot<T extends {
+        [P in keyof R]: unknown;
+    }>(propertyMatchers: Partial<T>, snapshot?: string): R;
+    /**
+     * This ensures that a value matches the most recent snapshot with property matchers.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     * Check out [the Snapshot Testing guide](https://jestjs.io/docs/en/snapshot-testing) for more information.
+     */
+    toMatchInlineSnapshot(snapshot?: string): R;
+    /**
+     * Used to test that a function throws a error matching the most recent snapshot when it is called.
+     */
+    toThrowErrorMatchingSnapshot(): R;
+    /**
+     * Used to test that a function throws a error matching the most recent snapshot when it is called.
+     * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
+     */
+    toThrowErrorMatchingInlineSnapshot(snapshot?: string): R;
+}
+export {};

node_modules/expect/build/ts3.4/utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ */
+declare type GetPath = {
+    hasEndProp?: boolean;
+    lastTraversedObject: unknown;
+    traversedPath: Array<string>;
+    value?: unknown;
+};
+export declare const hasOwnProperty: (object: object, key: string) => boolean;
+export declare const getPath: (object: Record<string, any>, propertyPath: string | string[]) => GetPath;
+export declare const getObjectSubset: (object: any, subset: any, seenReferences?: WeakMap<object, boolean>) => any;
+export declare const iterableEquality: (a: any, b: any, aStack?: any[], bStack?: any[]) => boolean | undefined;
+export declare const subsetEquality: (object: any, subset: any) => boolean | undefined;
+export declare const typeEquality: (a: any, b: any) => boolean | undefined;
+export declare const sparseArrayEquality: (a: unknown, b: unknown) => boolean | undefined;
+export declare const partition: <T>(items: T[], predicate: (arg: T) => boolean) => [T[], T[]];
+export declare const isError: (value: unknown) => value is Error;
+export declare function emptyObject(obj: any): boolean;
+export declare const isOneline: (expected: unknown, received: unknown) => boolean;
+export {};