$

node_modules/globals/index.d.ts

@@ -0,0 +1,6 @@
+import {ReadonlyDeep} from 'type-fest';
+import globalsJson = require('./globals.json');
+
+declare const globals: ReadonlyDeep<typeof globalsJson>;
+
+export = globals;

node_modules/globals/index.js

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('./globals.json');

node_modules/globals/license

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

node_modules/globals/node_modules/type-fest/base.d.ts

@@ -0,0 +1,38 @@
+// Types that are compatible with all supported TypeScript versions.
+// It's shared between all TypeScript version-specific definitions.
+
+// Basic
+export * from './source/basic';
+
+// Utilities
+export {Except} from './source/except';
+export {Mutable} from './source/mutable';
+export {Merge} from './source/merge';
+export {MergeExclusive} from './source/merge-exclusive';
+export {RequireAtLeastOne} from './source/require-at-least-one';
+export {RequireExactlyOne} from './source/require-exactly-one';
+export {PartialDeep} from './source/partial-deep';
+export {ReadonlyDeep} from './source/readonly-deep';
+export {LiteralUnion} from './source/literal-union';
+export {Promisable} from './source/promisable';
+export {Opaque} from './source/opaque';
+export {SetOptional} from './source/set-optional';
+export {SetRequired} from './source/set-required';
+export {ValueOf} from './source/value-of';
+export {PromiseValue} from './source/promise-value';
+export {AsyncReturnType} from './source/async-return-type';
+export {ConditionalExcept} from './source/conditional-except';
+export {ConditionalKeys} from './source/conditional-keys';
+export {ConditionalPick} from './source/conditional-pick';
+export {UnionToIntersection} from './source/union-to-intersection';
+export {Stringified} from './source/stringified';
+export {FixedLengthArray} from './source/fixed-length-array';
+export {IterableElement} from './source/iterable-element';
+export {Entry} from './source/entry';
+export {Entries} from './source/entries';
+export {SetReturnType} from './source/set-return-type';
+export {Asyncify} from './source/asyncify';
+
+// Miscellaneous
+export {PackageJson} from './source/package-json';
+export {TsConfigJson} from './source/tsconfig-json';

node_modules/globals/node_modules/type-fest/index.d.ts

@@ -0,0 +1,2 @@
+// These are all the basic types that's compatible with all supported TypeScript versions.
+export * from './base';

node_modules/globals/node_modules/type-fest/license

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

node_modules/globals/node_modules/type-fest/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "type-fest",
+	"version": "0.20.2",
+	"description": "A collection of essential TypeScript types",
+	"license": "(MIT OR CC0-1.0)",
+	"repository": "sindresorhus/type-fest",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"//test": "xo && tsd && tsc",
+		"test": "xo && tsc"
+	},
+	"files": [
+		"index.d.ts",
+		"base.d.ts",
+		"source",
+		"ts41"
+	],
+	"keywords": [
+		"typescript",
+		"ts",
+		"types",
+		"utility",
+		"util",
+		"utilities",
+		"omit",
+		"merge",
+		"json"
+	],
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "~0.7.0",
+		"tsd": "^0.13.1",
+		"typescript": "^4.1.2",
+		"xo": "^0.35.0"
+	},
+	"types": "./index.d.ts",
+	"typesVersions": {
+		">=4.1": {
+			"*": [
+				"ts41/*"
+			]
+		}
+	},
+	"xo": {
+		"rules": {
+			"@typescript-eslint/ban-types": "off",
+			"@typescript-eslint/indent": "off",
+			"node/no-unsupported-features/es-builtins": "off"
+		}
+	}
+}

node_modules/globals/node_modules/type-fest/source/async-return-type.d.ts

@@ -0,0 +1,23 @@
+import {PromiseValue} from './promise-value';
+
+type AsyncFunction = (...args: any[]) => Promise<unknown>;
+
+/**
+Unwrap the return type of a function that returns a `Promise`.
+
+There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+
+@example
+```ts
+import {AsyncReturnType} from 'type-fest';
+import {asyncFunction} from 'api';
+
+// This type resolves to the unwrapped return type of `asyncFunction`.
+type Value = AsyncReturnType<typeof asyncFunction>;
+
+async function doSomething(value: Value) {}
+
+asyncFunction().then(value => doSomething(value));
+```
+*/
+export type AsyncReturnType<Target extends AsyncFunction> = PromiseValue<ReturnType<Target>>;

node_modules/globals/node_modules/type-fest/source/asyncify.d.ts

