eslint-plugin-rxjs-x 0.0.2 → 0.2.0

package/dist/{index.cjs → index.js}

@@ -1,38 +1,11 @@
-'use strict';Object.defineProperty(exports, '__esModule', {value: true});
-
-const utils = require('@typescript-eslint/utils');
-const commonTags = require('common-tags');
-const tsutils = require('tsutils-etc');
-const ts = require('typescript');
-const scopeManager = require('@typescript-eslint/scope-manager');
-const tsutils$1 = require('tsutils');
-const decamelize = require('decamelize');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const tsutils__namespace = /*#__PURE__*/_interopNamespaceCompat(tsutils);
-const ts__namespace = /*#__PURE__*/_interopNamespaceCompat(ts);
-const tsutils__namespace$1 = /*#__PURE__*/_interopNamespaceCompat(tsutils$1);
-const decamelize__default = /*#__PURE__*/_interopDefaultCompat(decamelize);
-
-const name = "eslint-plugin-rxjs-x";
-const version = "0.0.2";
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// package.json
+var name = "eslint-plugin-rxjs-x";
+var version = "0.2.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",
@@ -53,8 +26,14 @@ const createRecommendedConfig = (plugin) => ({
   }
 });
 
+// src/rules/ban-observables.ts
+var _utils = require('@typescript-eslint/utils');
+var _commontags = require('common-tags');
+
+// src/utils.ts
+
 function createRegExpForWords(config) {
-  if (!config?.length) {
+  if (!(config == null ? void 0 : config.length)) {
     return void 0;
   }
   const flags = "i";
@@ -68,16 +47,17 @@ function createRegExpForWords(config) {
 function escapeRegExp(text) {
   return text.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-const ruleCreator = utils.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/docs/rules/${name}.md`
+var ruleCreator = _utils.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,7 +65,7 @@ const banObservablesRule = ruleCreator({
     schema: [
       {
         type: "object",
-        description: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           An object containing keys that are names of observable factory functions
           and values that are either booleans or strings containing the explanation for the ban.`
       }
@@ -107,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 }
           };
         }
       }
