xo 0.52.2 → 0.52.3

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ast-utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './eslint-utils';
+export * from './helpers';
+export * from './misc';
+export * from './predicates';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ast-utils/misc.d.ts

@@ -0,0 +1,8 @@
+import { TSESTree } from '../ts-estree';
+declare const LINEBREAK_MATCHER: RegExp;
+/**
+ * Determines whether two adjacent tokens are on the same line
+ */
+declare function isTokenOnSameLine(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean;
+export { isTokenOnSameLine, LINEBREAK_MATCHER };
+//# sourceMappingURL=misc.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ast-utils/predicates.d.ts

@@ -0,0 +1,58 @@
+import { TSESTree } from '../ts-estree';
+declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.PunctuatorToken & {
+    value: "?.";
+};
+declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.PunctuatorToken & {
+    value: "!";
+};
+declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+/**
+ * Returns true if and only if the node represents: foo?.() or foo.bar?.()
+ */
+declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.CallExpression & {
+    optional: boolean;
+};
+/**
+ * Returns true if and only if the node represents logical OR
+ */
+declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is TSESTree.LogicalExpression & Partial<TSESTree.LogicalExpression>;
+/**
+ * Checks if a node is a type assertion:
+ * ```
+ * x as foo
+ * <foo>x
+ * ```
+ */
+declare const isTypeAssertion: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) => node is TSESTree.VariableDeclarator;
+declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
+declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+declare const isTSFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSFunctionType;
+declare const isTSConstructorType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSConstructorType;
+declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.FunctionExpression | TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSAbstractMethodDefinitionComputedName | TSESTree.TSAbstractMethodDefinitionNonComputedName | TSESTree.TSAbstractPropertyDefinitionComputedName | TSESTree.TSAbstractPropertyDefinitionNonComputedName | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSIndexSignature | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName;
+/**
+ * Checks if a node is a constructor method.
+ */
+declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (TSESTree.MethodDefinitionComputedName & Partial<TSESTree.MethodDefinitionComputedName>) | (TSESTree.MethodDefinitionNonComputedName & Partial<TSESTree.MethodDefinitionNonComputedName>);
+/**
+ * Checks if a node is a setter method.
+ */
+declare function isSetter(node: TSESTree.Node | undefined): node is (TSESTree.MethodDefinition | TSESTree.Property) & {
+    kind: 'set';
+};
+declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier;
+/**
+ * Checks if a node represents an `await …` expression.
+ */
+declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.AwaitExpression;
+/**
+ * Checks if a possible token is the `await` keyword.
+ */
+declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is TSESTree.IdentifierToken & {
+    value: "await";
+};
+declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
+export { isAwaitExpression, isAwaitKeyword, isConstructor, isClassOrTypeElement, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isLoop, isLogicalOrOperator, isNonNullAssertionPunctuator, isNotNonNullAssertionPunctuator, isNotOptionalChainPunctuator, isOptionalChainPunctuator, isOptionalCallExpression, isSetter, isTSConstructorType, isTSFunctionType, isTypeAssertion, isVariableDeclarator, };
+//# sourceMappingURL=predicates.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/InferTypesFromRule.d.ts

@@ -0,0 +1,11 @@
+import { RuleCreateFunction, RuleModule } from '../ts-eslint';
+/**
+ * Uses type inference to fetch the TOptions type from the given RuleModule
+ */
+declare type InferOptionsTypeFromRule<T> = T extends RuleModule<infer _TMessageIds, infer TOptions> ? TOptions : T extends RuleCreateFunction<infer _TMessageIds, infer TOptions> ? TOptions : unknown;
+/**
+ * Uses type inference to fetch the TMessageIds type from the given RuleModule
+ */
+declare type InferMessageIdsTypeFromRule<T> = T extends RuleModule<infer TMessageIds, infer _TOptions> ? TMessageIds : T extends RuleCreateFunction<infer TMessageIds, infer _TOptions> ? TMessageIds : unknown;
+export { InferOptionsTypeFromRule, InferMessageIdsTypeFromRule };
+//# sourceMappingURL=InferTypesFromRule.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/RuleCreator.d.ts