@@ -0,0 +1,31 @@
+import {PromiseValue} from './promise-value';
+import {SetReturnType} from './set-return-type';
+
+/**
+Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+
+Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+
+@example
+```
+import {Asyncify} from 'type-fest';
+
+// Synchronous function.
+function getFooSync(someArg: SomeType): Foo {
+	// …
+}
+
+type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
+//=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
+
+// Same as `getFooSync` but asynchronous.
+const getFooAsync: AsyncifiedFooGetter = (someArg) => {
+	// TypeScript now knows that `someArg` is `SomeType` automatically.
+	// It also knows that this function must return `Promise<Foo>`.
+	// If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
+
+	// …
+}
+```
+*/
+export type Asyncify<Fn extends (...args: any[]) => any> = SetReturnType<Fn, Promise<PromiseValue<ReturnType<Fn>>>>;

node_modules/globals/node_modules/type-fest/source/basic.d.ts

@@ -0,0 +1,67 @@
+/// <reference lib="esnext"/>
+
+// TODO: This can just be `export type Primitive = not object` when the `not` keyword is out.
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+*/
+export type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+// TODO: Remove the `= unknown` sometime  in the future when most users are on TS 3.5 as it's now the default
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+*/
+export type Class<T = unknown, Arguments extends any[] = any[]> = new(...arguments_: Arguments) => T;
+
+/**
+Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+*/
+export type TypedArray =
+	| Int8Array
+	| Uint8Array
+	| Uint8ClampedArray
+	| Int16Array
+	| Uint16Array
+	| Int32Array
+	| Uint32Array
+	| Float32Array
+	| Float64Array
+	| BigInt64Array
+	| BigUint64Array;
+
+/**
+Matches a JSON object.
+
+This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+*/
+export type JsonObject = {[Key in string]?: JsonValue};
+
+/**
+Matches a JSON array.
+*/
+export interface JsonArray extends Array<JsonValue> {}
+
+/**
+Matches any valid JSON value.
+*/
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+*/
+export interface ObservableLike {
+	subscribe(observer: (value: unknown) => void): void;
+	[Symbol.observable](): ObservableLike;
+}

node_modules/globals/node_modules/type-fest/source/conditional-except.d.ts

@@ -0,0 +1,43 @@
+import {Except} from './except';
+import {ConditionalKeys} from './conditional-keys';
+
+/**
+Exclude keys from a shape that matches the given `Condition`.
+
+This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
+
+@example
+```
+import {Primitive, ConditionalExcept} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
+//=> {run: () => void}
+```
+
+@example
+```
+import {ConditionalExcept} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type NonStringKeysOnly = ConditionalExcept<Example, string>;
+//=> {b: string | number; c: () => void; d: {}}
+```
+*/
+export type ConditionalExcept<Base, Condition> = Except<
+	Base,
+	ConditionalKeys<Base, Condition>
+>;

node_modules/globals/node_modules/type-fest/source/conditional-keys.d.ts

@@ -0,0 +1,43 @@
+/**
+Extract the keys from a type where the value type of the key extends the given `Condition`.
+
+Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
+
+@example
+```
+import {ConditionalKeys} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c?: string;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalKeys<Example, string>;
+//=> 'a'
+```
+
+To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+
+@example
+```
+type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
+//=> 'a' | 'c'
+```
+*/
+export type ConditionalKeys<Base, Condition> = NonNullable<
+	// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+	{
+		// Map through all the keys of the given base type.
+		[Key in keyof Base]:
+			// Pick only keys with types extending the given `Condition` type.
+			Base[Key] extends Condition
+				// Retain this key since the condition passes.
+				? Key
+				// Discard this key since the condition fails.
+				: never;
+
+	// Convert the produced object into a union type of the keys which passed the conditional test.
+	}[keyof Base]
+>;

node_modules/globals/node_modules/type-fest/source/conditional-pick.d.ts

@@ -0,0 +1,42 @@
+import {ConditionalKeys} from './conditional-keys';
+
+/**
+Pick keys from the shape that matches the given `Condition`.
+
+This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
+
+@example
+```
+import {Primitive, ConditionalPick} from 'type-fest';
+
+class Awesome {
+	name: string;
+	successes: number;
+	failures: bigint;
+
+	run() {}
+}
+
+type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
+//=> {name: string; successes: number; failures: bigint}
+```
+
+@example
+```
+import {ConditionalPick} from 'type-fest';
+
+interface Example {
+	a: string;
+	b: string | number;
+	c: () => void;
+	d: {};
+}
+
+type StringKeysOnly = ConditionalPick<Example, string>;
+//=> {a: string}
+```
+*/
+export type ConditionalPick<Base, Condition> = Pick<
+	Base,
+	ConditionalKeys<Base, Condition>
+>;

node_modules/globals/node_modules/type-fest/source/entries.d.ts

