linted 16.12.2-rc.1 → 16.12.2-rc.2

package/dist/rules/svelte/_enable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_enable.js","sourceRoot":"","sources":["../../../src/rules/svelte/_enable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAElD,MACA,EAAE,MAAM,EAAE,GAAG,EAAE,EACf,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,EACtB,EACE,KAAK,EACL,MAAM,EACN,KAAK,EACL,MAAM,GACP,GAAG,KAAK,CAAC;AAEV,eAAe;IACb,MAAM;IACN;QAGE,+BAA+B,EAAE,KAAK;QACtC,4BAA4B,EAAE,KAAK;QACnC,+BAA+B,EAAE,KAAK;QACtC,8BAA8B,EAAE,KAAK;QACrC,iCAAiC,EAAE,KAAK;QACxC,+BAA+B,EAAE,KAAK;QACtC,6BAA6B,EAAE,KAAK;QACpC,qDAAqD,EAAE,KAAK;QAC5D,gCAAgC,EAAE,KAAK;QACvC,oCAAoC,EAAE,KAAK;QAC3C,6BAA6B,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACvD,8CAA8C,EAAE,KAAK;QACrD,uBAAuB,EAAE,KAAK;QAC9B,4CAA4C,EAAE,CAAC,KAAK,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;QAC/E,8CAA8C,EAAE,KAAK;QACrD,sCAAsC,EAAE,KAAK;QAC7C,sBAAsB,EAAE,CAAC,KAAK,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC;QAC1D,sCAAsC,EAAE,KAAK;QAM7C,wBAAwB,EAAE,KAAK;QAC/B,wBAAwB,EAAE,CAAC,KAAK,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,EAAE,CAAC;QAMxF,mBAAmB,EAAE;YACnB,KAAK;YACL;gBACE,oBAAoB,EAAE,IAAI;gBAC1B,mBAAmB,EAAE,KAAK;gBAC1B,MAAM,EAAE,CAAC,IAAI,CAAC;gBACd,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;aACvB;SACF;QACD,wBAAwB,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAC9E,yBAAyB,EAAE,KAAK;QAChC,+BAA+B,EAAE,KAAK;QACtC,yCAAyC,EAAE,KAAK;QAChD,yBAAyB,EAAE,CAAC,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC;QAC/D,8BAA8B,EAAE,KAAK;QACrC,6BAA6B,EAAE,KAAK;QACpC,2BAA2B,EAAE,KAAK;QAClC,6BAA6B,EAAE,KAAK;QACpC,gCAAgC,EAAE,KAAK;QACvC,6BAA6B,EAAE,CAAC,KAAK,EAAE,EAAE,qBAAqB,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;QACnG,wCAAwC,EAAE,KAAK;QAC/C,yBAAyB,EAAE,KAAK;QAChC,uCAAuC,EAAE,KAAK;QAC9C,0CAA0C,EAAE,KAAK;QACjD,4BAA4B,EAAE,KAAK;QACnC,uBAAuB,EAAE,KAAK;QAM9B,wCAAwC,EAAE,KAAK;QAC/C,kCAAkC,EAAE,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QACpF,qCAAqC,EAAE,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,CAAC;QAC1G,oBAAoB,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,0BAA0B,EAAE,IAAI,EAAE,EAAE,CAAC;QAC/G,0BAA0B,EAAE;YAC1B,KAAK;YACL;gBACE,MAAM,EAAE,MAAM;gBACd,MAAM,EAAE,MAAM;gBACd,SAAS,EAAE,MAAM;gBACjB,MAAM,EAAE,MAAM;aACf;SACF;QACD,eAAe,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,yBAAyB,EAAE,IAAI,EAAE,CAAC;QACvF,gCAAgC,EAAE,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;QAC1E,yBAAyB,EAAE;YACzB,KAAK;YACL;gBACE,eAAe,EAAE,KAAK;gBACtB,kBAAkB,EAAE,KAAK;gBACzB,oBAAoB,EAAE,KAAK;gBAC3B,IAAI,EAAE,EAAE,YAAY,EAAE,KAAK,EAAkB,YAAY,EAAE,KAAK,EAA+C;aAChH;SACF;QACD,kCAAkC,EAAE,KAAK;QACzC,oCAAoC,EAAE,GAAG;QACzC,kDAAkD,EAAE,KAAK;QACzD,+BAA+B,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QAC7D,+BAA+B,EAAE,KAAK;QACtC,4BAA4B,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACzD,4BAA4B,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACzD,wBAAwB,EAAE,GAAG;QAC7B,4BAA4B,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;QAM7C,6BAA6B,EAAE,KAAK;QAMpC,0BAA0B,EAAE,CAAC,KAAK,EAAE,EAAE,6BAA6B,EAAE,IAAI,EAAE,CAAC;QAC5E,eAAe,EAAE,KAAK;KAIvB;CACO,CAAC"}

