eslint-plugin-rxjs-x 0.0.2 → 0.2.0

package/dist/index.mjs

@@ -1,18 +1,11 @@
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { stripIndent } from 'common-tags';
-import * as tsutils from 'tsutils-etc';
-import { isReferenceType, couldBeType, isUnionType, couldBeFunction, isAny, isUnknown } from 'tsutils-etc';
-import * as ts from 'typescript';
-import { DefinitionType } from '@typescript-eslint/scope-manager';
-import * as tsutils$1 from 'tsutils';
-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.0.2";
-
-const createRecommendedConfig = (plugin) => ({
+// src/configs/recommended.ts
+var createRecommendedConfig = (plugin2) => ({
   plugins: {
-    "rxjs-x": plugin
+    "rxjs-x": plugin2
   },
   rules: {
     "rxjs-x/no-async-subscribe": "error",
@@ -33,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";
@@ -48,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}}."
@@ -87,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 }
           };
         }
       }
@@ -103,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,
@@ -116,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}}."
@@ -129,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.`
       }
@@ -151,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 }
           };
         }
       }
@@ -167,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,
@@ -180,6 +183,86 @@ const banOperatorsRule = ruleCreator({
   }
 });
 
+// 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, name2, qualified)) {
+    return true;
+  }
+  if (tsutils.isUnionOrIntersectionType(type)) {
+    return type.types.some((t) => couldBeType(t, name2, qualified));
+  }
+  const baseTypes = type.getBaseTypes();
+  if (baseTypes == null ? void 0 : baseTypes.some((t) => couldBeType(t, name2, qualified))) {
+    return true;
+  }
+  if (couldImplement(type, name2, qualified)) {
+    return true;
+  }
+  return false;
+}
+function isType(type, name2, qualified) {
+  if (!type.symbol) {
+    return false;
+  }
+  if (qualified && !qualified.name.test(
+    qualified.typeChecker.getFullyQualifiedName(type.symbol)
+  )) {
+    return false;
+  }
+  return typeof name2 === "string" ? type.symbol.name === name2 : Boolean(type.symbol.name.match(name2));
+}
+function couldImplement(type, name2, qualified) {
+  const { symbol } = type;
+  if (symbol) {
+    const { valueDeclaration } = symbol;
+    if (valueDeclaration && ts.isClassDeclaration(valueDeclaration)) {
+      const { heritageClauses } = valueDeclaration;
+      if (heritageClauses) {
+        const implemented = heritageClauses.some(
+          ({ token, types }) => token === ts.SyntaxKind.ImplementsKeyword && types.some((node) => isMatchingNode(node, name2, qualified))
+        );
+        if (implemented) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isMatchingNode(node, name2, qualified) {
+  const { expression } = node;
+  if (qualified) {
+    const type = qualified.typeChecker.getTypeAtLocation(expression);
+    if (type) {
+      const qualifiedName = qualified.typeChecker.getFullyQualifiedName(
+        type.symbol
+      );
+      if (!qualified.name.test(qualifiedName)) {
+        return false;
+      }
+    }
+  }
+  const text = expression.getText();
+  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, 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";
@@ -190,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,
@@ -212,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 = (node, name, qualified) => {
+  const couldBeType2 = (node, name2, qualified) => {
     const type = getType(node);
-    return tsutils.couldBeType(
+    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 && tsutils.couldBeType(
+      tsTypeNode && couldBeType(
         typeChecker.getTypeAtLocation(tsTypeNode),
-        name,
+        name2,
         qualified ? { ...qualified, typeChecker } : void 0
       )
     );
@@ -290,45 +386,49 @@ function getTypeServices(context) {
     return getTypeAtLocation(node);
   };
   return {
-    couldBeBehaviorSubject: (node) => couldBeType(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType(node, "Error"),
+    couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
+    couldBeError: (node) => couldBeType2(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
-      return tsutils.couldBeFunction(getType(node));
+      return couldBeFunction(getType(node));
     },
-    couldBeMonoTypeOperatorFunction: (node) => couldBeType(node, "MonoTypeOperatorFunction"),
-    couldBeObservable: (node) => couldBeType(node, "Observable"),
-    couldBeSubject: (node) => couldBeType(node, "Subject"),
-    couldBeSubscription: (node) => couldBeType(node, "Subscription"),
-    couldBeType,
+    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.isAny(getType(node)),
-    isReferenceType: (node) => tsutils.isReferenceType(getType(node)),
-    isUnknown: (node) => tsutils.isUnknown(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: {
@@ -338,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"
       }
@@ -354,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);
@@ -419,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;
@@ -428,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;
           }
@@ -450,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) {
@@ -529,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) {
@@ -580,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: {
@@ -618,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: {
@@ -677,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
     },
@@ -719,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."
@@ -744,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: {
@@ -759,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) {
@@ -770,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
@@ -781,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
     },
@@ -812,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";
 
-function isTypeReference(type) {
+// src/constants.ts
+var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
+
+// 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: {
@@ -831,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.`
       }