@@ -0,0 +1,57 @@
+import {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
+
+type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
+type MapEntries<BaseType> = Array<MapEntry<BaseType>>;
+type ObjectEntries<BaseType> = Array<ObjectEntry<BaseType>>;
+type SetEntries<BaseType extends Set<unknown>> = Array<SetEntry<BaseType>>;
+
+/**
+Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries.
+
+For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
+
+@see `Entry` if you want to just access the type of a single entry.
+
+@example
+```
+import {Entries} from 'type-fest';
+
+interface Example {
+	someKey: number;
+}
+
+const manipulatesEntries = (examples: Entries<Example>) => examples.map(example => [
+	// Does some arbitrary processing on the key (with type information available)
+	example[0].toUpperCase(),
+
+	// Does some arbitrary processing on the value (with type information available)
+	example[1].toFixed()
+]);
+
+const example: Example = {someKey: 1};
+const entries = Object.entries(example) as Entries<Example>;
+const output = manipulatesEntries(entries);
+
+// Objects
+const objectExample = {a: 1};
+const objectEntries: Entries<typeof objectExample> = [['a', 1]];
+
+// Arrays
+const arrayExample = ['a', 1];
+const arrayEntries: Entries<typeof arrayExample> = [[0, 'a'], [1, 1]];
+
+// Maps
+const mapExample = new Map([['a', 1]]);
+const mapEntries: Entries<typeof map> = [['a', 1]];
+
+// Sets
+const setExample = new Set(['a', 1]);
+const setEntries: Entries<typeof setExample> = [['a', 'a'], [1, 1]];
+```
+*/
+export type Entries<BaseType> =
+	BaseType extends Map<unknown, unknown> ? MapEntries<BaseType>
+		: BaseType extends Set<unknown> ? SetEntries<BaseType>
+		: BaseType extends unknown[] ? ArrayEntries<BaseType>
+		: BaseType extends object ? ObjectEntries<BaseType>
+		: never;

node_modules/globals/node_modules/type-fest/source/entry.d.ts

@@ -0,0 +1,60 @@
+type MapKey<BaseType> = BaseType extends Map<infer KeyType, unknown> ? KeyType : never;
+type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
+
+export type ArrayEntry<BaseType extends readonly unknown[]> = [number, BaseType[number]];
+export type MapEntry<BaseType> = [MapKey<BaseType>, MapValue<BaseType>];
+export type ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
+export type SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
+
+/**
+Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
+
+For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
+
+@see `Entries` if you want to just access the type of the array of entries (which is the return of the `.entries()` method).
+
+@example
+```
+import {Entry} from 'type-fest';
+
+interface Example {
+	someKey: number;
+}
+
+const manipulatesEntry = (example: Entry<Example>) => [
+	// Does some arbitrary processing on the key (with type information available)
+	example[0].toUpperCase(),
+
+	// Does some arbitrary processing on the value (with type information available)
+	example[1].toFixed(),
+];
+
+const example: Example = {someKey: 1};
+const entry = Object.entries(example)[0] as Entry<Example>;
+const output = manipulatesEntry(entry);
+
+// Objects
+const objectExample = {a: 1};
+const objectEntry: Entry<typeof objectExample> = ['a', 1];
+
+// Arrays
+const arrayExample = ['a', 1];
+const arrayEntryString: Entry<typeof arrayExample> = [0, 'a'];
+const arrayEntryNumber: Entry<typeof arrayExample> = [1, 1];
+
+// Maps
+const mapExample = new Map([['a', 1]]);
+const mapEntry: Entry<typeof map> = ['a', 1];
+
+// Sets
+const setExample = new Set(['a', 1]);
+const setEntryString: Entry<typeof setExample> = ['a', 'a'];
+const setEntryNumber: Entry<typeof setExample> = [1, 1];
+```
+*/
+export type Entry<BaseType> =
+	BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
+		: BaseType extends Set<unknown> ? SetEntry<BaseType>
+		: BaseType extends unknown[] ? ArrayEntry<BaseType>
+		: BaseType extends object ? ObjectEntry<BaseType>
+		: never;

node_modules/globals/node_modules/type-fest/source/except.d.ts

@@ -0,0 +1,22 @@
+/**
+Create a type from an object type without certain keys.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/30825) if you want to have the stricter version as a built-in in TypeScript.
+
+@example
+```
+import {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+	c: boolean;
+};
+
+type FooWithoutA = Except<Foo, 'a' | 'c'>;
+//=> {b: string};
+```
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;

node_modules/globals/node_modules/type-fest/source/fixed-length-array.d.ts

@@ -0,0 +1,38 @@
+/**
+Methods to exclude.
+*/
+type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift';
+
+/**
+Create a type that represents an array of the given type and length. The array's length and the `Array` prototype methods that manipulate its length are excluded in the resulting type.
+
+Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similiar type built into TypeScript.
+
+Use-cases:
+- Declaring fixed-length tuples or arrays with a large number of items.
+- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
+- Creating an array of coordinates with a static length, for example, length of 3 for a 3D vector.
+
+@example
+```
+import {FixedLengthArray} from 'type-fest';
+
+type FencingTeam = FixedLengthArray<string, 3>;
+
+const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
+
+const homeFencingTeam: FencingTeam = ['George', 'John'];
+//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
+
+guestFencingTeam.push('Sam');
+//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
+```
+*/
+export type FixedLengthArray<Element, Length extends number, ArrayPrototype = [Element, ...Element[]]> = Pick<
+	ArrayPrototype,
+	Exclude<keyof ArrayPrototype, ArrayLengthMutationKeys>
+> & {
+	[index: number]: Element;
+	[Symbol.iterator]: () => IterableIterator<Element>;
+	readonly length: Length;
+};

node_modules/globals/node_modules/type-fest/source/iterable-element.d.ts

@@ -0,0 +1,46 @@
+/**
+Get the element type of an `Iterable`/`AsyncIterable`. For example, an array or a generator.
+
+This can be useful, for example, if you want to get the type that is yielded in a generator function. Often the return type of those functions are not specified.
+
+This type works with both `Iterable`s and `AsyncIterable`s, so it can be use with synchronous and asynchronous generators.
+
+Here is an example of `IterableElement` in action with a generator function:
+
+@example
+```
+function * iAmGenerator() {
+	yield 1;
+	yield 2;
+}
+
+type MeNumber = IterableElement<ReturnType<typeof iAmGenerator>>
+```
+
+And here is an example with an async generator:
+
+@example
+```
+async function * iAmGeneratorAsync() {
+	yield 'hi';
+	yield true;
+}
+
+type MeStringOrBoolean = IterableElement<ReturnType<typeof iAmGeneratorAsync>>
+```
+
+Many types in JavaScript/TypeScript are iterables. This type works on all types that implement those interfaces. For example, `Array`, `Set`, `Map`, `stream.Readable`, etc.
+
+An example with an array of strings:
+
+@example
+```
+type MeString = IterableElement<string[]>
+```
+*/
+export type IterableElement<TargetIterable> =
+	TargetIterable extends Iterable<infer ElementType> ?
+	ElementType :
+	TargetIterable extends AsyncIterable<infer ElementType> ?
+	ElementType :
+	never;

node_modules/globals/node_modules/type-fest/source/literal-union.d.ts

@@ -0,0 +1,33 @@
+import {Primitive} from './basic';
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+ */
+export type LiteralUnion<
+	LiteralType,
+	BaseType extends Primitive
+> = LiteralType | (BaseType & {_?: never});

node_modules/globals/node_modules/type-fest/source/merge-exclusive.d.ts

@@ -0,0 +1,39 @@
+// Helper type. Not useful on its own.
+type Without<FirstType, SecondType> = {[KeyType in Exclude<keyof FirstType, keyof SecondType>]?: never};
+
+/**
+Create a type that has mutually exclusive keys.
+
+This type was inspired by [this comment](https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-373782604).
+
+This type works with a helper type, called `Without`. `Without<FirstType, SecondType>` produces a type that has only keys from `FirstType` which are not present on `SecondType` and sets the value type for these keys to `never`. This helper type is then used in `MergeExclusive` to remove keys from either `FirstType` or `SecondType`.
+
+@example
+```
+import {MergeExclusive} from 'type-fest';
+
+interface ExclusiveVariation1 {
+	exclusive1: boolean;
+}
+
+interface ExclusiveVariation2 {
+	exclusive2: string;
+}
+
+type ExclusiveOptions = MergeExclusive<ExclusiveVariation1, ExclusiveVariation2>;
+
+let exclusiveOptions: ExclusiveOptions;
+
+exclusiveOptions = {exclusive1: true};
+//=> Works
+exclusiveOptions = {exclusive2: 'hi'};
+//=> Works
+exclusiveOptions = {exclusive1: true, exclusive2: 'hi'};
+//=> Error
+```
+*/
+export type MergeExclusive<FirstType, SecondType> =
+	(FirstType | SecondType) extends object ?
+		(Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) :
+		FirstType | SecondType;
+

node_modules/globals/node_modules/type-fest/source/merge.d.ts

@@ -0,0 +1,22 @@
+import {Except} from './except';
+
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import {Merge} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type Bar = {
+	b: number;
+};
+
+const ab: Merge<Foo, Bar> = {a: 1, b: 2};
+```
+*/
+export type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;

node_modules/globals/node_modules/type-fest/source/mutable.d.ts

@@ -0,0 +1,22 @@
+/**
+Convert an object with `readonly` keys into a mutable object. Inverse of `Readonly<T>`.
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), and [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509).
+
+@example
+```
+import {Mutable} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: string;
+};
+
+const mutableFoo: Mutable<Foo> = {a: 1, b: '2'};
+mutableFoo.a = 3;
+```
+*/
+export type Mutable<ObjectType> = {
+	// For each `Key` in the keys of `ObjectType`, make a mapped type by removing the `readonly` modifier from the key.
+	-readonly [KeyType in keyof ObjectType]: ObjectType[KeyType];
+};

node_modules/globals/node_modules/type-fest/source/opaque.d.ts

@@ -0,0 +1,65 @@
+/**
+Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
+
+The generic type parameter can be anything. It doesn't have to be an object.
+
+[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
+
+There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The Token parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne (): NewThingOne {
+	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+	return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+	return 2 as AccountNumber;
+}
+
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+	return 4 as AccountBalance;
+}
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will not compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+	id: Opaque<number, Person>;
+	name: string;
+};
+```
+*/
+export type Opaque<Type, Token = unknown> = Type & {readonly __opaque__: Token};