package/dist/rules/svelte/disable_x.d.ts

@@ -0,0 +1,5 @@
+declare const _default: readonly ["disable-extend", {
+    readonly "no-inner-declarations": "off";
+}];
+export default _default;
+//# sourceMappingURL=disable_x.d.ts.map

package/dist/rules/svelte/disable_x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disable_x.d.ts","sourceRoot":"","sources":["../../../src/rules/svelte/disable_x.ts"],"names":[],"mappings":";;;AAOA,wBAA4I"}

package/dist/rules/svelte/disable_x.js

@@ -0,0 +1,4 @@
+import { id, level } from "../_strings.js";
+const { disable_x } = id, { OFF } = level;
+export default [disable_x, { "no-inner-declarations": OFF }];
+//# sourceMappingURL=disable_x.js.map

package/dist/rules/svelte/disable_x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disable_x.js","sourceRoot":"","sources":["../../../src/rules/svelte/disable_x.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MACA,EAAE,SAAS,EAAE,GAAG,EAAE,EAClB,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;AAGhB,eAAe,CAAC,SAAS,EAAE,EAAE,uBAAuB,EAAE,GAAG,EAAwE,CAAU,CAAC"}

package/dist/rules/ts/_enable.d.ts

@@ -0,0 +1,262 @@
+declare const _default: readonly ["enable", {
+    readonly "@typescript-eslint/adjacent-overload-signatures": "off";
+    readonly "@typescript-eslint/array-type": readonly ["error", {
+        readonly default: "array";
+        readonly readonly: "array";
+    }];
+    readonly "@typescript-eslint/await-thenable": "error";
+    readonly "@typescript-eslint/ban-ts-comment": readonly ["error", {
+        readonly "ts-check": false;
+        readonly "ts-expect-error": {
+            readonly descriptionFormat: "^: BUG: .+$";
+        };
+        readonly "ts-ignore": true;
+        readonly "ts-nocheck": true;
+        readonly minimumDescriptionLength: 32;
+    }];
+    readonly "@typescript-eslint/ban-tslint-comment": "error";
+    readonly "@typescript-eslint/class-literal-property-style": readonly ["error", "fields"];
+    readonly "@typescript-eslint/consistent-generic-constructors": readonly ["error", "constructor"];
+    readonly "@typescript-eslint/consistent-indexed-object-style": readonly ["error", "record"];
+    readonly "@typescript-eslint/consistent-type-assertions": readonly ["error", {
+        readonly assertionStyle: "as";
+        readonly objectLiteralTypeAssertions: "never";
+    }];
+    readonly "@typescript-eslint/consistent-type-definitions": "off";
+    readonly "@typescript-eslint/consistent-type-exports": readonly ["error", {
+        readonly fixMixedExportsWithInlineTypeSpecifier: false;
+    }];
+    readonly "@typescript-eslint/consistent-type-imports": readonly ["error", {
+        readonly disallowTypeAnnotations: true;
+        readonly fixStyle: "separate-type-imports";
+        readonly prefer: "type-imports";
+    }];
+    readonly "@typescript-eslint/explicit-function-return-type": "off";
+    readonly "@typescript-eslint/explicit-member-accessibility": readonly ["error", {
+        readonly accessibility: "explicit";
+        readonly ignoredMethodNames: readonly [];
+        readonly overrides: {
+            readonly properties: "explicit";
+            readonly constructors: "no-public";
+            readonly accessors: "explicit";
+            readonly methods: "explicit";
+            readonly parameterProperties: "explicit";
+        };
+    }];
+    readonly "@typescript-eslint/explicit-module-boundary-types": "off";
+    readonly "@typescript-eslint/member-ordering": readonly ["error", {
+        readonly default: {
+            readonly memberTypes: readonly ["signature", "call-signature", "public-static-field", "protected-static-field", "private-static-field", "#private-static-field", "public-decorated-field", "protected-decorated-field", "private-decorated-field", "public-instance-field", "protected-instance-field", "private-instance-field", "#private-instance-field", "public-abstract-field", "protected-abstract-field", "public-field", "protected-field", "private-field", "#private-field", "static-field", "instance-field", "abstract-field", "decorated-field", "field", "static-initialization", "public-constructor", "protected-constructor", "private-constructor", "constructor", "public-static-accessor", "protected-static-accessor", "private-static-accessor", "#private-static-accessor", "public-decorated-accessor", "protected-decorated-accessor", "private-decorated-accessor", "public-instance-accessor", "protected-instance-accessor", "private-instance-accessor", "#private-instance-accessor", "public-abstract-accessor", "protected-abstract-accessor", "public-accessor", "protected-accessor", "private-accessor", "#private-accessor", "static-accessor", "instance-accessor", "abstract-accessor", "decorated-accessor", "accessor", "public-static-get", "protected-static-get", "private-static-get", "#private-static-get", "public-decorated-get", "protected-decorated-get", "private-decorated-get", "public-instance-get", "protected-instance-get", "private-instance-get", "#private-instance-get", "public-abstract-get", "protected-abstract-get", "public-get", "protected-get", "private-get", "#private-get", "static-get", "instance-get", "abstract-get", "decorated-get", "get", "public-static-set", "protected-static-set", "private-static-set", "#private-static-set", "public-decorated-set", "protected-decorated-set", "private-decorated-set", "public-instance-set", "protected-instance-set", "private-instance-set", "#private-instance-set", "public-abstract-set", "protected-abstract-set", "public-set", "protected-set", "private-set", "#private-set", "static-set", "instance-set", "abstract-set", "decorated-set", "set", "public-static-method", "protected-static-method", "private-static-method", "#private-static-method", "public-decorated-method", "protected-decorated-method", "private-decorated-method", "public-instance-method", "protected-instance-method", "private-instance-method", "#private-instance-method", "public-abstract-method", "protected-abstract-method", "public-method", "protected-method", "private-method", "#private-method", "static-method", "instance-method", "abstract-method", "decorated-method", "method"];
+            readonly optionalityOrder: "required-first";
+            readonly order: "as-written";
+        };
+    }];
+    readonly "@typescript-eslint/method-signature-style": readonly ["error", "property"];
+    readonly "@typescript-eslint/naming-convention": "off";
+    readonly "@typescript-eslint/no-array-delete": "error";
+    readonly "@typescript-eslint/no-base-to-string": readonly ["error", {
+        readonly ignoredTypeNames: readonly ["Error", "RegExp", "URL", "URLSearchParams"];
+    }];
+    readonly "@typescript-eslint/no-confusing-non-null-assertion": "error";
+    readonly "@typescript-eslint/no-confusing-void-expression": readonly ["error", {
+        readonly ignoreArrowShorthand: true;
+        readonly ignoreVoidOperator: true;
+    }];
+    readonly "@typescript-eslint/no-duplicate-enum-values": "error";
+    readonly "@typescript-eslint/no-duplicate-type-constituents": readonly ["error", {
+        readonly ignoreIntersections: false;
+        readonly ignoreUnions: false;
+    }];
+    readonly "@typescript-eslint/no-dynamic-delete": "error";
+    readonly "@typescript-eslint/no-empty-object-type": readonly ["error", {
+        readonly allowInterfaces: "never";
+        readonly allowObjectTypes: "never";
+    }];
+    readonly "@typescript-eslint/no-explicit-any": readonly ["error", {
+        readonly fixToUnknown: true;
+        readonly ignoreRestArgs: false;
+    }];
+    readonly "@typescript-eslint/no-extra-non-null-assertion": "error";
+    readonly "@typescript-eslint/no-extraneous-class": readonly ["error", {
+        readonly allowConstructorOnly: false;
+        readonly allowEmpty: true;
+        readonly allowStaticOnly: false;
+        readonly allowWithDecorator: false;
+    }];
+    readonly "@typescript-eslint/no-floating-promises": readonly ["error", {
+        readonly checkThenables: true;
+        readonly ignoreVoid: true;
+        readonly ignoreIIFE: false;
+    }];
+    readonly "@typescript-eslint/no-for-in-array": "error";
+    readonly "@typescript-eslint/no-import-type-side-effects": "error";
+    readonly "@typescript-eslint/no-inferrable-types": readonly ["error", {
+        readonly ignoreParameters: false;
+        readonly ignoreProperties: false;
+    }];
+    readonly "@typescript-eslint/no-invalid-void-type": readonly ["error", {
+        readonly allowInGenericTypeArguments: true;
+        readonly allowAsThisParameter: false;
+    }];
+    readonly "@typescript-eslint/no-meaningless-void-operator": readonly ["error", {
+        readonly checkNever: true;
+    }];
+    readonly "@typescript-eslint/no-misused-new": "error";
+    readonly "@typescript-eslint/no-misused-promises": readonly ["error", {
+        readonly checksConditionals: true;
+        readonly checksSpreads: true;
+        readonly checksVoidReturn: {
+            readonly arguments: true;
+            readonly attributes: true;
+            readonly properties: true;
+            readonly returns: true;
+            readonly variables: true;
+        };
+    }];
+    readonly "@typescript-eslint/no-mixed-enums": "error";
+    readonly "@typescript-eslint/no-namespace": "off";
+    readonly "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error";
+    readonly "@typescript-eslint/no-non-null-asserted-optional-chain": "error";
+    readonly "@typescript-eslint/no-non-null-assertion": "error";
+    readonly "@typescript-eslint/no-redundant-type-constituents": "error";
+    readonly "@typescript-eslint/no-restricted-types": "off";
+    readonly "@typescript-eslint/no-require-imports": readonly ["error", {
+        readonly allow: readonly [];
+    }];
+    readonly "@typescript-eslint/no-this-alias": readonly ["error", {
+        readonly allowDestructuring: true;
+        readonly allowedNames: readonly [];
+    }];
+    readonly "@typescript-eslint/no-unnecessary-boolean-literal-compare": readonly ["error", {
+        readonly allowComparingNullableBooleansToTrue: true;
+        readonly allowComparingNullableBooleansToFalse: true;
+    }];
+    readonly "@typescript-eslint/no-unnecessary-condition": readonly ["error", {
+        readonly allowConstantLoopConditions: false;
+        readonly allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false;
+    }];
+    readonly "@typescript-eslint/no-unnecessary-qualifier": "error";
+    readonly "@typescript-eslint/no-unnecessary-template-expression": "error";
+    readonly "@typescript-eslint/no-unnecessary-type-arguments": "error";
+    readonly "@typescript-eslint/no-unnecessary-type-assertion": readonly ["error", {
+        readonly typesToIgnore: readonly [];
+    }];
+    readonly "@typescript-eslint/no-unnecessary-type-constraint": "error";
+    readonly "@typescript-eslint/no-unnecessary-type-parameters": "error";
+    readonly "@typescript-eslint/no-unsafe-argument": "error";
+    readonly "@typescript-eslint/no-unsafe-assignment": "error";
+    readonly "@typescript-eslint/no-unsafe-call": "error";
+    readonly "@typescript-eslint/no-unsafe-declaration-merging": "error";
+    readonly "@typescript-eslint/no-unsafe-enum-comparison": "error";
+    readonly "@typescript-eslint/no-unsafe-function-type": "error";
+    readonly "@typescript-eslint/no-unsafe-member-access": "error";
+    readonly "@typescript-eslint/no-unsafe-return": "error";
+    readonly "@typescript-eslint/no-unsafe-unary-minus": "error";
+    readonly "@typescript-eslint/no-useless-empty-export": "error";
+    readonly "@typescript-eslint/no-wrapper-object-types": "error";
+    readonly "@typescript-eslint/non-nullable-type-assertion-style": "off";
+    readonly "@typescript-eslint/parameter-properties": readonly ["error", {
+        readonly prefer: "parameter-property";
+    }];
+    readonly "@typescript-eslint/prefer-as-const": "error";
+    readonly "@typescript-eslint/prefer-enum-initializers": "error";
+    readonly "@typescript-eslint/prefer-find": "error";
+    readonly "@typescript-eslint/prefer-for-of": "error";
+    readonly "@typescript-eslint/prefer-function-type": "error";
+    readonly "@typescript-eslint/prefer-includes": "error";
+    readonly "@typescript-eslint/prefer-literal-enum-member": readonly ["error", {
+        readonly allowBitwiseExpressions: false;
+    }];
+    readonly "@typescript-eslint/prefer-namespace-keyword": "error";
+    readonly "@typescript-eslint/prefer-nullish-coalescing": readonly ["error", {
+        readonly allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false;
+        readonly ignoreConditionalTests: false;
+        readonly ignoreTernaryTests: false;
+        readonly ignoreMixedLogicalExpressions: false;
+        readonly ignorePrimitives: {
+            readonly bigint: false;
+            readonly boolean: false;
+            readonly number: false;
+            readonly string: false;
+        };
+    }];
+    readonly "@typescript-eslint/prefer-optional-chain": readonly ["error", {
+        readonly allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false;
+        readonly checkAny: true;
+        readonly checkBigInt: true;
+        readonly checkBoolean: true;
+        readonly checkNumber: true;
+        readonly checkString: true;
+        readonly checkUnknown: true;
+        readonly requireNullish: false;
+    }];
+    readonly "@typescript-eslint/prefer-readonly": readonly ["error", {
+        readonly onlyInlineLambdas: false;
+    }];
+    readonly "@typescript-eslint/prefer-readonly-parameter-types": "off";
+    readonly "@typescript-eslint/prefer-reduce-type-parameter": "error";
+    readonly "@typescript-eslint/prefer-regexp-exec": "error";
+    readonly "@typescript-eslint/prefer-return-this-type": "error";
+    readonly "@typescript-eslint/prefer-string-starts-ends-with": readonly ["error", {
+        readonly allowSingleElementEquality: "never";
+    }];
+    readonly "@typescript-eslint/promise-function-async": readonly ["error", {
+        readonly allowAny: false;
+        readonly allowedPromiseNames: readonly [];
+        readonly checkArrowFunctions: true;
+        readonly checkFunctionDeclarations: true;
+        readonly checkFunctionExpressions: true;
+        readonly checkMethodDeclarations: true;
+    }];
+    readonly "@typescript-eslint/require-array-sort-compare": readonly ["error", {
+        readonly ignoreStringArrays: true;
+    }];
+    readonly "@typescript-eslint/restrict-plus-operands": readonly ["error", {
+        readonly allowAny: false;
+        readonly allowBoolean: false;
+        readonly allowNullish: false;
+        readonly allowNumberAndString: false;
+        readonly allowRegExp: false;
+        readonly skipCompoundAssignments: false;
+    }];
+    readonly "@typescript-eslint/restrict-template-expressions": readonly ["error", {
+        readonly allowAny: true;
+        readonly allowArray: true;
+        readonly allowBoolean: true;
+        readonly allowNullish: false;
+        readonly allowNumber: true;
+        readonly allowNever: false;
+        readonly allowRegExp: false;
+    }];
+    readonly "@typescript-eslint/return-await": readonly ["error", "in-try-catch"];
+    readonly "@typescript-eslint/strict-boolean-expressions": readonly ["error", {
+        readonly allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false;
+        readonly allowAny: false;
+        readonly allowNumber: true;
+        readonly allowString: false;
+        readonly allowNullableBoolean: false;
+        readonly allowNullableEnum: false;
+        readonly allowNullableNumber: false;
+        readonly allowNullableObject: false;
+        readonly allowNullableString: false;
+    }];
+    readonly "@typescript-eslint/switch-exhaustiveness-check": readonly ["error", {
+        readonly allowDefaultCaseForExhaustiveSwitch: false;
+        readonly requireDefaultForNonUnion: true;
+    }];
+    readonly "@typescript-eslint/triple-slash-reference": readonly ["error", {
+        readonly lib: "never";
+        readonly path: "never";
+        readonly types: "never";
+    }];
+    readonly "@typescript-eslint/typedef": "off";
+    readonly "@typescript-eslint/unbound-method": readonly ["error", {
+        readonly ignoreStatic: false;
+    }];
+    readonly "@typescript-eslint/unified-signatures": readonly ["error", {
+        readonly ignoreDifferentlyNamedParameters: false;
+    }];
+    readonly "@typescript-eslint/use-unknown-in-catch-callback-variable": "error";
+}];
+export default _default;
+//# sourceMappingURL=_enable.d.ts.map