@@ -0,0 +1,35 @@
+import { RuleMetaData, RuleMetaDataDocs, RuleListener, RuleContext, RuleModule } from '../ts-eslint/Rule';
+export declare type NamedCreateRuleMetaDocs = Pick<RuleMetaDataDocs, Exclude<keyof RuleMetaDataDocs, 'url'>>;
+export declare type NamedCreateRuleMeta<TMessageIds extends string> = {
+    docs: NamedCreateRuleMetaDocs;
+} & Pick<RuleMetaData<TMessageIds>, Exclude<keyof RuleMetaData<TMessageIds>, 'docs'>>;
+export interface RuleCreateAndOptions<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> {
+    create: (context: Readonly<RuleContext<TMessageIds, TOptions>>, optionsWithDefault: Readonly<TOptions>) => TRuleListener;
+    defaultOptions: Readonly<TOptions>;
+}
+export interface RuleWithMeta<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> extends RuleCreateAndOptions<TOptions, TMessageIds, TRuleListener> {
+    meta: RuleMetaData<TMessageIds>;
+}
+export interface RuleWithMetaAndName<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> extends RuleCreateAndOptions<TOptions, TMessageIds, TRuleListener> {
+    meta: NamedCreateRuleMeta<TMessageIds>;
+    name: string;
+}
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+export declare function RuleCreator(urlCreator: (ruleName: string) => string): <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener = RuleListener>({ name, meta, ...rule }: Readonly<RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => RuleModule<TMessageIds, TOptions, TRuleListener>;
+export declare namespace RuleCreator {
+    var withoutDocs: typeof createRule;
+}
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+declare function createRule<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener = RuleListener>({ create, defaultOptions, meta, }: Readonly<RuleWithMeta<TOptions, TMessageIds, TRuleListener>>): RuleModule<TMessageIds, TOptions, TRuleListener>;
+export {};
+//# sourceMappingURL=RuleCreator.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/RuleTester.d.ts

@@ -0,0 +1,18 @@
+import * as TSESLint from '../ts-eslint';
+declare const parser = "@typescript-eslint/parser";
+declare type RuleTesterConfig = Pick<TSESLint.RuleTesterConfig, Exclude<keyof TSESLint.RuleTesterConfig, 'parser'>> & {
+    parser: typeof parser;
+};
+declare class RuleTester extends TSESLint.RuleTester {
+    private "RuleTester.#private";
+    constructor(options: RuleTesterConfig);
+    private getFilename;
+    run<TMessageIds extends string, TOptions extends Readonly<unknown[]>>(name: string, rule: TSESLint.RuleModule<TMessageIds, TOptions>, testsReadonly: TSESLint.RunTests<TMessageIds, TOptions>): void;
+}
+/**
+ * Simple no-op tag to mark code samples as "should not format with prettier"
+ *   for the internal/plugin-test-formatting lint rule
+ */
+declare function noFormat(strings: TemplateStringsArray, ...keys: string[]): string;
+export { noFormat, RuleTester };
+//# sourceMappingURL=RuleTester.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/applyDefault.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Uses the default options and overrides with the options provided by the user
+ * @param defaultOptions the defaults
+ * @param userOptions the user opts
+ * @returns the options with defaults
+ */
+declare function applyDefault<TUser extends readonly unknown[], TDefault extends TUser>(defaultOptions: Readonly<TDefault>, userOptions: Readonly<TUser> | null): TDefault;
+export { applyDefault };
+//# sourceMappingURL=applyDefault.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/batchedSingleLineTests.d.ts

@@ -0,0 +1,24 @@
+import { ValidTestCase, InvalidTestCase } from '../ts-eslint';
+/**
+ * Converts a batch of single line tests into a number of separate test cases.
+ * This makes it easier to write tests which use the same options.
+ *
+ * Why wouldn't you just leave them as one test?
+ * Because it makes the test error messages harder to decipher.
+ * This way each line will fail separately, instead of them all failing together.
+ */
+declare function batchedSingleLineTests<TOptions extends Readonly<unknown[]>>(test: ValidTestCase<TOptions>): ValidTestCase<TOptions>[];
+/**
+ * Converts a batch of single line tests into a number of separate test cases.
+ * This makes it easier to write tests which use the same options.
+ *
+ * Why wouldn't you just leave them as one test?
+ * Because it makes the test error messages harder to decipher.
+ * This way each line will fail separately, instead of them all failing together.
+ *
+ * Make sure you have your line numbers correct for error reporting, as it will match
+ * the line numbers up with the split tests!
+ */
+declare function batchedSingleLineTests<TMessageIds extends string, TOptions extends Readonly<unknown[]>>(test: InvalidTestCase<TMessageIds, TOptions>): InvalidTestCase<TMessageIds, TOptions>[];
+export { batchedSingleLineTests };
+//# sourceMappingURL=batchedSingleLineTests.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/deepMerge.d.ts

@@ -0,0 +1,17 @@
+declare type ObjectLike<T = unknown> = Record<string, T>;
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param obj an object
+ * @returns `true` if obj is an object
+ */
+declare function isObjectNotArray<T extends ObjectLike>(obj: unknown | unknown[]): obj is T;
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Merges two objects together deeply, overwriting the properties in first with the properties in second
+ * @param first The first object
+ * @param second The second object
+ * @returns a new object
+ */
+export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record<string, unknown>;
+export { isObjectNotArray };
+//# sourceMappingURL=deepMerge.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/getParserServices.d.ts

@@ -0,0 +1,8 @@
+import * as TSESLint from '../ts-eslint';
+import { ParserServices } from '../ts-estree';
+/**
+ * Try to retrieve typescript parser service from context
+ */
+declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation?: boolean): ParserServices;
+export { getParserServices };
+//# sourceMappingURL=getParserServices.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './applyDefault';
+export * from './batchedSingleLineTests';
+export * from './getParserServices';
+export * from './InferTypesFromRule';
+export * from './RuleCreator';
+export * from './RuleTester';
+export * from './deepMerge';
+export * from './nullThrows';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/eslint-utils/nullThrows.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A set of common reasons for calling nullThrows
+ */
+declare const NullThrowsReasons: {
+    readonly MissingParent: "Expected node to have a parent.";
+    readonly MissingToken: (token: string, thing: string) => string;
+};
+/**
+ * Assert that a value must not be null or undefined.
+ * This is a nice explicit alternative to the non-null assertion operator.
+ */
+declare function nullThrows<T>(value: T | null | undefined, message: string): T;
+export { nullThrows, NullThrowsReasons };
+//# sourceMappingURL=nullThrows.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/index.d.ts