node_modules/globals/node_modules/type-fest/source/partial-deep.d.ts

@@ -0,0 +1,72 @@
+import {Primitive} from './basic';
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14;
+		fontColor: '#000000';
+		fontWeight: 400;
+	}
+	autocomplete: false;
+	autosave: true;
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+*/
+export type PartialDeep<T> = T extends Primitive
+	? Partial<T>
+	: T extends Map<infer KeyType, infer ValueType>
+	? PartialMapDeep<KeyType, ValueType>
+	: T extends Set<infer ItemType>
+	? PartialSetDeep<ItemType>
+	: T extends ReadonlyMap<infer KeyType, infer ValueType>
+	? PartialReadonlyMapDeep<KeyType, ValueType>
+	: T extends ReadonlySet<infer ItemType>
+	? PartialReadonlySetDeep<ItemType>
+	: T extends ((...arguments: any[]) => unknown)
+	? T | undefined
+	: T extends object
+	? PartialObjectDeep<T>
+	: unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and  as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialMapDeep<KeyType, ValueType> extends Map<PartialDeep<KeyType>, PartialDeep<ValueType>> {}
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialSetDeep<T> extends Set<PartialDeep<T>> {}
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialReadonlyMapDeep<KeyType, ValueType> extends ReadonlyMap<PartialDeep<KeyType>, PartialDeep<ValueType>> {}
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialReadonlySetDeep<T> extends ReadonlySet<PartialDeep<T>> {}
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object> = {
+	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType]>
+};

