eslint-plugin-rxjs-x 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,16 +1,11 @@
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { stripIndent } from 'common-tags';
-import * as tsutils from 'ts-api-utils';
-import * as ts from 'typescript';
-import { DefinitionType } from '@typescript-eslint/scope-manager';
-import decamelize from 'decamelize';
+// package.json
+var name = "eslint-plugin-rxjs-x";
+var version = "0.2.0";
 
-const name = "eslint-plugin-rxjs-x";
-const version = "0.1.0";
-
-const createRecommendedConfig = (plugin) => ({
+// src/configs/recommended.ts
+var createRecommendedConfig = (plugin2) => ({
   plugins: {
-    "rxjs-x": plugin
+    "rxjs-x": plugin2
   },
   rules: {
     "rxjs-x/no-async-subscribe": "error",
@@ -31,8 +26,14 @@ const createRecommendedConfig = (plugin) => ({
   }
 });
 
+// src/rules/ban-observables.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { stripIndent } from "common-tags";
+
+// src/utils.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
 function createRegExpForWords(config) {
-  if (!config?.length) {
+  if (!(config == null ? void 0 : config.length)) {
     return void 0;
   }
   const flags = "i";
@@ -46,16 +47,17 @@ function createRegExpForWords(config) {
 function escapeRegExp(text) {
   return text.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-const ruleCreator = ESLintUtils.RuleCreator(
-  (name) => `https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/docs/rules/${name}.md`
+var ruleCreator = ESLintUtils.RuleCreator(
+  (name2) => `https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/docs/rules/${name2}.md`
 );
 
-const defaultOptions$c = [];
-const banObservablesRule = ruleCreator({
-  defaultOptions: defaultOptions$c,
+// src/rules/ban-observables.ts
+var defaultOptions = [];
+var banObservablesRule = ruleCreator({
+  defaultOptions,
   meta: {
     docs: {
-      description: "Forbids the use of banned observables."
+      description: "Disallow banned observable creators."
     },
     messages: {
       forbidden: "RxJS observable is banned: {{name}}{{explanation}}."
@@ -85,14 +87,14 @@ const banObservablesRule = ruleCreator({
         });
       }
     });
-    function getFailure(name) {
+    function getFailure(name2) {
       for (let b = 0, length = bans.length; b < length; ++b) {
         const ban = bans[b];
-        if (ban.regExp.test(name)) {
+        if (ban.regExp.test(name2)) {
           const explanation = ban.explanation ? `: ${ban.explanation}` : "";
           return {
             messageId: "forbidden",
-            data: { name, explanation }
+            data: { name: name2, explanation }
           };
         }
       }
@@ -101,8 +103,8 @@ const banObservablesRule = ruleCreator({
     return {
       "ImportDeclaration[source.value='rxjs'] > ImportSpecifier": (node) => {
         const identifier = node.imported;
-        const name = identifier.type === AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name);
+        const name2 = identifier.type === AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
         if (failure) {
           context.report({
             ...failure,
@@ -114,12 +116,15 @@ const banObservablesRule = ruleCreator({
   }
 });
 
-const defaultOptions$b = [];
-const banOperatorsRule = ruleCreator({
-  defaultOptions: defaultOptions$b,
+// src/rules/ban-operators.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+import { stripIndent as stripIndent2 } from "common-tags";
+var defaultOptions2 = [];
+var banOperatorsRule = ruleCreator({
+  defaultOptions: defaultOptions2,
   meta: {
     docs: {
-      description: "Forbids the use of banned operators."
+      description: "Disallow banned operators."
     },
     messages: {
       forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
@@ -127,7 +132,7 @@ const banOperatorsRule = ruleCreator({
     schema: [
       {
         type: "object",
-        description: stripIndent`
+        description: stripIndent2`
           An object containing keys that are names of operators
           and values that are either booleans or strings containing the explanation for the ban.`
       }
@@ -149,14 +154,14 @@ const banOperatorsRule = ruleCreator({
         });
       }
     });
-    function getFailure(name) {
+    function getFailure(name2) {
       for (let b = 0, length = bans.length; b < length; ++b) {
         const ban = bans[b];
-        if (ban.regExp.test(name)) {
+        if (ban.regExp.test(name2)) {
           const explanation = ban.explanation ? `: ${ban.explanation}` : "";
           return {
             messageId: "forbidden",
-            data: { name, explanation }
+            data: { name: name2, explanation }
           };
         }
       }
@@ -165,8 +170,8 @@ const banOperatorsRule = ruleCreator({
     return {
       [String.raw`ImportDeclaration[source.value=/^rxjs\u002foperators$/] > ImportSpecifier`]: (node) => {
         const identifier = node.imported;
-        const name = identifier.type === AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name);
+        const name2 = identifier.type === AST_NODE_TYPES2.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
         if (failure) {
           context.report({
             ...failure,
@@ -178,26 +183,35 @@ const banOperatorsRule = ruleCreator({
   }
 });
 
-function couldBeType(type, name, qualified) {
+// src/rules/finnish.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+
+// src/etc/could-be-function.ts
+import * as ts2 from "typescript";
+
+// src/etc/could-be-type.ts
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+function couldBeType(type, name2, qualified) {
   if (tsutils.isTypeReference(type)) {
     type = type.target;
   }
-  if (isType(type, name, qualified)) {
+  if (isType(type, name2, qualified)) {
     return true;
   }
   if (tsutils.isUnionOrIntersectionType(type)) {
-    return type.types.some((t) => couldBeType(t, name, qualified));
+    return type.types.some((t) => couldBeType(t, name2, qualified));
   }
   const baseTypes = type.getBaseTypes();
-  if (baseTypes?.some((t) => couldBeType(t, name, qualified))) {
+  if (baseTypes == null ? void 0 : baseTypes.some((t) => couldBeType(t, name2, qualified))) {
     return true;
   }
-  if (couldImplement(type, name, qualified)) {
+  if (couldImplement(type, name2, qualified)) {
     return true;
   }
   return false;
 }
-function isType(type, name, qualified) {
+function isType(type, name2, qualified) {
   if (!type.symbol) {
     return false;
   }
@@ -206,9 +220,9 @@ function isType(type, name, qualified) {
   )) {
     return false;
   }
-  return typeof name === "string" ? type.symbol.name === name : Boolean(type.symbol.name.match(name));
+  return typeof name2 === "string" ? type.symbol.name === name2 : Boolean(type.symbol.name.match(name2));
 }
-function couldImplement(type, name, qualified) {
+function couldImplement(type, name2, qualified) {
   const { symbol } = type;
   if (symbol) {
     const { valueDeclaration } = symbol;
@@ -216,7 +230,7 @@ function couldImplement(type, name, qualified) {
       const { heritageClauses } = valueDeclaration;
       if (heritageClauses) {
         const implemented = heritageClauses.some(
-          ({ token, types }) => token === ts.SyntaxKind.ImplementsKeyword && types.some((node) => isMatchingNode(node, name, qualified))
+          ({ token, types }) => token === ts.SyntaxKind.ImplementsKeyword && types.some((node) => isMatchingNode(node, name2, qualified))
         );
         if (implemented) {
           return true;
@@ -226,7 +240,7 @@ function couldImplement(type, name, qualified) {
   }
   return false;
 }
-function isMatchingNode(node, name, qualified) {
+function isMatchingNode(node, name2, qualified) {
   const { expression } = node;
   if (qualified) {
     const type = qualified.typeChecker.getTypeAtLocation(expression);
@@ -240,13 +254,15 @@ function isMatchingNode(node, name, qualified) {
     }
   }
   const text = expression.getText();
-  return typeof name === "string" ? text === name : Boolean(text.match(name));
+  return typeof name2 === "string" ? text === name2 : Boolean(text.match(name2));
 }
 
+// src/etc/could-be-function.ts
 function couldBeFunction(type) {
-  return type.getCallSignatures().length > 0 || couldBeType(type, "Function") || couldBeType(type, "ArrowFunction") || couldBeType(type, ts.InternalSymbolName.Function);
+  return type.getCallSignatures().length > 0 || couldBeType(type, "Function") || couldBeType(type, "ArrowFunction") || couldBeType(type, ts2.InternalSymbolName.Function);
 }
 
+// src/etc/find-parent.ts
 function findParent(node, ...args) {
   const [arg] = args;
   const predicate = typeof arg === "function" ? arg : (type) => !args.includes(type) ? "continue" : "return";
@@ -257,16 +273,20 @@ function findParent(node, ...args) {
         return void 0;
       case "return":
         return parent;
+      default:
+        break;
     }
     parent = parent.parent;
   }
   return void 0;
 }
 
+// src/etc/get-loc.ts
+import * as ts3 from "typescript";
 function getLoc(node) {
   const sourceFile = node.getSourceFile();
-  const start = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart());
-  const end = ts.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
+  const start = ts3.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+  const end = ts3.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
   return {
     start: {
       line: start.line + 1,
@@ -279,76 +299,85 @@ function getLoc(node) {
   };
 }
 
+// src/etc/get-type-services.ts
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+import * as tsutils2 from "ts-api-utils";
+import * as ts4 from "typescript";
+
+// src/etc/is.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 function hasTypeAnnotation(node) {
   return "typeAnnotation" in node && !!node.typeAnnotation;
 }
 function isArrayExpression(node) {
-  return node.type === AST_NODE_TYPES.ArrayExpression;
+  return node.type === AST_NODE_TYPES3.ArrayExpression;
 }
 function isArrayPattern(node) {
-  return node.type === AST_NODE_TYPES.ArrayPattern;
+  return node.type === AST_NODE_TYPES3.ArrayPattern;
 }
 function isArrowFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES.ArrowFunctionExpression;
+  return node.type === AST_NODE_TYPES3.ArrowFunctionExpression;
 }
 function isBlockStatement(node) {
-  return node.type === AST_NODE_TYPES.BlockStatement;
+  return node.type === AST_NODE_TYPES3.BlockStatement;
 }
 function isCallExpression(node) {
-  return node.type === AST_NODE_TYPES.CallExpression;
+  return node.type === AST_NODE_TYPES3.CallExpression;
 }
 function isFunctionDeclaration(node) {
-  return node.type === AST_NODE_TYPES.FunctionDeclaration;
+  return node.type === AST_NODE_TYPES3.FunctionDeclaration;
 }
 function isFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES.FunctionExpression;
+  return node.type === AST_NODE_TYPES3.FunctionExpression;
 }
 function isIdentifier(node) {
-  return node.type === AST_NODE_TYPES.Identifier;
+  return node.type === AST_NODE_TYPES3.Identifier;
 }
 function isLiteral(node) {
-  return node.type === AST_NODE_TYPES.Literal;
+  return node.type === AST_NODE_TYPES3.Literal;
 }
 function isMemberExpression(node) {
-  return node.type === AST_NODE_TYPES.MemberExpression;
+  return node.type === AST_NODE_TYPES3.MemberExpression;
 }
 function isObjectExpression(node) {
-  return node.type === AST_NODE_TYPES.ObjectExpression;
+  return node.type === AST_NODE_TYPES3.ObjectExpression;
 }
 function isObjectPattern(node) {
-  return node.type === AST_NODE_TYPES.ObjectPattern;
+  return node.type === AST_NODE_TYPES3.ObjectPattern;
 }
 function isProgram(node) {
-  return node.type === AST_NODE_TYPES.Program;
+  return node.type === AST_NODE_TYPES3.Program;
 }
 function isProperty(node) {
-  return node.type === AST_NODE_TYPES.Property;
+  return node.type === AST_NODE_TYPES3.Property;
 }
 
+// src/etc/get-type-services.ts
 function getTypeServices(context) {
-  const services = ESLintUtils.getParserServices(context);
+  const services = ESLintUtils2.getParserServices(context);
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
-  const couldBeType$1 = (node, name, qualified) => {
+  const couldBeType2 = (node, name2, qualified) => {
     const type = getType(node);
     return couldBeType(
       type,
-      name,
+      name2,
       qualified ? { ...qualified, typeChecker } : void 0
     );
   };
-  const couldReturnType = (node, name, qualified) => {
+  const couldReturnType = (node, name2, qualified) => {
+    var _a;
     let tsTypeNode;
     const tsNode = esTreeNodeToTSNodeMap.get(node);
-    if (ts.isArrowFunction(tsNode) || ts.isFunctionDeclaration(tsNode) || ts.isMethodDeclaration(tsNode) || ts.isFunctionExpression(tsNode)) {
-      tsTypeNode = tsNode.type ?? tsNode.body;
-    } else if (ts.isCallSignatureDeclaration(tsNode) || ts.isMethodSignature(tsNode)) {
+    if (ts4.isArrowFunction(tsNode) || ts4.isFunctionDeclaration(tsNode) || ts4.isMethodDeclaration(tsNode) || ts4.isFunctionExpression(tsNode)) {
+      tsTypeNode = (_a = tsNode.type) != null ? _a : tsNode.body;
+    } else if (ts4.isCallSignatureDeclaration(tsNode) || ts4.isMethodSignature(tsNode)) {
       tsTypeNode = tsNode.type;
     }
     return Boolean(
       tsTypeNode && couldBeType(
         typeChecker.getTypeAtLocation(tsTypeNode),
-        name,
+        name2,
         qualified ? { ...qualified, typeChecker } : void 0
       )
     );
@@ -357,45 +386,49 @@ function getTypeServices(context) {
     return getTypeAtLocation(node);
   };
   return {
-    couldBeBehaviorSubject: (node) => couldBeType$1(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType$1(node, "Error"),
+    couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
+    couldBeError: (node) => couldBeType2(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
       return couldBeFunction(getType(node));
     },
-    couldBeMonoTypeOperatorFunction: (node) => couldBeType$1(node, "MonoTypeOperatorFunction"),
-    couldBeObservable: (node) => couldBeType$1(node, "Observable"),
-    couldBeSubject: (node) => couldBeType$1(node, "Subject"),
-    couldBeSubscription: (node) => couldBeType$1(node, "Subscription"),
-    couldBeType: couldBeType$1,
+    couldBeMonoTypeOperatorFunction: (node) => couldBeType2(node, "MonoTypeOperatorFunction"),
+    couldBeObservable: (node) => couldBeType2(node, "Observable"),
+    couldBeSubject: (node) => couldBeType2(node, "Subject"),
+    couldBeSubscription: (node) => couldBeType2(node, "Subscription"),
+    couldBeType: couldBeType2,
     couldReturnObservable: (node) => couldReturnType(node, "Observable"),
     couldReturnType,
     getType,
-    isAny: (node) => tsutils.isIntrinsicAnyType(getType(node)),
-    isReferenceType: (node) => tsutils.isTypeReference(getType(node)),
-    isUnknown: (node) => tsutils.isIntrinsicUnknownType(getType(node)),
+    isAny: (node) => tsutils2.isIntrinsicAnyType(getType(node)),
+    isReferenceType: (node) => tsutils2.isTypeReference(getType(node)),
+    isUnknown: (node) => tsutils2.isIntrinsicUnknownType(getType(node)),
     typeChecker
   };
 }
 
-function isImport(scope, name, source) {
-  const variable = scope.variables.find((variable2) => variable2.name === name);
+// src/etc/is-import.ts
+import { DefinitionType } from "@typescript-eslint/scope-manager";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+function isImport(scope, name2, source) {
+  const variable = scope.variables.find((variable2) => variable2.name === name2);
   if (variable) {
     return variable.defs.some(
-      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
+      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES4.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
     );
   }
-  return scope.upper ? isImport(scope.upper, name, source) : false;
+  return scope.upper ? isImport(scope.upper, name2, source) : false;
 }
 
-const defaultOptions$a = [];
-const finnishRule = ruleCreator({
-  defaultOptions: defaultOptions$a,
+// src/rules/finnish.ts
+var defaultOptions3 = [];
+var finnishRule = ruleCreator({
+  defaultOptions: defaultOptions3,
   meta: {
     docs: {
-      description: "Enforces the use of Finnish notation.",
+      description: "Enforce Finnish notation.",
       requiresTypeChecking: true
     },
     messages: {
@@ -405,14 +438,14 @@ const finnishRule = ruleCreator({
     schema: [
       {
         properties: {
-          functions: { type: "boolean" },
-          methods: { type: "boolean" },
-          names: { type: "object" },
-          parameters: { type: "boolean" },
-          properties: { type: "boolean" },
-          strict: { type: "boolean" },
-          types: { type: "object" },
-          variables: { type: "boolean" }
+          functions: { type: "boolean", description: "Require for functions." },
+          methods: { type: "boolean", description: "Require for methods." },
+          names: { type: "object", description: "Enforce for specific names. Keys are a RegExp, values are a boolean." },
+          parameters: { type: "boolean", description: "Require for parameters." },
+          properties: { type: "boolean", description: "Require for properties." },
+          strict: { type: "boolean", description: "Disallow Finnish notation for non-Observables." },
+          types: { type: "object", description: "Enforce for specific types. Keys are a RegExp, values are a boolean." },
+          variables: { type: "boolean", description: "Require for variables." }
         },
         type: "object"
       }
@@ -421,10 +454,10 @@ const finnishRule = ruleCreator({
   },
   name: "finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils3.getParserServices(context);
     const {
       couldBeObservable,
-      couldBeType,
+      couldBeType: couldBeType2,
       couldReturnObservable,
       couldReturnType
     } = getTypeServices(context);
@@ -486,8 +519,8 @@ const finnishRule = ruleCreator({
       } : () => {
       };
       if (couldBeObservable(typeNode || nameNode) || couldReturnObservable(typeNode || nameNode)) {
-        for (const name of names) {
-          const { regExp, validate: validate2 } = name;
+        for (const name2 of names) {
+          const { regExp, validate: validate2 } = name2;
           if (regExp.test(text) && !validate2) {
             shouldNotBeFinnish();
             return;
@@ -495,7 +528,7 @@ const finnishRule = ruleCreator({
         }
         for (const type of types) {
           const { regExp, validate: validate2 } = type;
-          if ((couldBeType(typeNode || nameNode, regExp) || couldReturnType(typeNode || nameNode, regExp)) && !validate2) {
+          if ((couldBeType2(typeNode || nameNode, regExp) || couldReturnType(typeNode || nameNode, regExp)) && !validate2) {
             shouldNotBeFinnish();
             return;
           }
@@ -517,7 +550,7 @@ const finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES5.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -596,7 +629,7 @@ const finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES5.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -647,11 +680,12 @@ const finnishRule = ruleCreator({
   }
 });
 
-const justRule = ruleCreator({
+// src/rules/just.ts
+var justRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Enforces the use of a `just` alias for `of`."
+      description: "Require the use of `just` instead of `of`."
     },
     fixable: "code",
     messages: {
@@ -685,11 +719,12 @@ const justRule = ruleCreator({
   }
 });
 
-const macroRule = ruleCreator({
+// src/rules/macro.ts
+var macroRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Enforces the use of the RxJS Tools Babel macro."
+      description: "Require the use of the RxJS Tools Babel macro."
     },
     fixable: "code",
     messages: {
@@ -744,11 +779,12 @@ const macroRule = ruleCreator({
   }
 });
 
-const noAsyncSubscribeRule = ruleCreator({
+// src/rules/no-async-subscribe.ts
+var noAsyncSubscribeRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids passing `async` functions to `subscribe`.",
+      description: "Disallow passing `async` functions to `subscribe`.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -786,11 +822,12 @@ const noAsyncSubscribeRule = ruleCreator({
   }
 });
 
-const noCompatRule = ruleCreator({
+// src/rules/no-compat.ts
+var noCompatRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids importation from locations that depend upon `rxjs-compat`."
+      description: "Disallow the `rxjs-compat` package."
     },
     messages: {
       forbidden: "'rxjs-compat'-dependent import locations are forbidden."
@@ -811,11 +848,12 @@ const noCompatRule = ruleCreator({
   }
 });
 
-const noConnectableRule = ruleCreator({
+// src/rules/no-connectable.ts
+var noConnectableRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids operators that return connectable observables.",
+      description: "Disallow operators that return connectable observables.",
       requiresTypeChecking: true
     },
     messages: {
@@ -826,7 +864,7 @@ const noConnectableRule = ruleCreator({
   },
   name: "no-connectable",
   create: (context) => {
-    const { couldBeFunction } = getTypeServices(context);
+    const { couldBeFunction: couldBeFunction2 } = getTypeServices(context);
     return {
       "CallExpression[callee.name='multicast']": (node) => {
         if (node.arguments.length === 1) {
@@ -837,7 +875,7 @@ const noConnectableRule = ruleCreator({
         }
       },
       "CallExpression[callee.name=/^(publish|publishBehavior|publishLast|publishReplay)$/]": (node) => {
-        if (!node.arguments.some((arg) => couldBeFunction(arg))) {
+        if (!node.arguments.some((arg) => couldBeFunction2(arg))) {
           context.report({
             messageId: "forbidden",
             node: node.callee
@@ -848,11 +886,12 @@ const noConnectableRule = ruleCreator({
   }
 });
 
-const noCreateRule = ruleCreator({
+// src/rules/no-create.ts
+var noCreateRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the calling of `Observable.create`.",
+      description: "Disallow the static `Observable.create` function.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -879,17 +918,23 @@ const noCreateRule = ruleCreator({
   }
 });
 
-const defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
+// src/rules/no-cyclic-action.ts
+import { stripIndent as stripIndent3 } from "common-tags";
+import * as ts5 from "typescript";
+
+// src/constants.ts
+var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
 
-function isTypeReference(type) {
+// src/rules/no-cyclic-action.ts
+function isTypeReference3(type) {
   return Boolean(type.target);
 }
-const defaultOptions$9 = [];
-const noCyclicActionRule = ruleCreator({
-  defaultOptions: defaultOptions$9,
+var defaultOptions4 = [];
+var noCyclicActionRule = ruleCreator({
+  defaultOptions: defaultOptions4,
   meta: {
     docs: {
-      description: "Forbids effects and epics that re-emit filtered actions.",
+      description: "Disallow cyclic actions in effects and epics.",
       requiresTypeChecking: true
     },
     messages: {
@@ -898,10 +943,10 @@ const noCyclicActionRule = ruleCreator({
     schema: [
       {
         properties: {
-          observable: { type: "string" }
+          observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
         },
         type: "object",
-        description: stripIndent`
+        description: stripIndent3`
           An optional object with an optional \`observable\` property.
           The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
       }
@@ -924,13 +969,13 @@ const noCyclicActionRule = ruleCreator({
       const operatorType = getType(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
-        ts.SignatureKind.Call
+        ts5.SignatureKind.Call
       );
       if (!signature) {
         return;
       }
       const operatorReturnType = typeChecker.getReturnTypeOfSignature(signature);
-      if (!isTypeReference(operatorReturnType)) {
+      if (!isTypeReference3(operatorReturnType)) {
         return;
       }
       const [operatorElementType] = typeChecker.getTypeArguments(operatorReturnType);
@@ -938,7 +983,7 @@ const noCyclicActionRule = ruleCreator({
         return;
       }
       const pipeType = getType(pipeCallExpression);
-      if (!isTypeReference(pipeType)) {
+      if (!isTypeReference3(pipeType)) {
         return;
       }
       const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
@@ -966,7 +1011,7 @@ const noCyclicActionRule = ruleCreator({
         return memberActionTypes;
       }
       const symbol = typeChecker.getPropertyOfType(type, "type");
-      if (!symbol?.valueDeclaration) {
+      if (!(symbol == null ? void 0 : symbol.valueDeclaration)) {
         return [];
       }
       const actionType = typeChecker.getTypeOfSymbolAtLocation(
@@ -982,11 +1027,12 @@ const noCyclicActionRule = ruleCreator({
   }
 });
 
-const noExplicitGenericsRule = ruleCreator({
+// src/rules/no-explicit-generics.ts
+var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids explicit generic type arguments."
+      description: "Disallow unnecessary explicit generic type arguments."
     },
     messages: {
       forbidden: "Explicit generic type arguments are forbidden."
@@ -1031,13 +1077,14 @@ const noExplicitGenericsRule = ruleCreator({
   }
 });
 
-const defaultAllowedTypesRegExp = /^EventEmitter$/;
-const defaultOptions$8 = [];
-const noExposedSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions$8,
+// src/rules/no-exposed-subjects.ts
+var defaultAllowedTypesRegExp = /^EventEmitter$/;
+var defaultOptions5 = [];
+var noExposedSubjectsRule = ruleCreator({
+  defaultOptions: defaultOptions5,
   meta: {
     docs: {
-      description: "Forbids exposed (i.e. non-private) subjects.",
+      description: "Disallow public and protected subjects.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1047,7 +1094,7 @@ const noExposedSubjectsRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowProtected: { type: "boolean" }
+          allowProtected: { type: "boolean", description: "Allow protected subjects.", default: false }
         },
         type: "object"
       }
@@ -1058,11 +1105,11 @@ const noExposedSubjectsRule = ruleCreator({
   create: (context) => {
     const [config = {}] = context.options;
     const { allowProtected = false } = config;
-    const { couldBeSubject, couldBeType } = getTypeServices(context);
+    const { couldBeSubject, couldBeType: couldBeType2 } = getTypeServices(context);
     const messageId = allowProtected ? "forbiddenAllowProtected" : "forbidden";
     const accessibilityRexExp = allowProtected ? /^(private|protected)$/ : /^private$/;
     function isSubject(node) {
-      return couldBeSubject(node) && !couldBeType(node, defaultAllowedTypesRegExp);
+      return couldBeSubject(node) && !couldBeType2(node, defaultAllowedTypesRegExp);
     }
     return {
       [`PropertyDefinition[accessibility!=${accessibilityRexExp}]`]: (node) => {
@@ -1134,11 +1181,13 @@ const noExposedSubjectsRule = ruleCreator({
   }
 });
 
-const noFinnishRule = ruleCreator({
+// src/rules/no-finnish.ts
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+var noFinnishRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the use of Finnish notation.",
+      description: "Disallow Finnish notation.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1149,7 +1198,7 @@ const noFinnishRule = ruleCreator({
   },
   name: "no-finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils4.getParserServices(context);
     const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
     function checkNode(nameNode, typeNode) {
       if (couldBeObservable(typeNode || nameNode) || couldReturnObservable(typeNode || nameNode)) {
@@ -1221,17 +1270,19 @@ const noFinnishRule = ruleCreator({
         }
       },
       "VariableDeclarator[id.name=/[$]+$/]": (node) => {
-        checkNode(node.id, node.init ?? node);
+        var _a;
+        checkNode(node.id, (_a = node.init) != null ? _a : node);
       }
     };
   }
 });
 
-const noIgnoredErrorRule = ruleCreator({
+// src/rules/no-ignored-error.ts
+var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the calling of `subscribe` without specifying an error handler.",
+      description: "Disallow calling `subscribe` without specifying an error handler.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1242,12 +1293,12 @@ const noIgnoredErrorRule = ruleCreator({
   },
   name: "no-ignored-error",
   create: (context) => {
-    const { couldBeObservable, couldBeFunction } = getTypeServices(context);
+    const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
     return {
       "CallExpression[arguments.length > 0] > MemberExpression > Identifier[name='subscribe']": (node) => {
         const memberExpression = node.parent;
         const callExpression = memberExpression.parent;
-        if (callExpression.arguments.length < 2 && couldBeObservable(memberExpression.object) && couldBeFunction(callExpression.arguments[0])) {
+        if (callExpression.arguments.length < 2 && couldBeObservable(memberExpression.object) && couldBeFunction2(callExpression.arguments[0])) {
           context.report({
             messageId: "forbidden",
             node
@@ -1258,11 +1309,12 @@ const noIgnoredErrorRule = ruleCreator({
   }
 });
 
-const noIgnoredNotifierRule = ruleCreator({
+// src/rules/no-ignored-notifier.ts
+var noIgnoredNotifierRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids observables not composed from the `repeatWhen` or `retryWhen` notifier.",
+      description: "Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -1329,11 +1381,12 @@ const noIgnoredNotifierRule = ruleCreator({
   }
 });
 
-const noIgnoredObservableRule = ruleCreator({
+// src/rules/no-ignored-observable.ts
+var noIgnoredObservableRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the ignoring of observables returned by functions.",
+      description: "Disallow ignoring observables returned by functions.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1358,11 +1411,12 @@ const noIgnoredObservableRule = ruleCreator({
   }
 });
 
-const noIgnoredReplayBufferRule = ruleCreator({
+// src/rules/no-ignored-replay-buffer.ts
+var noIgnoredReplayBufferRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.",
+      description: "Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.",
       recommended: true
     },
     messages: {
@@ -1399,11 +1453,12 @@ const noIgnoredReplayBufferRule = ruleCreator({
   }
 });
 
-const noIgnoredSubscribeRule = ruleCreator({
+// src/rules/no-ignored-subscribe.ts
+var noIgnoredSubscribeRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the calling of `subscribe` without specifying arguments.",
+      description: "Disallow calling `subscribe` without specifying arguments.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1414,11 +1469,11 @@ const noIgnoredSubscribeRule = ruleCreator({
   },
   name: "no-ignored-subscribe",
   create: (context) => {
-    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
     return {
       "CallExpression[arguments.length = 0][callee.property.name='subscribe']": (node) => {
         const callee = node.callee;
-        if (couldBeObservable(callee.object) || couldBeType(callee.object, "Subscribable")) {
+        if (couldBeObservable(callee.object) || couldBeType2(callee.object, "Subscribable")) {
           context.report({
             messageId: "forbidden",
             node: callee.property
@@ -1429,11 +1484,12 @@ const noIgnoredSubscribeRule = ruleCreator({
   }
 });
 
-const noIgnoredSubscriptionRule = ruleCreator({
+// src/rules/no-ignored-subscription.ts
+var noIgnoredSubscriptionRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids ignoring the subscription returned by `subscribe`.",
+      description: "Disallow ignoring the subscription returned by `subscribe`.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1444,12 +1500,12 @@ const noIgnoredSubscriptionRule = ruleCreator({
   },
   name: "no-ignored-subscription",
   create: (context) => {
-    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
     return {
       "ExpressionStatement > CallExpression > MemberExpression[property.name='subscribe']": (node) => {
         if (couldBeObservable(node.object)) {
           const callExpression = node.parent;
-          if (callExpression.arguments.length === 1 && couldBeType(callExpression.arguments[0], "Subscriber")) {
+          if (callExpression.arguments.length === 1 && couldBeType2(callExpression.arguments[0], "Subscriber")) {
             return;
           }
           context.report({
@@ -1462,11 +1518,12 @@ const noIgnoredSubscriptionRule = ruleCreator({
   }
 });
 
-const noIgnoredTakewhileValueRule = ruleCreator({
+// src/rules/no-ignored-takewhile-value.ts
+var noIgnoredTakewhileValueRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids ignoring the value within `takeWhile`.",
+      description: "Disallow ignoring the value within `takeWhile`.",
       recommended: true
     },
     messages: {
@@ -1487,7 +1544,7 @@ const noIgnoredTakewhileValueRule = ruleCreator({
       if (param) {
         if (isIdentifier(param)) {
           const variable = scope.variables.find(
-            ({ name }) => name === param.name
+            ({ name: name2 }) => name2 === param.name
           );
           if (variable && variable.references.length > 0) {
             ignored = false;
@@ -1516,17 +1573,21 @@ const noIgnoredTakewhileValueRule = ruleCreator({
   }
 });
 
+// src/rules/no-implicit-any-catch.ts
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES6
+} from "@typescript-eslint/utils";
 function isParenthesised(sourceCode, node) {
   const before = sourceCode.getTokenBefore(node);
   const after = sourceCode.getTokenAfter(node);
   return before && after && before.value === "(" && before.range[1] <= node.range[0] && after.value === ")" && after.range[0] >= node.range[1];
 }
-const defaultOptions$7 = [];
-const noImplicitAnyCatchRule = ruleCreator({
-  defaultOptions: defaultOptions$7,
+var defaultOptions6 = [];
+var noImplicitAnyCatchRule = ruleCreator({
+  defaultOptions: defaultOptions6,
   meta: {
     docs: {
-      description: "Forbids implicit `any` error parameters in `catchError` operators.",
+      description: "Disallow implicit `any` error parameters in `catchError` operators.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -1543,7 +1604,9 @@ const noImplicitAnyCatchRule = ruleCreator({
         additionalProperties: false,
         properties: {
           allowExplicitAny: {
-            type: "boolean"
+            type: "boolean",
+            description: "Allow error variable to be explicitly typed as `any`.",
+            default: false
           }
         },
         type: "object"
@@ -1568,41 +1631,43 @@ const noImplicitAnyCatchRule = ruleCreator({
           const {
             typeAnnotation: { type }
           } = typeAnnotation;
-          if (type === AST_NODE_TYPES.TSAnyKeyword) {
-            let fix = function(fixer) {
+          if (type === AST_NODE_TYPES6.TSAnyKeyword) {
+            let fix2 = function(fixer) {
               return fixer.replaceText(typeAnnotation, ": unknown");
             };
+            var fix = fix2;
             if (allowExplicitAny) {
               return;
             }
             context.report({
-              fix,
+              fix: fix2,
               messageId: "explicitAny",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix
+                  fix: fix2
                 }
               ]
             });
-          } else if (type !== AST_NODE_TYPES.TSUnknownKeyword) {
-            let fix = function(fixer) {
+          } else if (type !== AST_NODE_TYPES6.TSUnknownKeyword) {
+            let fix2 = function(fixer) {
               return fixer.replaceText(typeAnnotation, ": unknown");
             };
+            var fix = fix2;
             context.report({
               messageId: "narrowed",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix
+                  fix: fix2
                 }
               ]
             });
           }
         } else {
-          let fix = function(fixer) {
+          let fix2 = function(fixer) {
             if (isParenthesised(sourceCode, param)) {
               return fixer.insertTextAfter(param, ": unknown");
             }
@@ -1611,14 +1676,15 @@ const noImplicitAnyCatchRule = ruleCreator({
               fixer.insertTextAfter(param, ": unknown)")
             ];
           };
+          var fix = fix2;
           context.report({
-            fix,
+            fix: fix2,
             messageId: "implicitAny",
             node: param,
             suggest: [
               {
                 messageId: "suggestExplicitUnknown",
-                fix
+                fix: fix2
               }
             ]
           });
@@ -1654,11 +1720,12 @@ const noImplicitAnyCatchRule = ruleCreator({
   }
 });
 
-const noIndexRule = ruleCreator({
+// src/rules/no-index.ts
+var noIndexRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the importation from index modules.",
+      description: "Disallow importing index modules.",
       recommended: true
     },
     messages: {
@@ -1680,11 +1747,12 @@ const noIndexRule = ruleCreator({
   }
 });
 
-const noInternalRule = ruleCreator({
+// src/rules/no-internal.ts
+var noInternalRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the importation of internals.",
+      description: "Disallow importing internal modules.",
       recommended: true
     },
     fixable: "code",
@@ -1734,14 +1802,15 @@ const noInternalRule = ruleCreator({
       [String.raw`ImportDeclaration Literal[value=/^rxjs\u002finternal/]`]: (node) => {
         const replacement = getReplacement(node.raw);
         if (replacement) {
-          let fix = function(fixer) {
+          let fix2 = function(fixer) {
             return fixer.replaceText(node, replacement);
           };
+          var fix = fix2;
           context.report({
-            fix,
+            fix: fix2,
             messageId: "forbidden",
             node,
-            suggest: [{ fix, messageId: "suggest" }]
+            suggest: [{ fix: fix2, messageId: "suggest" }]
           });
         } else {
           context.report({
@@ -1754,11 +1823,12 @@ const noInternalRule = ruleCreator({
   }
 });
 
-const noNestedSubscribeRule = ruleCreator({
+// src/rules/no-nested-subscribe.ts
+var noNestedSubscribeRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the calling of `subscribe` within a `subscribe` callback.",
+      description: "Disallow calling `subscribe` within a `subscribe` callback.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -1770,11 +1840,11 @@ const noNestedSubscribeRule = ruleCreator({
   },
   name: "no-nested-subscribe",
   create: (context) => {
-    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
     const argumentsMap = /* @__PURE__ */ new WeakMap();
     return {
       [`CallExpression > MemberExpression[property.name='subscribe']`]: (node) => {
-        if (!couldBeObservable(node.object) && !couldBeType(node.object, "Subscribable")) {
+        if (!couldBeObservable(node.object) && !couldBeType2(node.object, "Subscribable")) {
           return;
         }
         const callExpression = node.parent;
@@ -1797,11 +1867,12 @@ const noNestedSubscribeRule = ruleCreator({
   }
 });
 
-const noRedundantNotifyRule = ruleCreator({
+// src/rules/no-redundant-notify.ts
+var noRedundantNotifyRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids redundant notifications from completed or errored observables.",
+      description: "Disallow sending redundant notifications from completed or errored observables.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -1814,7 +1885,7 @@ const noRedundantNotifyRule = ruleCreator({
   name: "no-redundant-notify",
   create: (context) => {
     const sourceCode = context.sourceCode;
-    const { couldBeType } = getTypeServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     return {
       "ExpressionStatement[expression.callee.property.name=/^(complete|error)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error)$/]": (node) => {
         const parent = node.parent;
@@ -1830,7 +1901,7 @@ const noRedundantNotifyRule = ruleCreator({
         if (getExpressionText(sibling, sourceCode) !== getExpressionText(node, sourceCode)) {
           return;
         }
-        if (!isExpressionObserver(sibling, couldBeType) || !isExpressionObserver(node, couldBeType)) {
+        if (!isExpressionObserver(sibling, couldBeType2) || !isExpressionObserver(node, couldBeType2)) {
           return;
         }
         const { expression } = node;
@@ -1861,7 +1932,7 @@ function getExpressionText(expressionStatement, sourceCode) {
   const { object } = callExpression.callee;
   return sourceCode.getText(object);
 }
-function isExpressionObserver(expressionStatement, couldBeType) {
+function isExpressionObserver(expressionStatement, couldBeType2) {
   if (!isCallExpression(expressionStatement.expression)) {
     return false;
   }
@@ -1870,15 +1941,17 @@ function isExpressionObserver(expressionStatement, couldBeType) {
     return false;
   }
   const { object } = callExpression.callee;
-  return couldBeType(object, /^(Subject|Subscriber)$/);
+  return couldBeType2(object, /^(Subject|Subscriber)$/);
 }
 
-const defaultOptions$6 = [];
-const noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions$6,
+// src/rules/no-sharereplay.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var defaultOptions7 = [];
+var noSharereplayRule = ruleCreator({
+  defaultOptions: defaultOptions7,
   meta: {
     docs: {
-      description: "Forbids using the `shareReplay` operator.",
+      description: "Disallow unsafe `shareReplay` usage.",
       recommended: true
     },
     messages: {
@@ -1888,7 +1961,7 @@ const noSharereplayRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowConfig: { type: "boolean" }
+          allowConfig: { type: "boolean", description: "Allow shareReplay if a config argument is specified.", default: true }
         },
         type: "object"
       }
@@ -1903,7 +1976,7 @@ const noSharereplayRule = ruleCreator({
       "CallExpression[callee.name='shareReplay']": (node) => {
         let report = true;
         if (allowConfig) {
-          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES.ObjectExpression;
+          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES7.ObjectExpression;
         }
         if (report) {
           context.report({
@@ -1916,11 +1989,12 @@ const noSharereplayRule = ruleCreator({
   }
 });
 
-const noSubclassRule = ruleCreator({
+// src/rules/no-subclass.ts
+var noSubclassRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids subclassing RxJS classes.",
+      description: "Disallow subclassing RxJS classes.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1931,7 +2005,7 @@ const noSubclassRule = ruleCreator({
   },
   name: "no-subclass",
   create: (context) => {
-    const { couldBeType } = getTypeServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     const queryNames = [
       "AsyncSubject",
       "BehaviorSubject",
@@ -1946,7 +2020,7 @@ const noSubclassRule = ruleCreator({
         "|"
       )})$/] > Identifier.superClass`]: (node) => {
         if (queryNames.some(
-          (name) => couldBeType(node, name, { name: /[/\\]rxjs[/\\]/ })
+          (name2) => couldBeType2(node, name2, { name: /[/\\]rxjs[/\\]/ })
         )) {
           context.report({
             messageId: "forbidden",
@@ -1958,11 +2032,12 @@ const noSubclassRule = ruleCreator({
   }
 });
 
-const noSubjectUnsubscribeRule = ruleCreator({
+// src/rules/no-subject-unsubscribe.ts
+var noSubjectUnsubscribeRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids calling the `unsubscribe` method of a subject instance.",
+      description: "Disallow calling the `unsubscribe` method of subjects.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -2000,11 +2075,12 @@ const noSubjectUnsubscribeRule = ruleCreator({
   }
 });
 
-const noSubjectValueRule = ruleCreator({
+// src/rules/no-subject-value.ts
+var noSubjectValueRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids accessing the `value` property of a `BehaviorSubject` instance.",
+      description: "Disallow accessing the `value` property of a `BehaviorSubject` instance.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2033,11 +2109,12 @@ const noSubjectValueRule = ruleCreator({
   }
 });
 
-const noSubscribeHandlersRule = ruleCreator({
+// src/rules/no-subscribe-handlers.ts
+var noSubscribeHandlersRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the passing of handlers to `subscribe`.",
+      description: "Disallow passing handlers to `subscribe`.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2048,11 +2125,11 @@ const noSubscribeHandlersRule = ruleCreator({
   },
   name: "no-subscribe-handlers",
   create: (context) => {
-    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
     return {
       "CallExpression[arguments.length > 0][callee.property.name='subscribe']": (node) => {
         const callee = node.callee;
-        if (couldBeObservable(callee.object) || couldBeType(callee.object, "Subscribable")) {
+        if (couldBeObservable(callee.object) || couldBeType2(callee.object, "Subscribable")) {
           context.report({
             messageId: "forbidden",
             node: callee.property
@@ -2063,12 +2140,13 @@ const noSubscribeHandlersRule = ruleCreator({
   }
 });
 
-const noTapRule = ruleCreator({
+// src/rules/no-tap.ts
+var noTapRule = ruleCreator({
   defaultOptions: [],
   meta: {
     deprecated: true,
     docs: {
-      description: "Forbids the use of the `tap` operator."
+      description: "Disallow the `tap` operator."
     },
     messages: {
       forbidden: "The tap operator is forbidden."
@@ -2097,11 +2175,12 @@ const noTapRule = ruleCreator({
   }
 });
 
-const noTopromiseRule = ruleCreator({
+// src/rules/no-topromise.ts
+var noTopromiseRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the use of the `toPromise` method.",
+      description: "Disallow use of the `toPromise` method.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2126,11 +2205,12 @@ const noTopromiseRule = ruleCreator({
   }
 });
 
-const noUnboundMethodsRule = ruleCreator({
+// src/rules/no-unbound-methods.ts
+var noUnboundMethodsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the passing of unbound methods.",
+      description: "Disallow passing unbound methods.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -2187,12 +2267,14 @@ const noUnboundMethodsRule = ruleCreator({
   }
 });
 
-const defaultOptions$5 = [];
-const noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions$5,
+// src/rules/no-unsafe-catch.ts
+import { stripIndent as stripIndent4 } from "common-tags";
+var defaultOptions8 = [];
+var noUnsafeCatchRule = ruleCreator({
+  defaultOptions: defaultOptions8,
   meta: {
     docs: {
-      description: "Forbids unsafe `catchError` usage in effects and epics.",
+      description: "Disallow unsafe `catchError` usage in effects and epics.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2201,10 +2283,10 @@ const noUnsafeCatchRule = ruleCreator({
     schema: [
       {
         properties: {
-          observable: { type: "string" }
+          observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
         },
         type: "object",
-        description: stripIndent`
+        description: stripIndent4`
           An optional object with an optional \`observable\` property.
           The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
       }
@@ -2246,12 +2328,14 @@ const noUnsafeCatchRule = ruleCreator({
   }
 });
 
-const defaultOptions$4 = [];
-const noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions$4,
+// src/rules/no-unsafe-first.ts
+import { stripIndent as stripIndent5 } from "common-tags";
+var defaultOptions9 = [];
+var noUnsafeFirstRule = ruleCreator({
+  defaultOptions: defaultOptions9,
   meta: {
     docs: {
-      description: "Forbids unsafe `first`/`take` usage in effects and epics.",
+      description: "Disallow unsafe `first`/`take` usage in effects and epics.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2260,10 +2344,10 @@ const noUnsafeFirstRule = ruleCreator({
     schema: [
       {
         properties: {
-          observable: { type: "string" }
+          observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
         },
         type: "object",
-        description: stripIndent`
+        description: stripIndent5`
           An optional object with an optional \`observable\` property.
           The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
       }
@@ -2314,11 +2398,14 @@ const noUnsafeFirstRule = ruleCreator({
   }
 });
 
-const noUnsafeSubjectNext = ruleCreator({
+// src/rules/no-unsafe-subject-next.ts
+import * as tsutils3 from "ts-api-utils";
+import * as ts6 from "typescript";
+var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids unsafe optional `next` calls.",
+      description: "Disallow unsafe optional `next` calls.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -2335,19 +2422,19 @@ const noUnsafeSubjectNext = ruleCreator({
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
           const type = getType(node.callee.object);
-          if (tsutils.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (tsutils.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils.isTypeFlagSet(t, ts.TypeFlags.Void)
+            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils3.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -2362,12 +2449,15 @@ const noUnsafeSubjectNext = ruleCreator({
   }
 });
 
-const defaultOptions$3 = [];
-const noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions$3,
+// src/rules/no-unsafe-switchmap.ts
+import { stripIndent as stripIndent6 } from "common-tags";
+import decamelize from "decamelize";
+var defaultOptions10 = [];
+var noUnsafeSwitchmapRule = ruleCreator({
+  defaultOptions: defaultOptions10,
   meta: {
     docs: {
-      description: "Forbids unsafe `switchMap` usage in effects and epics.",
+      description: "Disallow unsafe `switchMap` usage in effects and epics.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2377,26 +2467,27 @@ const noUnsafeSwitchmapRule = ruleCreator({
       {
         properties: {
           allow: {
+            description: "Action types that are allowed to be used with switchMap. Mutually exclusive with `disallow`.",
             oneOf: [
-              { type: "string" },
-              { type: "array", items: { type: "string" } }
+              { type: "string", description: "A regular expression string." },
+              { type: "array", items: { type: "string" }, description: "An array of words." }
             ]
           },
           disallow: {
+            description: "Action types that are disallowed to be used with switchMap. Mutually exclusive with `allow`.",
             oneOf: [
-              { type: "string" },
-              { type: "array", items: { type: "string" } }
+              { type: "string", description: "A regular expression string." },
+              { type: "array", items: { type: "string" }, description: "An array of words." }
             ]
           },
           observable: {
-            oneOf: [
-              { type: "string" },
-              { type: "array", items: { type: "string" } }
-            ]
+            type: "string",
+            description: "A RegExp that matches an effect or epic's actions observable.",
+            default: defaultObservable
           }
         },
         type: "object",
-        description: stripIndent`
+        description: stripIndent6`
           An optional object with optional \`allow\`, \`disallow\` and \`observable\` properties.
           The properties can be specified as regular expression strings or as arrays of words.
           The \`allow\` or \`disallow\` properties are mutually exclusive. Whether or not
@@ -2409,6 +2500,7 @@ const noUnsafeSwitchmapRule = ruleCreator({
   },
   name: "no-unsafe-switchmap",
   create: (context) => {
+    var _a, _b, _c;
     const defaultDisallow = [
       "add",
       "create",
@@ -2424,9 +2516,9 @@ const noUnsafeSwitchmapRule = ruleCreator({
     let observableRegExp;
     const [config = {}] = context.options;
     if (config.allow || config.disallow) {
-      allowRegExp = createRegExpForWords(config.allow ?? []);
-      disallowRegExp = createRegExpForWords(config.disallow ?? []);
-      observableRegExp = new RegExp(config.observable ?? defaultObservable);
+      allowRegExp = createRegExpForWords((_a = config.allow) != null ? _a : []);
+      disallowRegExp = createRegExpForWords((_b = config.disallow) != null ? _b : []);
+      observableRegExp = new RegExp((_c = config.observable) != null ? _c : defaultObservable);
     } else {
       allowRegExp = void 0;
       disallowRegExp = createRegExpForWords(defaultDisallow);
@@ -2445,12 +2537,12 @@ const noUnsafeSwitchmapRule = ruleCreator({
           return arg.property.name;
         }
         return "";
-      }).map((name) => decamelize(name));
+      }).map((name2) => decamelize(name2));
       if (allowRegExp) {
-        return !names.every((name) => allowRegExp?.test(name));
+        return !names.every((name2) => allowRegExp == null ? void 0 : allowRegExp.test(name2));
       }
       if (disallowRegExp) {
-        return names.some((name) => disallowRegExp?.test(name));
+        return names.some((name2) => disallowRegExp == null ? void 0 : disallowRegExp.test(name2));
       }
       return false;
     }
@@ -2483,12 +2575,37 @@ const noUnsafeSwitchmapRule = ruleCreator({
   }
 });
 
-const defaultOptions$2 = [];
-const noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions$2,
+// src/rules/no-unsafe-takeuntil.ts
+import { stripIndent as stripIndent7 } from "common-tags";
+var defaultOptions11 = [];
+var allowedOperators = [
+  "count",
+  "defaultIfEmpty",
+  "endWith",
+  "every",
+  "finalize",
+  "finally",
+  "isEmpty",
+  "last",
+  "max",
+  "min",
+  "publish",
+  "publishBehavior",
+  "publishLast",
+  "publishReplay",
+  "reduce",
+  "share",
+  "shareReplay",
+  "skipLast",
+  "takeLast",
+  "throwIfEmpty",
+  "toArray"
+];
+var noUnsafeTakeuntilRule = ruleCreator({
+  defaultOptions: defaultOptions11,
   meta: {
     docs: {
-      description: "Forbids the application of operators after `takeUntil`.",
+      description: "Disallow applying operators after `takeUntil`.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -2498,11 +2615,11 @@ const noUnsafeTakeuntilRule = ruleCreator({
     schema: [
       {
         properties: {
-          alias: { type: "array", items: { type: "string" } },
-          allow: { type: "array", items: { type: "string" } }
+          alias: { type: "array", items: { type: "string" }, description: "An array of operator names that should be treated similarly to `takeUntil`." },
+          allow: { type: "array", items: { type: "string" }, description: "An array of operator names that are allowed to follow `takeUntil`.", default: allowedOperators }
         },
         type: "object",
-        description: stripIndent`
+        description: stripIndent7`
           An optional object with optional \`alias\` and \`allow\` properties.
           The \`alias\` property is an array containing the names of operators that aliases for \`takeUntil\`.
           The \`allow\` property is an array containing the names of the operators that are allowed to follow \`takeUntil\`.`
@@ -2513,29 +2630,6 @@ const noUnsafeTakeuntilRule = ruleCreator({
   name: "no-unsafe-takeuntil",
   create: (context) => {
     let checkedOperatorsRegExp = /^takeUntil$/;
-    const allowedOperators = [
-      "count",
-      "defaultIfEmpty",
-      "endWith",
-      "every",
-      "finalize",
-      "finally",
-      "isEmpty",
-      "last",
-      "max",
-      "min",
-      "publish",
-      "publishBehavior",
-      "publishLast",
-      "publishReplay",
-      "reduce",
-      "share",
-      "shareReplay",
-      "skipLast",
-      "takeLast",
-      "throwIfEmpty",
-      "toArray"
-    ];
     const [config = {}] = context.options;
     const { alias, allow = allowedOperators } = config;
     if (alias) {
@@ -2586,12 +2680,13 @@ const noUnsafeTakeuntilRule = ruleCreator({
   }
 });
 
-const defaultOptions$1 = [];
-const preferObserverRule = ruleCreator({
-  defaultOptions: defaultOptions$1,
+// src/rules/prefer-observer.ts
+var defaultOptions12 = [];
+var preferObserverRule = ruleCreator({
+  defaultOptions: defaultOptions12,
   meta: {
     docs: {
-      description: "Forbids the passing separate handlers to `subscribe` and `tap`.",
+      description: "Disallow passing separate handlers to `subscribe` and `tap`.",
       requiresTypeChecking: true
     },
     fixable: "code",
@@ -2602,7 +2697,7 @@ const preferObserverRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowNext: { type: "boolean" }
+          allowNext: { type: "boolean", description: "Allows a single `next` callback.", default: true }
         },
         type: "object"
       }
@@ -2611,7 +2706,7 @@ const preferObserverRule = ruleCreator({
   },
   name: "prefer-observer",
   create: (context) => {
-    const { couldBeFunction, couldBeObservable } = getTypeServices(context);
+    const { couldBeFunction: couldBeFunction2, couldBeObservable } = getTypeServices(context);
     const [config = {}] = context.options;
     const { allowNext = true } = config;
     function checkArgs(callExpression, reportNode) {
@@ -2655,7 +2750,7 @@ const preferObserverRule = ruleCreator({
         });
       } else if (args.length === 1 && !allowNext) {
         const [arg] = args;
-        if (isArrowFunctionExpression(arg) || isFunctionExpression(arg) || couldBeFunction(arg)) {
+        if (isArrowFunctionExpression(arg) || isFunctionExpression(arg) || couldBeFunction2(arg)) {
           context.report({
             messageId: "forbidden",
             node: reportNode,
@@ -2684,12 +2779,14 @@ function isValidArgText(argText) {
   return argText && argText !== "undefined" && argText !== "null";
 }
 
-const defaultOptions = [];
-const suffixSubjectsRule = ruleCreator({
-  defaultOptions,
+// src/rules/suffix-subjects.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+var defaultOptions13 = [];
+var suffixSubjectsRule = ruleCreator({
+  defaultOptions: defaultOptions13,
   meta: {
     docs: {
-      description: "Enforces the use of a suffix in subject identifiers.",
+      description: "Enforce the use of a suffix in subject identifiers.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2698,11 +2795,11 @@ const suffixSubjectsRule = ruleCreator({
     schema: [
       {
         properties: {
-          parameters: { type: "boolean" },
-          properties: { type: "boolean" },
-          suffix: { type: "string" },
-          types: { type: "object" },
-          variables: { type: "boolean" }
+          parameters: { type: "boolean", description: "Require for parameters." },
+          properties: { type: "boolean", description: "Require for properties." },
+          suffix: { type: "string", description: "The suffix to enforce." },
+          types: { type: "object", description: "Enforce for specific types. Keys are a RegExp, values are a boolean." },
+          variables: { type: "boolean", description: "Require for variables." }
         },
         type: "object"
       }
@@ -2711,8 +2808,8 @@ const suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
-    const { couldBeType } = getTypeServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils5.getParserServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
       parameters: true,
@@ -2741,10 +2838,10 @@ const suffixSubjectsRule = ruleCreator({
     function checkNode(nameNode, typeNode) {
       const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
       const text = tsNode.getText();
-      if (!suffixRegex.test(text) && couldBeType(typeNode || nameNode, "Subject")) {
+      if (!suffixRegex.test(text) && couldBeType2(typeNode || nameNode, "Subject")) {
         for (const type of types) {
           const { regExp, validate: validate2 } = type;
-          if (couldBeType(typeNode || nameNode, regExp) && !validate2) {
+          if (couldBeType2(typeNode || nameNode, regExp) && !validate2) {
             return;
           }
         }
@@ -2767,7 +2864,7 @@ const suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2834,7 +2931,7 @@ const suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2880,11 +2977,14 @@ const suffixSubjectsRule = ruleCreator({
   }
 });
 
-const throwErrorRule = ruleCreator({
+// src/rules/throw-error.ts
+import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+import * as tsutils4 from "ts-api-utils";
+var throwErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Enforces the passing of `Error` values to error notifications.",
+      description: "Enforce passing only `Error` values to error notifications.",
       requiresTypeChecking: true
     },
     messages: {
@@ -2895,7 +2995,7 @@ const throwErrorRule = ruleCreator({
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program } = ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program } = ESLintUtils6.getParserServices(context);
     const { couldBeObservable, getType } = getTypeServices(context);
     function checkNode(node) {
       let type = getType(node);
@@ -2903,9 +3003,9 @@ const throwErrorRule = ruleCreator({
         const tsNode = esTreeNodeToTSNodeMap.get(node);
         const annotation = tsNode.type;
         const body = tsNode.body;
-        type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
+        type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (!tsutils.isIntrinsicAnyType(type) && !tsutils.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
+      if (!tsutils4.isIntrinsicAnyType(type) && !tsutils4.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
         context.report({
           messageId: "forbidden",
           node
@@ -2926,7 +3026,8 @@ const throwErrorRule = ruleCreator({
   }
 });
 
-const plugin = {
+// src/index.ts
+var plugin = {
   meta: { name, version },
   rules: {
     "ban-observables": banObservablesRule,
@@ -2972,11 +3073,13 @@ const plugin = {
     "throw-error": throwErrorRule
   }
 };
-const rxjsX = {
+var rxjsX = {
   ...plugin,
   configs: {
     recommended: createRecommendedConfig(plugin)
   }
 };
-
-export { rxjsX as default };
+var src_default = rxjsX;
+export {
+  src_default as default
+};