@@ -0,0 +1,8 @@
+import * as ASTUtils from './ast-utils';
+import * as ESLintUtils from './eslint-utils';
+import * as JSONSchema from './json-schema';
+import * as TSESLint from './ts-eslint';
+import * as TSESLintScope from './ts-eslint-scope';
+export { ASTUtils, ESLintUtils, JSONSchema, TSESLint, TSESLintScope };
+export * from './ts-estree';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/json-schema.d.ts

@@ -0,0 +1,2 @@
+export { JSONSchema4, JSONSchema4Type, JSONSchema4TypeName, JSONSchema4Version, JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version, JSONSchema7, JSONSchema7Array, JSONSchema7Definition, JSONSchema7Type, JSONSchema7TypeName, JSONSchema7Version, ValidationError, ValidationResult, } from 'json-schema';
+//# sourceMappingURL=json-schema.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/AST.d.ts

@@ -0,0 +1,9 @@
+import { TSESTree, AST_TOKEN_TYPES } from '../ts-estree';
+declare namespace AST {
+    type TokenType = AST_TOKEN_TYPES;
+    type Token = TSESTree.Token;
+    type SourceLocation = TSESTree.SourceLocation;
+    type Range = TSESTree.Range;
+}
+export { AST };
+//# sourceMappingURL=AST.d.ts.map

package/node_modules/@typescript-eslint/utils/_ts3.4/dist/ts-eslint/CLIEngine.d.ts