node_modules/globals/node_modules/type-fest/source/promisable.d.ts

@@ -0,0 +1,23 @@
+/**
+Create a type that represents either the value or the value wrapped in `PromiseLike`.
+
+Use-cases:
+- A function accepts a callback that may either return a value synchronously or may return a promised value.
+- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import {Promisable} from 'type-fest';
+
+async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
+    const entry = await getLogEntry();
+    console.log(entry);
+}
+
+logger(() => 'foo');
+logger(() => Promise.resolve('bar'));
+```
+*/
+export type Promisable<T> = T | PromiseLike<T>;

node_modules/globals/node_modules/type-fest/source/promise-value.d.ts

@@ -0,0 +1,27 @@
+/**
+Returns the type that is wrapped inside a `Promise` type.
+If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
+If the type is not a `Promise`, the type itself is returned.
+
+@example
+```
+import {PromiseValue} from 'type-fest';
+
+type AsyncData = Promise<string>;
+let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
+
+type Data = PromiseValue<AsyncData>;
+let data: Data = await asyncData;
+
+// Here's an example that shows how this type reacts to non-Promise types.
+type SyncData = PromiseValue<string>;
+let syncData: SyncData = getSyncData();
+
+// Here's an example that shows how this type reacts to recursive Promise types.
+type RecursiveAsyncData = Promise<Promise<string> >;
+let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
+```
+*/
+export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value>
+	? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
+	: Otherwise;

node_modules/globals/node_modules/type-fest/source/readonly-deep.d.ts