@@ -857,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);
@@ -871,7 +983,7 @@ const noCyclicActionRule = ruleCreator({
         return;
       }
       const pipeType = getType(pipeCallExpression);
-      if (!isTypeReference(pipeType)) {
+      if (!isTypeReference3(pipeType)) {
         return;
       }
       const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
@@ -899,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(
@@ -915,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."
@@ -964,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: {
@@ -980,7 +1094,7 @@ const noExposedSubjectsRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowProtected: { type: "boolean" }
+          allowProtected: { type: "boolean", description: "Allow protected subjects.", default: false }
         },
         type: "object"
       }
@@ -991,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) => {
@@ -1067,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: {
@@ -1082,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)) {
@@ -1154,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: {
@@ -1175,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
@@ -1191,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
     },
@@ -1262,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: {
@@ -1291,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: {
@@ -1332,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: {
@@ -1347,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
@@ -1362,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: {
@@ -1377,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({
@@ -1395,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: {
@@ -1420,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;
@@ -1449,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
     },
@@ -1476,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"
@@ -1501,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");
             }
@@ -1544,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
               }
             ]
           });
@@ -1587,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: {
@@ -1613,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",
@@ -1667,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({
@@ -1687,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
     },
@@ -1703,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;
@@ -1730,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
     },
@@ -1747,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;
@@ -1763,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;
@@ -1794,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;
   }
@@ -1803,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: {
@@ -1821,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"
       }
@@ -1836,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({
@@ -1849,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: {
@@ -1864,7 +2005,7 @@ const noSubclassRule = ruleCreator({
   },
   name: "no-subclass",
   create: (context) => {
-    const { couldBeType } = getTypeServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     const queryNames = [
       "AsyncSubject",
       "BehaviorSubject",
@@ -1879,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",
@@ -1891,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
     },
@@ -1933,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: {
@@ -1966,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: {
@@ -1981,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
@@ -1996,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."
@@ -2030,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: {
@@ -2059,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
     },
@@ -2120,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: {
@@ -2134,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.`
       }
@@ -2179,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: {
@@ -2193,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.`
       }
@@ -2247,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
     },
@@ -2268,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 (isReferenceType(type) && couldBeType(type, "Subject")) {
+          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils$1.isTypeFlagSet(t, ts.TypeFlags.Void)
+            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils3.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -2295,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: {
@@ -2310,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
@@ -2342,6 +2500,7 @@ const noUnsafeSwitchmapRule = ruleCreator({
   },
   name: "no-unsafe-switchmap",
   create: (context) => {
+    var _a, _b, _c;
     const defaultDisallow = [
       "add",
       "create",
@@ -2357,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);
@@ -2378,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;
     }
@@ -2416,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
     },
@@ -2431,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\`.`
@@ -2446,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) {
@@ -2519,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",
@@ -2535,7 +2697,7 @@ const preferObserverRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowNext: { type: "boolean" }
+          allowNext: { type: "boolean", description: "Allows a single `next` callback.", default: true }
         },
         type: "object"
       }
@@ -2544,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) {
@@ -2588,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,
@@ -2617,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: {
@@ -2631,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"
       }
@@ -2644,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,
@@ -2674,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;
           }
         }
@@ -2700,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) {
@@ -2767,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) {
@@ -2813,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: {
@@ -2828,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);
@@ -2836,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 (!isAny(type) && !isUnknown(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
+      if (!tsutils4.isIntrinsicAnyType(type) && !tsutils4.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
         context.report({
           messageId: "forbidden",
           node
@@ -2859,7 +3026,8 @@ const throwErrorRule = ruleCreator({
   }
 });
 
-const plugin = {
+// src/index.ts
+var plugin = {
   meta: { name, version },
   rules: {
     "ban-observables": banObservablesRule,
@@ -2905,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
+};