@@ -0,0 +1,137 @@
+import { Linter } from './Linter';
+import { RuleListener, RuleMetaData, RuleModule } from './Rule';
+declare namespace CLIEngine {
+    interface Options {
+        allowInlineConfig?: boolean;
+        baseConfig?: false | {
+            [name: string]: unknown;
+        };
+        cache?: boolean;
+        cacheFile?: string;
+        cacheLocation?: string;
+        configFile?: string;
+        cwd?: string;
+        envs?: string[];
+        errorOnUnmatchedPattern?: boolean;
+        extensions?: string[];
+        fix?: boolean;
+        globals?: string[];
+        ignore?: boolean;
+        ignorePath?: string;
+        ignorePattern?: string | string[];
+        useEslintrc?: boolean;
+        parser?: string;
+        parserOptions?: Linter.ParserOptions;
+        plugins?: string[];
+        resolvePluginsRelativeTo?: string;
+        rules?: {
+            [name: string]: Linter.RuleLevel | Linter.RuleLevelAndOptions;
+        };
+        rulePaths?: string[];
+        reportUnusedDisableDirectives?: boolean;
+    }
+    interface LintResult {
+        filePath: string;
+        messages: Linter.LintMessage[];
+        errorCount: number;
+        warningCount: number;
+        fixableErrorCount: number;
+        fixableWarningCount: number;
+        output?: string;
+        source?: string;
+    }
+    interface LintReport {
+        results: LintResult[];
+        errorCount: number;
+        warningCount: number;
+        fixableErrorCount: number;
+        fixableWarningCount: number;
+        usedDeprecatedRules: DeprecatedRuleUse[];
+    }
+    interface DeprecatedRuleUse {
+        ruleId: string;
+        replacedBy: string[];
+    }
+    interface LintResultData<TMessageIds extends string> {
+        rulesMeta: {
+            [ruleId: string]: RuleMetaData<TMessageIds>;
+        };
+    }
+    type Formatter = <TMessageIds extends string>(results: LintResult[], data?: LintResultData<TMessageIds>) => string;
+}
+/**
+ * The underlying utility that runs the ESLint command line interface. This object will read the filesystem for
+ * configuration and file information but will not output any results. Instead, it allows you direct access to the
+ * important information so you can deal with the output yourself.
+ * @deprecated use the ESLint class instead
+ */
+declare const CLIEngine: {
+    new (options: CLIEngine.Options): {
+        /**
+         * Add a plugin by passing its configuration
+         * @param name Name of the plugin.
+         * @param pluginObject Plugin configuration object.
+         */
+        addPlugin(name: string, pluginObject: Linter.Plugin): void;
+        /**
+         * Executes the current configuration on an array of file and directory names.
+         * @param patterns An array of file and directory names.
+         * @returns The results for all files that were linted.
+         */
+        executeOnFiles(patterns: string[]): CLIEngine.LintReport;
+        /**
+         * Executes the current configuration on text.
+         * @param text A string of JavaScript code to lint.
+         * @param filename An optional string representing the texts filename.
+         * @param warnIgnored Always warn when a file is ignored
+         * @returns The results for the linting.
+         */
+        executeOnText(text: string, filename?: string, warnIgnored?: boolean): CLIEngine.LintReport;
+        /**
+         * Returns a configuration object for the given file based on the CLI options.
+         * This is the same logic used by the ESLint CLI executable to determine configuration for each file it processes.
+         * @param filePath The path of the file to retrieve a config object for.
+         * @returns A configuration object for the file.
+         */
+        getConfigForFile(filePath: string): Linter.Config;
+        /**
+         * Returns the formatter representing the given format.
+         * @param format The name of the format to load or the path to a custom formatter.
+         * @returns The formatter function.
+         */
+        getFormatter(format?: string): CLIEngine.Formatter;
+        /**
+         * Checks if a given path is ignored by ESLint.
+         * @param filePath The path of the file to check.
+         * @returns Whether or not the given path is ignored.
+         */
+        isPathIgnored(filePath: string): boolean;
+        /**
+         * Resolves the patterns passed into `executeOnFiles()` into glob-based patterns for easier handling.
+         * @param patterns The file patterns passed on the command line.
+         * @returns The equivalent glob patterns.
+         */
+        resolveFileGlobPatterns(patterns: string[]): string[];
+        getRules<TMessageIds extends string = string, TOptions extends readonly unknown[] = unknown[], TRuleListener extends RuleListener = RuleListener>(): Map<string, RuleModule<TMessageIds, TOptions, TRuleListener>>;
+    };
+    /**
+     * Returns results that only contains errors.
+     * @param results The results to filter.
+     * @returns The filtered results.
+     */
+    getErrorResults(results: CLIEngine.LintResult[]): CLIEngine.LintResult[];
+    /**
+     * Returns the formatter representing the given format or null if the `format` is not a string.
+     * @param format The name of the format to load or the path to a custom formatter.
+     * @returns The formatter function.
+     */
+    getFormatter(format?: string): CLIEngine.Formatter;
+    /**
+     * Outputs fixes from the given results to files.
+     * @param report The report object created by CLIEngine.
+     */
+    outputFixes(report: CLIEngine.LintReport): void;
+    version: string;
+} | undefined;
+export { CLIEngine };
+//# sourceMappingURL=CLIEngine.d.ts.map