@@ -123,8 +103,8 @@ const banObservablesRule = ruleCreator({
     return {
       "ImportDeclaration[source.value='rxjs'] > ImportSpecifier": (node) => {
         const identifier = node.imported;
-        const name = identifier.type === utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name);
+        const name2 = identifier.type === _utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
         if (failure) {
           context.report({
             ...failure,
@@ -136,12 +116,15 @@ const banObservablesRule = ruleCreator({
   }
 });
 
-const defaultOptions$b = [];
-const banOperatorsRule = ruleCreator({
-  defaultOptions: defaultOptions$b,
+// src/rules/ban-operators.ts
+
+
+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}}."
@@ -149,7 +132,7 @@ const banOperatorsRule = ruleCreator({
     schema: [
       {
         type: "object",
-        description: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           An object containing keys that are names of operators
           and values that are either booleans or strings containing the explanation for the ban.`
       }
@@ -171,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 }
           };
         }
       }
@@ -187,8 +170,8 @@ const banOperatorsRule = ruleCreator({
     return {
       [String.raw`ImportDeclaration[source.value=/^rxjs\u002foperators$/] > ImportSpecifier`]: (node) => {
         const identifier = node.imported;
-        const name = identifier.type === utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name);
+        const name2 = identifier.type === _utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
         if (failure) {
           context.report({
             ...failure,
@@ -200,6 +183,86 @@ const banOperatorsRule = ruleCreator({
   }
 });
 
+// src/rules/finnish.ts
+
+
+// src/etc/could-be-function.ts
+var _typescript = require('typescript'); var ts2 = _interopRequireWildcard(_typescript); var ts = _interopRequireWildcard(_typescript); var ts3 = _interopRequireWildcard(_typescript); var ts4 = _interopRequireWildcard(_typescript); var ts5 = _interopRequireWildcard(_typescript); var ts6 = _interopRequireWildcard(_typescript);
+
+// src/etc/could-be-type.ts
+var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils); var tsutils4 = _interopRequireWildcard(_tsapiutils);
+
+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";
@@ -210,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
+
 function getLoc(node) {
   const sourceFile = node.getSourceFile();
-  const start = ts__namespace.getLineAndCharacterOfPosition(sourceFile, node.getStart());
-  const end = ts__namespace.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
+  const start = ts3.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+  const end = ts3.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
   return {
     start: {
       line: start.line + 1,
@@ -232,76 +299,85 @@ function getLoc(node) {
   };
 }
 
+// src/etc/get-type-services.ts
+
+
+
+
+// src/etc/is.ts
+
 function hasTypeAnnotation(node) {
   return "typeAnnotation" in node && !!node.typeAnnotation;
 }
 function isArrayExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.ArrayExpression;
+  return node.type === _utils.AST_NODE_TYPES.ArrayExpression;
 }
 function isArrayPattern(node) {
-  return node.type === utils.AST_NODE_TYPES.ArrayPattern;
+  return node.type === _utils.AST_NODE_TYPES.ArrayPattern;
 }
 function isArrowFunctionExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.ArrowFunctionExpression;
+  return node.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression;
 }
 function isBlockStatement(node) {
-  return node.type === utils.AST_NODE_TYPES.BlockStatement;
+  return node.type === _utils.AST_NODE_TYPES.BlockStatement;
 }
 function isCallExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.CallExpression;
+  return node.type === _utils.AST_NODE_TYPES.CallExpression;
 }
 function isFunctionDeclaration(node) {
-  return node.type === utils.AST_NODE_TYPES.FunctionDeclaration;
+  return node.type === _utils.AST_NODE_TYPES.FunctionDeclaration;
 }
 function isFunctionExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.FunctionExpression;
+  return node.type === _utils.AST_NODE_TYPES.FunctionExpression;
 }
 function isIdentifier(node) {
-  return node.type === utils.AST_NODE_TYPES.Identifier;
+  return node.type === _utils.AST_NODE_TYPES.Identifier;
 }
 function isLiteral(node) {
-  return node.type === utils.AST_NODE_TYPES.Literal;
+  return node.type === _utils.AST_NODE_TYPES.Literal;
 }
 function isMemberExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.MemberExpression;
+  return node.type === _utils.AST_NODE_TYPES.MemberExpression;
 }
 function isObjectExpression(node) {
-  return node.type === utils.AST_NODE_TYPES.ObjectExpression;
+  return node.type === _utils.AST_NODE_TYPES.ObjectExpression;
 }
 function isObjectPattern(node) {
-  return node.type === utils.AST_NODE_TYPES.ObjectPattern;
+  return node.type === _utils.AST_NODE_TYPES.ObjectPattern;
 }
 function isProgram(node) {
-  return node.type === utils.AST_NODE_TYPES.Program;
+  return node.type === _utils.AST_NODE_TYPES.Program;
 }
 function isProperty(node) {
-  return node.type === utils.AST_NODE_TYPES.Property;
+  return node.type === _utils.AST_NODE_TYPES.Property;
 }
 
+// src/etc/get-type-services.ts
 function getTypeServices(context) {
-  const services = utils.ESLintUtils.getParserServices(context);
+  const services = _utils.ESLintUtils.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__namespace.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__namespace.isArrowFunction(tsNode) || ts__namespace.isFunctionDeclaration(tsNode) || ts__namespace.isMethodDeclaration(tsNode) || ts__namespace.isFunctionExpression(tsNode)) {
-      tsTypeNode = tsNode.type ?? tsNode.body;
-    } else if (ts__namespace.isCallSignatureDeclaration(tsNode) || ts__namespace.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__namespace.couldBeType(
+      tsTypeNode && couldBeType(
         typeChecker.getTypeAtLocation(tsTypeNode),
-        name,
+        name2,
         qualified ? { ...qualified, typeChecker } : void 0
       )
     );
@@ -310,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__namespace.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__namespace.isAny(getType(node)),
-    isReferenceType: (node) => tsutils__namespace.isReferenceType(getType(node)),
-    isUnknown: (node) => tsutils__namespace.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
+var _scopemanager = require('@typescript-eslint/scope-manager');
+
+function isImport(scope, name2, source) {
+  const variable = scope.variables.find((variable2) => variable2.name === name2);
   if (variable) {
     return variable.defs.some(
-      (def) => def.type === scopeManager.DefinitionType.ImportBinding && def.parent.type === utils.AST_NODE_TYPES.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
+      (def) => def.type === _scopemanager.DefinitionType.ImportBinding && def.parent.type === _utils.AST_NODE_TYPES.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: {
@@ -358,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"
       }
@@ -374,10 +454,10 @@ const finnishRule = ruleCreator({
   },
   name: "finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = _utils.ESLintUtils.getParserServices(context);
     const {
       couldBeObservable,
-      couldBeType,
+      couldBeType: couldBeType2,
       couldReturnObservable,
       couldReturnType
     } = getTypeServices(context);
@@ -439,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;
@@ -448,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;
           }
@@ -470,7 +550,7 @@ const finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -549,7 +629,7 @@ const finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -600,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: {
@@ -638,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: {
@@ -697,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
     },
@@ -739,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."
@@ -764,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: {
@@ -779,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) {
@@ -790,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
@@ -801,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
     },
@@ -832,17 +918,23 @@ const noCreateRule = ruleCreator({
   }
 });
 
-const defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
+// src/rules/no-cyclic-action.ts
+
+
 
-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: {
@@ -851,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: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           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.`
       }
@@ -877,13 +969,13 @@ const noCyclicActionRule = ruleCreator({
       const operatorType = getType(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
-        ts__namespace.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);
@@ -891,7 +983,7 @@ const noCyclicActionRule = ruleCreator({
         return;
       }
       const pipeType = getType(pipeCallExpression);
-      if (!isTypeReference(pipeType)) {
+      if (!isTypeReference3(pipeType)) {
         return;
       }
       const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
@@ -919,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(
@@ -935,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."
@@ -984,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: {
@@ -1000,7 +1094,7 @@ const noExposedSubjectsRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowProtected: { type: "boolean" }
+          allowProtected: { type: "boolean", description: "Allow protected subjects.", default: false }
         },
         type: "object"
       }
@@ -1011,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) => {
@@ -1087,11 +1181,13 @@ const noExposedSubjectsRule = ruleCreator({
   }
 });
 
-const noFinnishRule = ruleCreator({
+// src/rules/no-finnish.ts
+
+var noFinnishRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids the use of Finnish notation.",
+      description: "Disallow Finnish notation.",
       requiresTypeChecking: true
     },
     messages: {
@@ -1102,7 +1198,7 @@ const noFinnishRule = ruleCreator({
   },
   name: "no-finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = _utils.ESLintUtils.getParserServices(context);
     const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
     function checkNode(nameNode, typeNode) {
       if (couldBeObservable(typeNode || nameNode) || couldReturnObservable(typeNode || nameNode)) {
@@ -1174,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: {
@@ -1195,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
@@ -1211,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
     },
@@ -1282,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: {
@@ -1311,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: {
@@ -1352,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: {
@@ -1367,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
@@ -1382,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: {
@@ -1397,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({
@@ -1415,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: {
@@ -1440,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;
@@ -1469,17 +1573,21 @@ const noIgnoredTakewhileValueRule = ruleCreator({
   }
 });
 
+// src/rules/no-implicit-any-catch.ts
+
+
+
 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
     },
@@ -1496,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"
@@ -1521,41 +1631,43 @@ const noImplicitAnyCatchRule = ruleCreator({
           const {
             typeAnnotation: { type }
           } = typeAnnotation;
-          if (type === utils.AST_NODE_TYPES.TSAnyKeyword) {
-            let fix = function(fixer) {
+          if (type === _utils.AST_NODE_TYPES.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 !== utils.AST_NODE_TYPES.TSUnknownKeyword) {
-            let fix = function(fixer) {
+          } else if (type !== _utils.AST_NODE_TYPES.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");
             }
@@ -1564,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
               }
             ]
           });
@@ -1607,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: {
@@ -1633,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",
@@ -1687,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({
@@ -1707,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
     },
@@ -1723,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;
@@ -1750,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
     },
@@ -1767,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;
@@ -1783,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;
@@ -1814,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;
   }
@@ -1823,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
+
+var defaultOptions7 = [];
+var noSharereplayRule = ruleCreator({
+  defaultOptions: defaultOptions7,
   meta: {
     docs: {
-      description: "Forbids using the `shareReplay` operator.",
+      description: "Disallow unsafe `shareReplay` usage.",
       recommended: true
     },
     messages: {
@@ -1841,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"
       }
@@ -1856,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 !== utils.AST_NODE_TYPES.ObjectExpression;
+          report = node.arguments.length !== 1 || node.arguments[0].type !== _utils.AST_NODE_TYPES.ObjectExpression;
         }
         if (report) {
           context.report({
@@ -1869,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: {
@@ -1884,7 +2005,7 @@ const noSubclassRule = ruleCreator({
   },
   name: "no-subclass",
   create: (context) => {
-    const { couldBeType } = getTypeServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     const queryNames = [
       "AsyncSubject",
       "BehaviorSubject",
@@ -1899,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",
@@ -1911,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
     },
@@ -1953,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: {
@@ -1986,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: {
@@ -2001,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
@@ -2016,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."
@@ -2050,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: {
@@ -2079,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
     },
@@ -2140,12 +2267,14 @@ const noUnboundMethodsRule = ruleCreator({
   }
 });
 
-const defaultOptions$5 = [];
-const noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions$5,
+// src/rules/no-unsafe-catch.ts
+
+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: {
@@ -2154,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: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           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.`
       }
@@ -2199,12 +2328,14 @@ const noUnsafeCatchRule = ruleCreator({
   }
 });
 
-const defaultOptions$4 = [];
-const noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions$4,
+// src/rules/no-unsafe-first.ts
+
+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: {
@@ -2213,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: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           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.`
       }
@@ -2267,11 +2398,14 @@ const noUnsafeFirstRule = ruleCreator({
   }
 });
 
-const noUnsafeSubjectNext = ruleCreator({
+// src/rules/no-unsafe-subject-next.ts
+
+
+var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Forbids unsafe optional `next` calls.",
+      description: "Disallow unsafe optional `next` calls.",
       recommended: true,
       requiresTypeChecking: true
     },
@@ -2288,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.isReferenceType(type) && tsutils.couldBeType(type, "Subject")) {
+          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Any)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Unknown)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Void)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (tsutils.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils__namespace$1.isTypeFlagSet(t, ts__namespace.TypeFlags.Void)
+            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils3.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -2315,12 +2449,15 @@ const noUnsafeSubjectNext = ruleCreator({
   }
 });
 
-const defaultOptions$3 = [];
-const noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions$3,
+// src/rules/no-unsafe-switchmap.ts
+
+var _decamelize = require('decamelize'); var _decamelize2 = _interopRequireDefault(_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: {
@@ -2330,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: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           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
@@ -2362,6 +2500,7 @@ const noUnsafeSwitchmapRule = ruleCreator({
   },
   name: "no-unsafe-switchmap",
   create: (context) => {
+    var _a, _b, _c;
     const defaultDisallow = [
       "add",
       "create",
@@ -2377,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);
@@ -2398,12 +2537,12 @@ const noUnsafeSwitchmapRule = ruleCreator({
           return arg.property.name;
         }
         return "";
-      }).map((name) => decamelize__default(name));
+      }).map((name2) => _decamelize2.default.call(void 0, 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;
     }
@@ -2436,12 +2575,37 @@ const noUnsafeSwitchmapRule = ruleCreator({
   }
 });
 
-const defaultOptions$2 = [];
-const noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions$2,
+// src/rules/no-unsafe-takeuntil.ts
+
+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
     },
@@ -2451,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: commonTags.stripIndent`
+        description: _commontags.stripIndent`
           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\`.`
@@ -2466,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) {
@@ -2539,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",
@@ -2555,7 +2697,7 @@ const preferObserverRule = ruleCreator({
     schema: [
       {
         properties: {
-          allowNext: { type: "boolean" }
+          allowNext: { type: "boolean", description: "Allows a single `next` callback.", default: true }
         },
         type: "object"
       }
@@ -2564,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) {
@@ -2608,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,
@@ -2637,12 +2779,14 @@ function isValidArgText(argText) {
   return argText && argText !== "undefined" && argText !== "null";
 }
 
-const defaultOptions = [];
-const suffixSubjectsRule = ruleCreator({
-  defaultOptions,
+// src/rules/suffix-subjects.ts
+
+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: {
@@ -2651,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"
       }
@@ -2664,8 +2808,8 @@ const suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
-    const { couldBeType } = getTypeServices(context);
+    const { esTreeNodeToTSNodeMap } = _utils.ESLintUtils.getParserServices(context);
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
       parameters: true,
@@ -2694,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;
           }
         }
@@ -2720,7 +2864,7 @@ const suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2787,7 +2931,7 @@ const suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && found.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2833,11 +2977,14 @@ const suffixSubjectsRule = ruleCreator({
   }
 });
 
-const throwErrorRule = ruleCreator({
+// src/rules/throw-error.ts
+
+
+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: {
@@ -2848,17 +2995,17 @@ const throwErrorRule = ruleCreator({
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program } = utils.ESLintUtils.getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program } = _utils.ESLintUtils.getParserServices(context);
     const { couldBeObservable, getType } = getTypeServices(context);
     function checkNode(node) {
       let type = getType(node);
-      if (tsutils.couldBeFunction(type)) {
+      if (couldBeFunction(type)) {
         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.isAny(type) && !tsutils.isUnknown(type) && !tsutils.couldBeType(type, /^(Error|DOMException)$/)) {
+      if (!tsutils4.isIntrinsicAnyType(type) && !tsutils4.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
         context.report({
           messageId: "forbidden",
           node
@@ -2879,7 +3026,8 @@ const throwErrorRule = ruleCreator({
   }
 });
 
-const plugin = {
+// src/index.ts
+var plugin = {
   meta: { name, version },
   rules: {
     "ban-observables": banObservablesRule,
@@ -2925,11 +3073,15 @@ const plugin = {
     "throw-error": throwErrorRule
   }
 };
-const rxjsX = {
+var rxjsX = {
   ...plugin,
   configs: {
     recommended: createRecommendedConfig(plugin)
   }
 };
+var src_default = rxjsX;
+
+
+exports.default = src_default;
 
-exports.default = rxjsX;
+module.exports = exports.default;