package/dist/rules/ts/_enable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_enable.d.ts","sourceRoot":"","sources":["../../../src/rules/ts/_enable.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,wBA8YW"}

package/dist/rules/ts/_enable.js

@@ -0,0 +1,359 @@
+import { id, level, state } from "../_strings.js";
+const { enable } = id, { ERROR, OFF } = level, { Never, Explicit } = state;
+export default [
+    enable,
+    {
+        "@typescript-eslint/adjacent-overload-signatures": OFF,
+        "@typescript-eslint/array-type": [ERROR, { "default": "array", readonly: "array" }],
+        "@typescript-eslint/await-thenable": ERROR,
+        "@typescript-eslint/ban-ts-comment": [
+            ERROR,
+            {
+                "ts-check": false,
+                "ts-expect-error": { descriptionFormat: "^: BUG: .+$" },
+                "ts-ignore": true,
+                "ts-nocheck": true,
+                minimumDescriptionLength: 32,
+            },
+        ],
+        "@typescript-eslint/ban-tslint-comment": ERROR,
+        "@typescript-eslint/class-literal-property-style": [ERROR, "fields"],
+        "@typescript-eslint/consistent-generic-constructors": [ERROR, "constructor"],
+        "@typescript-eslint/consistent-indexed-object-style": [ERROR, "record"],
+        "@typescript-eslint/consistent-type-assertions": [ERROR, { assertionStyle: "as", objectLiteralTypeAssertions: Never }],
+        "@typescript-eslint/consistent-type-definitions": OFF,
+        "@typescript-eslint/consistent-type-exports": [ERROR, { fixMixedExportsWithInlineTypeSpecifier: false }],
+        "@typescript-eslint/consistent-type-imports": [ERROR, { disallowTypeAnnotations: true, fixStyle: "separate-type-imports", prefer: "type-imports" }],
+        "@typescript-eslint/explicit-function-return-type": OFF,
+        "@typescript-eslint/explicit-member-accessibility": [
+            ERROR,
+            {
+                accessibility: Explicit,
+                ignoredMethodNames: [],
+                overrides: {
+                    properties: Explicit,
+                    constructors: "no-public",
+                    accessors: Explicit,
+                    methods: Explicit,
+                    parameterProperties: Explicit,
+                },
+            },
+        ],
+        "@typescript-eslint/explicit-module-boundary-types": OFF,
+        "@typescript-eslint/member-ordering": [
+            ERROR,
+            {
+                "default": {
+                    memberTypes: [
+                        "signature",
+                        "call-signature",
+                        "public-static-field",
+                        "protected-static-field",
+                        "private-static-field",
+                        "#private-static-field",
+                        "public-decorated-field",
+                        "protected-decorated-field",
+                        "private-decorated-field",
+                        "public-instance-field",
+                        "protected-instance-field",
+                        "private-instance-field",
+                        "#private-instance-field",
+                        "public-abstract-field",
+                        "protected-abstract-field",
+                        "public-field",
+                        "protected-field",
+                        "private-field",
+                        "#private-field",
+                        "static-field",
+                        "instance-field",
+                        "abstract-field",
+                        "decorated-field",
+                        "field",
+                        "static-initialization",
+                        "public-constructor",
+                        "protected-constructor",
+                        "private-constructor",
+                        "constructor",
+                        "public-static-accessor",
+                        "protected-static-accessor",
+                        "private-static-accessor",
+                        "#private-static-accessor",
+                        "public-decorated-accessor",
+                        "protected-decorated-accessor",
+                        "private-decorated-accessor",
+                        "public-instance-accessor",
+                        "protected-instance-accessor",
+                        "private-instance-accessor",
+                        "#private-instance-accessor",
+                        "public-abstract-accessor",
+                        "protected-abstract-accessor",
+                        "public-accessor",
+                        "protected-accessor",
+                        "private-accessor",
+                        "#private-accessor",
+                        "static-accessor",
+                        "instance-accessor",
+                        "abstract-accessor",
+                        "decorated-accessor",
+                        "accessor",
+                        "public-static-get",
+                        "protected-static-get",
+                        "private-static-get",
+                        "#private-static-get",
+                        "public-decorated-get",
+                        "protected-decorated-get",
+                        "private-decorated-get",
+                        "public-instance-get",
+                        "protected-instance-get",
+                        "private-instance-get",
+                        "#private-instance-get",
+                        "public-abstract-get",
+                        "protected-abstract-get",
+                        "public-get",
+                        "protected-get",
+                        "private-get",
+                        "#private-get",
+                        "static-get",
+                        "instance-get",
+                        "abstract-get",
+                        "decorated-get",
+                        "get",
+                        "public-static-set",
+                        "protected-static-set",
+                        "private-static-set",
+                        "#private-static-set",
+                        "public-decorated-set",
+                        "protected-decorated-set",
+                        "private-decorated-set",
+                        "public-instance-set",
+                        "protected-instance-set",
+                        "private-instance-set",
+                        "#private-instance-set",
+                        "public-abstract-set",
+                        "protected-abstract-set",
+                        "public-set",
+                        "protected-set",
+                        "private-set",
+                        "#private-set",
+                        "static-set",
+                        "instance-set",
+                        "abstract-set",
+                        "decorated-set",
+                        "set",
+                        "public-static-method",
+                        "protected-static-method",
+                        "private-static-method",
+                        "#private-static-method",
+                        "public-decorated-method",
+                        "protected-decorated-method",
+                        "private-decorated-method",
+                        "public-instance-method",
+                        "protected-instance-method",
+                        "private-instance-method",
+                        "#private-instance-method",
+                        "public-abstract-method",
+                        "protected-abstract-method",
+                        "public-method",
+                        "protected-method",
+                        "private-method",
+                        "#private-method",
+                        "static-method",
+                        "instance-method",
+                        "abstract-method",
+                        "decorated-method",
+                        "method",
+                    ],
+                    optionalityOrder: "required-first",
+                    order: "as-written",
+                },
+            },
+        ],
+        "@typescript-eslint/method-signature-style": [ERROR, "property"],
+        "@typescript-eslint/naming-convention": OFF,
+        "@typescript-eslint/no-array-delete": ERROR,
+        "@typescript-eslint/no-base-to-string": [
+            ERROR,
+            {
+                ignoredTypeNames: [
+                    "Error",
+                    "RegExp",
+                    "URL",
+                    "URLSearchParams",
+                ],
+            },
+        ],
+        "@typescript-eslint/no-confusing-non-null-assertion": ERROR,
+        "@typescript-eslint/no-confusing-void-expression": [ERROR, { ignoreArrowShorthand: true, ignoreVoidOperator: true }],
+        "@typescript-eslint/no-duplicate-enum-values": ERROR,
+        "@typescript-eslint/no-duplicate-type-constituents": [ERROR, { ignoreIntersections: false, ignoreUnions: false }],
+        "@typescript-eslint/no-dynamic-delete": ERROR,
+        "@typescript-eslint/no-empty-object-type": [
+            ERROR,
+            {
+                allowInterfaces: Never,
+                allowObjectTypes: Never,
+            },
+        ],
+        "@typescript-eslint/no-explicit-any": [ERROR, { fixToUnknown: true, ignoreRestArgs: false }],
+        "@typescript-eslint/no-extra-non-null-assertion": ERROR,
+        "@typescript-eslint/no-extraneous-class": [
+            ERROR,
+            {
+                allowConstructorOnly: false,
+                allowEmpty: true,
+                allowStaticOnly: false,
+                allowWithDecorator: false,
+            },
+        ],
+        "@typescript-eslint/no-floating-promises": [ERROR, { checkThenables: true, ignoreVoid: true, ignoreIIFE: false }],
+        "@typescript-eslint/no-for-in-array": ERROR,
+        "@typescript-eslint/no-import-type-side-effects": ERROR,
+        "@typescript-eslint/no-inferrable-types": [ERROR, { ignoreParameters: false, ignoreProperties: false }],
+        "@typescript-eslint/no-invalid-void-type": [ERROR, { allowInGenericTypeArguments: true, allowAsThisParameter: false }],
+        "@typescript-eslint/no-meaningless-void-operator": [ERROR, { checkNever: true }],
+        "@typescript-eslint/no-misused-new": ERROR,
+        "@typescript-eslint/no-misused-promises": [
+            ERROR,
+            {
+                checksConditionals: true,
+                checksSpreads: true,
+                checksVoidReturn: {
+                    arguments: true,
+                    attributes: true,
+                    properties: true,
+                    returns: true,
+                    variables: true,
+                },
+            },
+        ],
+        "@typescript-eslint/no-mixed-enums": ERROR,
+        "@typescript-eslint/no-namespace": OFF,
+        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": ERROR,
+        "@typescript-eslint/no-non-null-asserted-optional-chain": ERROR,
+        "@typescript-eslint/no-non-null-assertion": ERROR,
+        "@typescript-eslint/no-redundant-type-constituents": ERROR,
+        "@typescript-eslint/no-restricted-types": OFF,
+        "@typescript-eslint/no-require-imports": [ERROR, { allow: [] }],
+        "@typescript-eslint/no-this-alias": [ERROR, { allowDestructuring: true, allowedNames: [] }],
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": [ERROR, { allowComparingNullableBooleansToTrue: true, allowComparingNullableBooleansToFalse: true }],
+        "@typescript-eslint/no-unnecessary-condition": [ERROR, { allowConstantLoopConditions: false, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false }],
+        "@typescript-eslint/no-unnecessary-qualifier": ERROR,
+        "@typescript-eslint/no-unnecessary-template-expression": ERROR,
+        "@typescript-eslint/no-unnecessary-type-arguments": ERROR,
+        "@typescript-eslint/no-unnecessary-type-assertion": [ERROR, { typesToIgnore: [] }],
+        "@typescript-eslint/no-unnecessary-type-constraint": ERROR,
+        "@typescript-eslint/no-unnecessary-type-parameters": ERROR,
+        "@typescript-eslint/no-unsafe-argument": ERROR,
+        "@typescript-eslint/no-unsafe-assignment": ERROR,
+        "@typescript-eslint/no-unsafe-call": ERROR,
+        "@typescript-eslint/no-unsafe-declaration-merging": ERROR,
+        "@typescript-eslint/no-unsafe-enum-comparison": ERROR,
+        "@typescript-eslint/no-unsafe-function-type": ERROR,
+        "@typescript-eslint/no-unsafe-member-access": ERROR,
+        "@typescript-eslint/no-unsafe-return": ERROR,
+        "@typescript-eslint/no-unsafe-unary-minus": ERROR,
+        "@typescript-eslint/no-useless-empty-export": ERROR,
+        "@typescript-eslint/no-wrapper-object-types": ERROR,
+        "@typescript-eslint/non-nullable-type-assertion-style": OFF,
+        "@typescript-eslint/parameter-properties": [ERROR, { prefer: "parameter-property" }],
+        "@typescript-eslint/prefer-as-const": ERROR,
+        "@typescript-eslint/prefer-enum-initializers": ERROR,
+        "@typescript-eslint/prefer-find": ERROR,
+        "@typescript-eslint/prefer-for-of": ERROR,
+        "@typescript-eslint/prefer-function-type": ERROR,
+        "@typescript-eslint/prefer-includes": ERROR,
+        "@typescript-eslint/prefer-literal-enum-member": [ERROR, { allowBitwiseExpressions: false }],
+        "@typescript-eslint/prefer-namespace-keyword": ERROR,
+        "@typescript-eslint/prefer-nullish-coalescing": [
+            ERROR,
+            {
+                allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+                ignoreConditionalTests: false,
+                ignoreTernaryTests: false,
+                ignoreMixedLogicalExpressions: false,
+                ignorePrimitives: {
+                    bigint: false,
+                    "boolean": false,
+                    number: false,
+                    string: false,
+                },
+            },
+        ],
+        "@typescript-eslint/prefer-optional-chain": [
+            ERROR,
+            {
+                allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+                checkAny: true,
+                checkBigInt: true,
+                checkBoolean: true,
+                checkNumber: true,
+                checkString: true,
+                checkUnknown: true,
+                requireNullish: false,
+            },
+        ],
+        "@typescript-eslint/prefer-readonly": [ERROR, { onlyInlineLambdas: false }],
+        "@typescript-eslint/prefer-readonly-parameter-types": OFF,
+        "@typescript-eslint/prefer-reduce-type-parameter": ERROR,
+        "@typescript-eslint/prefer-regexp-exec": ERROR,
+        "@typescript-eslint/prefer-return-this-type": ERROR,
+        "@typescript-eslint/prefer-string-starts-ends-with": [ERROR, { allowSingleElementEquality: Never }],
+        "@typescript-eslint/promise-function-async": [
+            ERROR,
+            {
+                allowAny: false,
+                allowedPromiseNames: [],
+                checkArrowFunctions: true,
+                checkFunctionDeclarations: true,
+                checkFunctionExpressions: true,
+                checkMethodDeclarations: true,
+            },
+        ],
+        "@typescript-eslint/require-array-sort-compare": [ERROR, { ignoreStringArrays: true }],
+        "@typescript-eslint/restrict-plus-operands": [
+            ERROR,
+            {
+                allowAny: false,
+                allowBoolean: false,
+                allowNullish: false,
+                allowNumberAndString: false,
+                allowRegExp: false,
+                skipCompoundAssignments: false,
+            },
+        ],
+        "@typescript-eslint/restrict-template-expressions": [
+            ERROR,
+            {
+                allowAny: true,
+                allowArray: true,
+                allowBoolean: true,
+                allowNullish: false,
+                allowNumber: true,
+                allowNever: false,
+                allowRegExp: false,
+            },
+        ],
+        "@typescript-eslint/return-await": [ERROR, "in-try-catch"],
+        "@typescript-eslint/strict-boolean-expressions": [
+            ERROR,
+            {
+                allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+                allowAny: false,
+                allowNumber: true,
+                allowString: false,
+                allowNullableBoolean: false,
+                allowNullableEnum: false,
+                allowNullableNumber: false,
+                allowNullableObject: false,
+                allowNullableString: false,
+            },
+        ],
+        "@typescript-eslint/switch-exhaustiveness-check": [ERROR, { allowDefaultCaseForExhaustiveSwitch: false, requireDefaultForNonUnion: true }],
+        "@typescript-eslint/triple-slash-reference": [ERROR, { lib: Never, path: Never, types: Never }],
+        "@typescript-eslint/typedef": OFF,
+        "@typescript-eslint/unbound-method": [ERROR, { ignoreStatic: false }],
+        "@typescript-eslint/unified-signatures": [ERROR, { ignoreDifferentlyNamedParameters: false }],
+        "@typescript-eslint/use-unknown-in-catch-callback-variable": ERROR,
+    },
+];
+//# sourceMappingURL=_enable.js.map