@@ -0,0 +1,59 @@
+import {Primitive} from './basic';
+
+/**
+Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	"foo": ["bar"]
+}
+
+// main.ts
+import {ReadonlyDeep} from 'type-fest';
+import dataJson = require('./data.json');
+
+const data: ReadonlyDeep<typeof dataJson> = dataJson;
+
+export default data;
+
+// test.ts
+import data from './main';
+
+data.foo.push('bar');
+//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
+```
+*/
+export type ReadonlyDeep<T> = T extends Primitive | ((...arguments: any[]) => unknown)
+	? T
+	: T extends ReadonlyMap<infer KeyType, infer ValueType>
+	? ReadonlyMapDeep<KeyType, ValueType>
+	: T extends ReadonlySet<infer ItemType>
+	? ReadonlySetDeep<ItemType>
+	: T extends object
+	? ReadonlyObjectDeep<T>
+	: unknown;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+interface ReadonlyMapDeep<KeyType, ValueType>
+	extends ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>> {}
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+interface ReadonlySetDeep<ItemType>
+	extends ReadonlySet<ReadonlyDeep<ItemType>> {}
+
+/**
+Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyObjectDeep<ObjectType extends object> = {
+	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
+};

node_modules/globals/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -0,0 +1,33 @@
+import {Except} from './except';
+
+/**
+Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+
+@example
+```
+import {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+
+	secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+*/
+export type RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType = keyof ObjectType
+> = {
+	// For each `Key` in `KeysType` make a mapped type:
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
+		// 2. Make all other keys in `KeysType` optional
+		Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] &
+	// 3. Add the remaining keys not in `KeysType`
+	Except<ObjectType, KeysType>;

node_modules/globals/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -0,0 +1,35 @@
+// TODO: Remove this when we target TypeScript >=3.5.
+type _Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
+/**
+Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
+
+Use-cases:
+- Creating interfaces for components that only need one of the keys to display properly.
+- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
+
+The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import {RequireExactlyOne} from 'type-fest';
+
+type Responder = {
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+};
+
+const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
+	// Adding a `text` key here would cause a compile error.
+
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+*/
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	{[Key in KeysType]: (
+		Required<Pick<ObjectType, Key>> &
+		Partial<Record<Exclude<KeysType, Key>, never>>
+	)}[KeysType] & _Omit<ObjectType, KeysType>;

node_modules/globals/node_modules/type-fest/source/set-optional.d.ts

@@ -0,0 +1,34 @@
+import {Except} from './except';
+
+/**
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+}
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+// type SomeOptional = {
+// 	a: number;
+// 	b?: string; // Was already optional and still is.
+// 	c?: boolean; // Is now optional.
+// }
+```
+*/
+export type SetOptional<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	// Pick just the keys that are not optional from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be optional from the base type and make them optional.
+	Partial<Pick<BaseType, Keys>> extends
+	// If `InferredType` extends the previous, then for each key, use the inferred type key.
+	infer InferredType
+		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
+		: never;

node_modules/globals/node_modules/type-fest/source/set-required.d.ts

@@ -0,0 +1,34 @@
+import {Except} from './except';
+
+/**
+Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
+
+@example
+```
+import {SetRequired} from 'type-fest';
+
+type Foo = {
+	a?: number;
+	b: string;
+	c?: boolean;
+}
+
+type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
+// type SomeRequired = {
+// 	a?: number;
+// 	b: string; // Was already required and still is.
+// 	c: boolean; // Is now required.
+// }
+```
+*/
+export type SetRequired<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	// Pick just the keys that are not required from the base type.
+	Except<BaseType, Keys> &
+	// Pick the keys that should be required from the base type and make them required.
+	Required<Pick<BaseType, Keys>> extends
+	// If `InferredType` extends the previous, then for each key, use the inferred type key.
+	infer InferredType
+		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
+		: never;

node_modules/globals/node_modules/type-fest/source/set-return-type.d.ts

@@ -0,0 +1,29 @@
+type IsAny<T> = 0 extends (1 & T) ? true : false; // https://stackoverflow.com/a/49928360/3406963
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnknown<T> = IsNever<T> extends false ? T extends unknown ? unknown extends T ? IsAny<T> extends false ? true : false : false : false : false;
+
+/**
+Create a function type with a return type of your choice and the same parameters as the given function type.
+
+Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+
+@example
+```
+import {SetReturnType} from 'type-fest';
+
+type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+
+type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+//=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+```
+*/
+export type SetReturnType<Fn extends (...args: any[]) => any, TypeToReturn> =
+	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+	Fn extends (this: infer ThisArg, ...args: infer Arguments) => any ? (
+		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+		IsUnknown<ThisArg> extends true ? (...args: Arguments) => TypeToReturn : (this: ThisArg, ...args: Arguments) => TypeToReturn
+	) : (
+		// This part should be unreachable, but we make it meaningful just in case…
+		(...args: Parameters<Fn>) => TypeToReturn
+	);

node_modules/globals/node_modules/type-fest/source/stringified.d.ts

@@ -0,0 +1,21 @@
+/**
+Create a type with the keys of the given type changed to `string` type.
+
+Use-case: Changing interface values to strings in order to use them in a form model.
+
+@example
+```
+import {Stringified} from 'type-fest';
+
+type Car {
+	model: string;
+	speed: number;
+}
+
+const carForm: Stringified<Car> = {
+	model: 'Foo',
+	speed: '101'
+};
+```
+*/
+export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};

node_modules/globals/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -0,0 +1,58 @@
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+*/
+export type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+	) extends ((mergedIntersection: infer Intersection) => void)
+		? Intersection
+		: never;

node_modules/globals/node_modules/type-fest/source/utilities.d.ts

@@ -0,0 +1,3 @@
+export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+
+export type WordSeparators = '-' | '_' | ' ';

node_modules/globals/node_modules/type-fest/source/value-of.d.ts

@@ -0,0 +1,40 @@
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	'foo': 1,
+	'bar': 2,
+	'biz': 3
+}
+
+// main.ts
+import {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+	return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+	return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+*/
+export type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];

node_modules/globals/node_modules/type-fest/ts41/camel-case.d.ts

@@ -0,0 +1,72 @@
+import {WordSeparators} from '../source/utilities';
+
+/**
+Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
+*/
+export type Split<S extends string, D extends string> =
+	string extends S ? string[] :
+	S extends '' ? [] :
+	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
+	[S];
+
+/**
+Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
+
+Only to be used by `CamelCaseStringArray<>`.
+
+@see CamelCaseStringArray
+*/
+type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? FirstPart extends undefined
+			? ''
+			: FirstPart extends ''
+					? InnerCamelCaseStringArray<RemainingParts, PreviousPart>
+					: `${PreviousPart extends '' ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`
+		: '';
+
+/**
+Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal.
+
+It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code.
+
+@see Split
+*/
+type CamelCaseStringArray<Parts extends string[]> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`>
+		: never;
+
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+@example
+```
+import {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+
+// Advanced
+
+type CamelCasedProps<T> = {
+	[K in keyof T as CamelCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+}
+
+const dbResult: CamelCasedProps<ModelProps> = {
+	dryRun: true,
+	fullFamilyName: 'bar.js',
+	foo: 123
+};
+```
+*/
+export type CamelCase<K> = K extends string ? CamelCaseStringArray<Split<K, WordSeparators>> : K;

node_modules/globals/node_modules/type-fest/ts41/delimiter-case.d.ts

@@ -0,0 +1,85 @@
+import {UpperCaseCharacters, WordSeparators} from '../source/utilities';
+
+/**
+Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+*/
+export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> =
+	Source extends '' ? [] :
+	Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ?
+	(
+		Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
+			? UsedDelimiter extends Delimiter
+				? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
+					? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>]
+					: never
+				: never
+			: never
+	) :
+	[Source];
+
+/**
+Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+
+@see StringArrayToDelimiterCase
+*/
+type StringPartToDelimiterCase<StringPart extends string, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+	StringPart extends UsedWordSeparators ? Delimiter :
+	StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` :
+	StringPart;
+
+/**
+Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+
+It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+
+@see SplitIncludingDelimiters
+*/
+type StringArrayToDelimiterCase<Parts extends any[], UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? `${StringPartToDelimiterCase<FirstPart, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
+		: '';
+
+/**
+Convert a string literal to a custom string delimiter casing.
+
+This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+
+@see KebabCase
+@see SnakeCase
+
+@example
+```
+import {DelimiterCase} from 'type-fest';
+
+// Simple
+
+const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+
+// Advanced
+
+type OddlyCasedProps<T> = {
+	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+};
+
+interface SomeOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: OddlyCasedProps<SomeOptions> = {
+	'dry#run': true,
+	'include#file': 'bar.js',
+	foo: 123
+};
+```
+*/
+
+export type DelimiterCase<Value, Delimiter extends string> = Value extends string
+	? StringArrayToDelimiterCase<
+		SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
+		WordSeparators,
+		UpperCaseCharacters,
+		Delimiter
+	>
+	: Value;

node_modules/globals/node_modules/type-fest/ts41/index.d.ts

@@ -0,0 +1,9 @@
+// These are all the basic types that's compatible with all supported TypeScript versions.
+export * from '../base';
+
+// These are special types that require at least TypeScript 4.1.
+export {CamelCase} from './camel-case';
+export {KebabCase} from './kebab-case';
+export {PascalCase} from './pascal-case';
+export {SnakeCase} from './snake-case';
+export {DelimiterCase} from './delimiter-case';

node_modules/globals/node_modules/type-fest/ts41/kebab-case.d.ts

@@ -0,0 +1,36 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert a string literal to kebab-case.
+
+This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
+
+@example
+```
+import {KebabCase} from 'type-fest';
+
+// Simple
+
+const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+
+// Advanced
+
+type KebabCasedProps<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+interface CliOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: KebabCasedProps<CliOptions> = {
+	'dry-run': true,
+	'include-file': 'bar.js',
+	foo: 123
+};
+```
+*/
+
+export type KebabCase<Value> = DelimiterCase<Value, '-'>;

node_modules/globals/node_modules/type-fest/ts41/pascal-case.d.ts

@@ -0,0 +1,36 @@
+import {CamelCase} from './camel-case';
+
+/**
+Converts a string literal to pascal-case.
+
+@example
+```
+import {PascalCase} from 'type-fest';
+
+// Simple
+
+const someVariable: PascalCase<'foo-bar'> = 'FooBar';
+
+// Advanced
+
+type PascalCaseProps<T> = {
+	[K in keyof T as PascalCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+}
+
+const dbResult: CamelCasedProps<ModelProps> = {
+	DryRun: true,
+	FullFamilyName: 'bar.js',
+	Foo: 123
+};
+```
+*/
+
+export type PascalCase<Value> = CamelCase<Value> extends string
+	? Capitalize<CamelCase<Value>>
+	: CamelCase<Value>;

node_modules/globals/node_modules/type-fest/ts41/snake-case.d.ts

@@ -0,0 +1,35 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert a string literal to snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a snake-cased SQL column name.
+
+@example
+```
+import {SnakeCase} from 'type-fest';
+
+// Simple
+
+const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
+
+// Advanced
+
+type SnakeCasedProps<T> = {
+	[K in keyof T as SnakeCase<K>]: T[K]
+};
+
+interface ModelProps {
+	isHappy: boolean;
+	fullFamilyName: string;
+	foo: number;
+}
+
+const dbResult: SnakeCasedProps<ModelProps> = {
+	'is_happy': true,
+	'full_family_name': 'Carla Smith',
+	foo: 123
+};
+```
+*/
+export type SnakeCase<Value> = DelimiterCase<Value, '_'>;

node_modules/globals/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "globals",
+	"version": "13.17.0",
+	"description": "Global identifiers from different JavaScript environments",
+	"license": "MIT",
+	"repository": "sindresorhus/globals",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"globals.json"
+	],
+	"keywords": [
+		"globals",
+		"global",
+		"identifiers",
+		"variables",
+		"vars",
+		"jshint",
+		"eslint",
+		"environments"
+	],
+	"dependencies": {
+		"type-fest": "^0.20.2"
+	},
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"tsd": "^0.14.0",
+		"xo": "^0.36.1"
+	},
+	"xo": {
+		"ignores": [
+			"get-browser-globals.js"
+		],
+		"rules": {
+			"node/no-unsupported-features/es-syntax": "off"
+		}
+	},
+	"tsd": {
+		"compilerOptions": {
+			"resolveJsonModule": true
+		}
+	}
+}

node_modules/globals/readme.md

@@ -0,0 +1,56 @@
+# globals
+
+> Global identifiers from different JavaScript environments
+
+It's just a [JSON file](globals.json), so use it in any environment.
+
+This package is used by ESLint.
+
+**This package [no longer accepts](https://github.com/sindresorhus/globals/issues/82) new environments. If you need it for ESLint, just [create a plugin](http://eslint.org/docs/developer-guide/working-with-plugins#environments-in-plugins).**
+
+## Install
+
+```
+$ npm install globals
+```
+
+## Usage
+
+```js
+const globals = require('globals');
+
+console.log(globals.browser);
+/*
+{
+	addEventListener: false,
+	applicationCache: false,
+	ArrayBuffer: false,
+	atob: false,
+	…
+}
+*/
+```
+
+Each global is given a value of `true` or `false`. A value of `true` indicates that the variable may be overwritten. A value of `false` indicates that the variable should be considered read-only. This information is used by static analysis tools to flag incorrect behavior. We assume all variables should be `false` unless we hear otherwise.
+
+For Node.js this package provides two sets of globals:
+
+- `globals.nodeBuiltin`: Globals available to all code running in Node.js.
+	These will usually be available as properties on the `global` object and include `process`, `Buffer`, but not CommonJS arguments like `require`.
+	See: https://nodejs.org/api/globals.html
+- `globals.node`: A combination of the globals from `nodeBuiltin` plus all CommonJS arguments ("CommonJS module scope").
+	See: https://nodejs.org/api/modules.html#modules_the_module_scope
+
+When analyzing code that is known to run outside of a CommonJS wrapper, for example, JavaScript modules, `nodeBuiltin` can find accidental CommonJS references.
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-globals?utm_source=npm-globals&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>