eslint-plugin-rxjs-x 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2936 @@
+'use strict';
+
+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.1";
+
+const createRecommendedConfig = (plugin) => ({
+  plugins: {
+    "rxjs-x": plugin
+  },
+  rules: {
+    "rxjs-x/no-async-subscribe": "error",
+    "rxjs-x/no-create": "error",
+    "rxjs-x/no-ignored-notifier": "error",
+    "rxjs-x/no-ignored-replay-buffer": "error",
+    "rxjs-x/no-ignored-takewhile-value": "error",
+    "rxjs-x/no-implicit-any-catch": "error",
+    "rxjs-x/no-index": "error",
+    "rxjs-x/no-internal": "error",
+    "rxjs-x/no-nested-subscribe": "error",
+    "rxjs-x/no-redundant-notify": "error",
+    "rxjs-x/no-sharereplay": ["error", { allowConfig: true }],
+    "rxjs-x/no-subject-unsubscribe": "error",
+    "rxjs-x/no-unbound-methods": "error",
+    "rxjs-x/no-unsafe-subject-next": "error",
+    "rxjs-x/no-unsafe-takeuntil": "error"
+  }
+});
+
+function createRegExpForWords(config) {
+  if (!config?.length) {
+    return void 0;
+  }
+  const flags = "i";
+  if (typeof config === "string") {
+    return new RegExp(config, flags);
+  }
+  const words = config;
+  const joined = words.map((word) => String.raw`(\b|_)${word}(\b|_)`).join("|");
+  return new RegExp(`(${joined})`, flags);
+}
+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`
+);
+
+const defaultOptions$c = [];
+const banObservablesRule = ruleCreator({
+  defaultOptions: defaultOptions$c,
+  meta: {
+    docs: {
+      description: "Forbids the use of banned observables."
+    },
+    messages: {
+      forbidden: "RxJS observable is banned: {{name}}{{explanation}}."
+    },
+    schema: [
+      {
+        type: "object",
+        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.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "ban-observables",
+  create: (context) => {
+    const bans = [];
+    const [config] = context.options;
+    if (!config) {
+      return {};
+    }
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== false) {
+        bans.push({
+          explanation: typeof value === "string" ? value : "",
+          regExp: new RegExp(`^${key}$`)
+        });
+      }
+    });
+    function getFailure(name) {
+      for (let b = 0, length = bans.length; b < length; ++b) {
+        const ban = bans[b];
+        if (ban.regExp.test(name)) {
+          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
+          return {
+            messageId: "forbidden",
+            data: { name, explanation }
+          };
+        }
+      }
+      return void 0;
+    }
+    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);
+        if (failure) {
+          context.report({
+            ...failure,
+            node: identifier
+          });
+        }
+      }
+    };
+  }
+});
+
+const defaultOptions$b = [];
+const banOperatorsRule = ruleCreator({
+  defaultOptions: defaultOptions$b,
+  meta: {
+    docs: {
+      description: "Forbids the use of banned operators."
+    },
+    messages: {
+      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
+    },
+    schema: [
+      {
+        type: "object",
+        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.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "ban-operators",
+  create: (context) => {
+    const bans = [];
+    const [config] = context.options;
+    if (!config) {
+      return {};
+    }
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== false) {
+        bans.push({
+          explanation: typeof value === "string" ? value : "",
+          regExp: new RegExp(`^${key}$`)
+        });
+      }
+    });
+    function getFailure(name) {
+      for (let b = 0, length = bans.length; b < length; ++b) {
+        const ban = bans[b];
+        if (ban.regExp.test(name)) {
+          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
+          return {
+            messageId: "forbidden",
+            data: { name, explanation }
+          };
+        }
+      }
+      return void 0;
+    }
+    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);
+        if (failure) {
+          context.report({
+            ...failure,
+            node: identifier
+          });
+        }
+      }
+    };
+  }
+});
+
+function findParent(node, ...args) {
+  const [arg] = args;
+  const predicate = typeof arg === "function" ? arg : (type) => !args.includes(type) ? "continue" : "return";
+  let parent = node.parent;
+  while (parent) {
+    switch (predicate(parent.type)) {
+      case "break":
+        return void 0;
+      case "return":
+        return parent;
+    }
+    parent = parent.parent;
+  }
+  return void 0;
+}
+
+function getLoc(node) {
+  const sourceFile = node.getSourceFile();
+  const start = ts__namespace.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+  const end = ts__namespace.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
+  return {
+    start: {
+      line: start.line + 1,
+      column: start.character
+    },
+    end: {
+      line: end.line + 1,
+      column: end.character
+    }
+  };
+}
+
+function hasTypeAnnotation(node) {
+  return "typeAnnotation" in node && !!node.typeAnnotation;
+}
+function isArrayExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.ArrayExpression;
+}
+function isArrayPattern(node) {
+  return node.type === utils.AST_NODE_TYPES.ArrayPattern;
+}
+function isArrowFunctionExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.ArrowFunctionExpression;
+}
+function isBlockStatement(node) {
+  return node.type === utils.AST_NODE_TYPES.BlockStatement;
+}
+function isCallExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.CallExpression;
+}
+function isFunctionDeclaration(node) {
+  return node.type === utils.AST_NODE_TYPES.FunctionDeclaration;
+}
+function isFunctionExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.FunctionExpression;
+}
+function isIdentifier(node) {
+  return node.type === utils.AST_NODE_TYPES.Identifier;
+}
+function isLiteral(node) {
+  return node.type === utils.AST_NODE_TYPES.Literal;
+}
+function isMemberExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.MemberExpression;
+}
+function isObjectExpression(node) {
+  return node.type === utils.AST_NODE_TYPES.ObjectExpression;
+}
+function isObjectPattern(node) {
+  return node.type === utils.AST_NODE_TYPES.ObjectPattern;
+}
+function isProgram(node) {
+  return node.type === utils.AST_NODE_TYPES.Program;
+}
+function isProperty(node) {
+  return node.type === utils.AST_NODE_TYPES.Property;
+}
+
+function getTypeServices(context) {
+  const services = utils.ESLintUtils.getParserServices(context);
+  const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
+  const typeChecker = program.getTypeChecker();
+  const couldBeType = (node, name, qualified) => {
+    const type = getType(node);
+    return tsutils__namespace.couldBeType(
+      type,
+      name,
+      qualified ? { ...qualified, typeChecker } : void 0
+    );
+  };
+  const couldReturnType = (node, name, qualified) => {
+    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)) {
+      tsTypeNode = tsNode.type;
+    }
+    return Boolean(
+      tsTypeNode && tsutils__namespace.couldBeType(
+        typeChecker.getTypeAtLocation(tsTypeNode),
+        name,
+        qualified ? { ...qualified, typeChecker } : void 0
+      )
+    );
+  };
+  const getType = (node) => {
+    return getTypeAtLocation(node);
+  };
+  return {
+    couldBeBehaviorSubject: (node) => couldBeType(node, "BehaviorSubject"),
+    couldBeError: (node) => couldBeType(node, "Error"),
+    couldBeFunction: (node) => {
+      if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
+        return true;
+      }
+      return tsutils__namespace.couldBeFunction(getType(node));
+    },
+    couldBeMonoTypeOperatorFunction: (node) => couldBeType(node, "MonoTypeOperatorFunction"),
+    couldBeObservable: (node) => couldBeType(node, "Observable"),
+    couldBeSubject: (node) => couldBeType(node, "Subject"),
+    couldBeSubscription: (node) => couldBeType(node, "Subscription"),
+    couldBeType,
+    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)),
+    typeChecker
+  };
+}
+
+function isImport(scope, name, source) {
+  const variable = scope.variables.find((variable2) => variable2.name === name);
+  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))
+    );
+  }
+  return scope.upper ? isImport(scope.upper, name, source) : false;
+}
+
+const defaultOptions$a = [];
+const finnishRule = ruleCreator({
+  defaultOptions: defaultOptions$a,
+  meta: {
+    docs: {
+      description: "Enforces the use of Finnish notation.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      shouldBeFinnish: "Finnish notation should be used here.",
+      shouldNotBeFinnish: "Finnish notation should not be used here."
+    },
+    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" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "finnish",
+  create: (context) => {
+    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
+    const {
+      couldBeObservable,
+      couldBeType,
+      couldReturnObservable,
+      couldReturnType
+    } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { strict = false } = config;
+    const validate = {
+      functions: true,
+      methods: true,
+      parameters: true,
+      properties: true,
+      variables: true,
+      ...config
+    };
+    const names = [];
+    if (config.names) {
+      Object.entries(config.names).forEach(
+        ([key, validate2]) => {
+          names.push({ regExp: new RegExp(key), validate: validate2 });
+        }
+      );
+    } else {
+      names.push({
+        regExp: /^(canActivate|canActivateChild|canDeactivate|canLoad|intercept|resolve|validate)$/,
+        validate: false
+      });
+    }
+    const types = [];
+    if (config.types) {
+      Object.entries(config.types).forEach(
+        ([key, validate2]) => {
+          types.push({ regExp: new RegExp(key), validate: validate2 });
+        }
+      );
+    } else {
+      types.push({
+        regExp: /^EventEmitter$/,
+        validate: false
+      });
+    }
+    function checkNode(nameNode, typeNode) {
+      const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
+      const text = tsNode.getText();
+      const hasFinnish = text.endsWith("$");
+      if (hasFinnish && !strict) {
+        return;
+      }
+      const shouldBeFinnish = hasFinnish ? () => {
+      } : () => {
+        context.report({
+          loc: getLoc(tsNode),
+          messageId: "shouldBeFinnish"
+        });
+      };
+      const shouldNotBeFinnish = hasFinnish ? () => {
+        context.report({
+          loc: getLoc(tsNode),
+          messageId: "shouldNotBeFinnish"
+        });
+      } : () => {
+      };
+      if (couldBeObservable(typeNode || nameNode) || couldReturnObservable(typeNode || nameNode)) {
+        for (const name of names) {
+          const { regExp, validate: validate2 } = name;
+          if (regExp.test(text) && !validate2) {
+            shouldNotBeFinnish();
+            return;
+          }
+        }
+        for (const type of types) {
+          const { regExp, validate: validate2 } = type;
+          if ((couldBeType(typeNode || nameNode, regExp) || couldReturnType(typeNode || nameNode, regExp)) && !validate2) {
+            shouldNotBeFinnish();
+            return;
+          }
+        }
+        shouldBeFinnish();
+      } else {
+        shouldNotBeFinnish();
+      }
+    }
+    return {
+      "ArrayPattern > Identifier": (node) => {
+        const found = findParent(
+          node,
+          "ArrowFunctionExpression",
+          "FunctionDeclaration",
+          "FunctionExpression",
+          "VariableDeclarator"
+        );
+        if (!found) {
+          return;
+        }
+        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+          return;
+        }
+        if (!validate.parameters) {
+          return;
+        }
+        checkNode(node);
+      },
+      "ArrowFunctionExpression > Identifier": (node) => {
+        if (validate.parameters) {
+          const parent = node.parent;
+          if (node !== parent.body) {
+            checkNode(node);
+          }
+        }
+      },
+      "PropertyDefinition[computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key);
+        }
+      },
+      "FunctionDeclaration > Identifier": (node) => {
+        const parent = node.parent;
+        if (node === parent.id) {
+          if (validate.functions) {
+            checkNode(node, parent);
+          }
+        } else {
+          if (validate.parameters) {
+            checkNode(node);
+          }
+        }
+      },
+      "FunctionExpression > Identifier": (node) => {
+        const parent = node.parent;
+        if (node === parent.id) {
+          if (validate.functions) {
+            checkNode(node, parent);
+          }
+        } else {
+          if (validate.parameters) {
+            checkNode(node);
+          }
+        }
+      },
+      "MethodDefinition[kind='get'][computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key, node);
+        }
+      },
+      "MethodDefinition[kind='method'][computed=false]": (node) => {
+        if (validate.methods) {
+          checkNode(node.key, node);
+        }
+      },
+      "MethodDefinition[kind='set'][computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key, node);
+        }
+      },
+      "ObjectExpression > Property[computed=false] > Identifier": (node) => {
+        if (validate.properties) {
+          const parent = node.parent;
+          if (node === parent.key) {
+            checkNode(node);
+          }
+        }
+      },
+      "ObjectPattern > Property > Identifier": (node) => {
+        const found = findParent(
+          node,
+          "ArrowFunctionExpression",
+          "FunctionDeclaration",
+          "FunctionExpression",
+          "VariableDeclarator"
+        );
+        if (!found) {
+          return;
+        }
+        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+          return;
+        }
+        if (!validate.parameters) {
+          return;
+        }
+        const parent = node.parent;
+        if (node === parent.value) {
+          checkNode(node);
+        }
+      },
+      "TSCallSignatureDeclaration > Identifier": (node) => {
+        if (validate.parameters) {
+          checkNode(node);
+        }
+      },
+      "TSConstructSignatureDeclaration > Identifier": (node) => {
+        if (validate.parameters) {
+          checkNode(node);
+        }
+      },
+      "TSMethodSignature[computed=false]": (node) => {
+        if (validate.methods) {
+          checkNode(node.key, node);
+        }
+        if (validate.parameters) {
+          node.params.forEach((param) => {
+            checkNode(param);
+          });
+        }
+      },
+      "TSParameterProperty > Identifier": (node) => {
+        if (validate.parameters || validate.properties) {
+          checkNode(node);
+        }
+      },
+      "TSPropertySignature[computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key);
+        }
+      },
+      "VariableDeclarator > Identifier": (node) => {
+        const parent = node.parent;
+        if (validate.variables && node === parent.id) {
+          checkNode(node);
+        }
+      }
+    };
+  }
+});
+
+const justRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforces the use of a `just` alias for `of`."
+    },
+    fixable: "code",
+    messages: {
+      forbidden: "Use just alias."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "just",
+  create: (context) => {
+    return {
+      "ImportDeclaration[source.value='rxjs'] > ImportSpecifier[imported.name='of']": (node) => {
+        if (node.local.range[0] !== node.imported.range[0] && node.local.range[1] !== node.imported.range[1]) {
+          return;
+        }
+        context.report({
+          messageId: "forbidden",
+          node,
+          fix: (fixer) => fixer.replaceTextRange(node.range, "of as just")
+        });
+        const [ofImport] = context.sourceCode.getDeclaredVariables(node);
+        ofImport.references.forEach((ref) => {
+          context.report({
+            messageId: "forbidden",
+            node: ref.identifier,
+            fix: (fixer) => fixer.replaceTextRange(ref.identifier.range, "just")
+          });
+        });
+      }
+    };
+  }
+});
+
+const macroRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforces the use of the RxJS Tools Babel macro."
+    },
+    fixable: "code",
+    messages: {
+      macro: "Use the RxJS Tools Babel macro."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "macro",
+  create: (context) => {
+    let hasFailure = false;
+    let hasMacroImport = false;
+    let program = void 0;
+    function fix(fixer) {
+      return fixer.insertTextBefore(
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        program,
+        `import "babel-plugin-rxjs-tools/macro";
+`
+      );
+    }
+    return {
+      "CallExpression[callee.property.name=/^(pipe|subscribe)$/]": (node) => {
+        if (hasFailure || hasMacroImport) {
+          return;
+        }
+        hasFailure = true;
+        context.report({
+          fix,
+          messageId: "macro",
+          node: node.callee
+        });
+      },
+      "ImportDeclaration[source.value='babel-plugin-rxjs-tools/macro']": (_node) => {
+        hasMacroImport = true;
+      },
+      [String.raw`ImportDeclaration[source.value=/^rxjs(\u002f|$)/]`]: (node) => {
+        if (hasFailure || hasMacroImport) {
+          return;
+        }
+        hasFailure = true;
+        context.report({
+          fix,
+          messageId: "macro",
+          node
+        });
+      },
+      "Program": (node) => {
+        program = node;
+      }
+    };
+  }
+});
+
+const noAsyncSubscribeRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids passing `async` functions to `subscribe`.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Passing async functions to subscribe is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-async-subscribe",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    function checkNode(node) {
+      const parentNode = node.parent;
+      const callee = parentNode.callee;
+      if (couldBeObservable(callee.object)) {
+        const { loc } = node;
+        const asyncLoc = {
+          ...loc,
+          end: {
+            ...loc.start,
+            column: loc.start.column + 5
+          }
+        };
+        context.report({
+          messageId: "forbidden",
+          loc: asyncLoc
+        });
+      }
+    }
+    return {
+      "CallExpression[callee.property.name='subscribe'] > FunctionExpression[async=true]": checkNode,
+      "CallExpression[callee.property.name='subscribe'] > ArrowFunctionExpression[async=true]": checkNode
+    };
+  }
+});
+
+const noCompatRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids importation from locations that depend upon `rxjs-compat`."
+    },
+    messages: {
+      forbidden: "'rxjs-compat'-dependent import locations are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-compat",
+  create: (context) => {
+    return {
+      [String.raw`ImportDeclaration Literal[value=/^rxjs\u002f/]:not(Literal[value=/^rxjs\u002f(ajax|fetch|operators|testing|webSocket)/])`]: (node) => {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+      }
+    };
+  }
+});
+
+const noConnectableRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids operators that return connectable observables.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Connectable observables are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-connectable",
+  create: (context) => {
+    const { couldBeFunction } = getTypeServices(context);
+    return {
+      "CallExpression[callee.name='multicast']": (node) => {
+        if (node.arguments.length === 1) {
+          context.report({
+            messageId: "forbidden",
+            node: node.callee
+          });
+        }
+      },
+      "CallExpression[callee.name=/^(publish|publishBehavior|publishLast|publishReplay)$/]": (node) => {
+        if (!node.arguments.some((arg) => couldBeFunction(arg))) {
+          context.report({
+            messageId: "forbidden",
+            node: node.callee
+          });
+        }
+      }
+    };
+  }
+});
+
+const noCreateRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the calling of `Observable.create`.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Observable.create is forbidden; use new Observable."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-create",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    return {
+      "CallExpression > MemberExpression[object.name='Observable'] > Identifier[name='create']": (node) => {
+        const memberExpression = node.parent;
+        if (couldBeObservable(memberExpression.object)) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
+
+function isTypeReference(type) {
+  return Boolean(type.target);
+}
+const defaultOptions$9 = [];
+const noCyclicActionRule = ruleCreator({
+  defaultOptions: defaultOptions$9,
+  meta: {
+    docs: {
+      description: "Forbids effects and epics that re-emit filtered actions.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Effects and epics that re-emit filtered actions are forbidden."
+    },
+    schema: [
+      {
+        properties: {
+          observable: { type: "string" }
+        },
+        type: "object",
+        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.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-cyclic-action",
+  create: (context) => {
+    const [config = {}] = context.options;
+    const { observable = defaultObservable } = config;
+    const observableRegExp = new RegExp(observable);
+    const { getType, typeChecker } = getTypeServices(context);
+    function checkNode(pipeCallExpression) {
+      const operatorCallExpression = pipeCallExpression.arguments.find(
+        (arg) => isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "ofType"
+      );
+      if (!operatorCallExpression) {
+        return;
+      }
+      const operatorType = getType(operatorCallExpression);
+      const [signature] = typeChecker.getSignaturesOfType(
+        operatorType,
+        ts__namespace.SignatureKind.Call
+      );
+      if (!signature) {
+        return;
+      }
+      const operatorReturnType = typeChecker.getReturnTypeOfSignature(signature);
+      if (!isTypeReference(operatorReturnType)) {
+        return;
+      }
+      const [operatorElementType] = typeChecker.getTypeArguments(operatorReturnType);
+      if (!operatorElementType) {
+        return;
+      }
+      const pipeType = getType(pipeCallExpression);
+      if (!isTypeReference(pipeType)) {
+        return;
+      }
+      const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
+      if (!pipeElementType) {
+        return;
+      }
+      const operatorActionTypes = getActionTypes(operatorElementType);
+      const pipeActionTypes = getActionTypes(pipeElementType);
+      for (const actionType of operatorActionTypes) {
+        if (pipeActionTypes.includes(actionType)) {
+          context.report({
+            messageId: "forbidden",
+            node: pipeCallExpression.callee
+          });
+          return;
+        }
+      }
+    }
+    function getActionTypes(type) {
+      if (type.isUnion()) {
+        const memberActionTypes = [];
+        for (const memberType of type.types) {
+          memberActionTypes.push(...getActionTypes(memberType));
+        }
+        return memberActionTypes;
+      }
+      const symbol = typeChecker.getPropertyOfType(type, "type");
+      if (!symbol?.valueDeclaration) {
+        return [];
+      }
+      const actionType = typeChecker.getTypeOfSymbolAtLocation(
+        symbol,
+        symbol.valueDeclaration
+      );
+      return [typeChecker.typeToString(actionType)];
+    }
+    return {
+      [`CallExpression[callee.property.name='pipe'][callee.object.name=${observableRegExp}]`]: checkNode,
+      [`CallExpression[callee.property.name='pipe'][callee.object.property.name=${observableRegExp}]`]: checkNode
+    };
+  }
+});
+
+const noExplicitGenericsRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids explicit generic type arguments."
+    },
+    messages: {
+      forbidden: "Explicit generic type arguments are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-explicit-generics",
+  create: (context) => {
+    function report(node) {
+      context.report({
+        messageId: "forbidden",
+        node
+      });
+    }
+    function checkBehaviorSubjects(node) {
+      const parent = node.parent;
+      const {
+        arguments: [value]
+      } = parent;
+      if (isArrayExpression(value) || isObjectExpression(value)) {
+        return;
+      }
+      report(node);
+    }
+    function checkNotifications(node) {
+      const parent = node.parent;
+      const {
+        arguments: [, value]
+      } = parent;
+      if (isArrayExpression(value) || isObjectExpression(value)) {
+        return;
+      }
+      report(node);
+    }
+    return {
+      "CallExpression[callee.property.name='pipe'] > CallExpression[typeArguments.params.length > 0] > Identifier": report,
+      "NewExpression[typeArguments.params.length > 0] > Identifier[name='BehaviorSubject']": checkBehaviorSubjects,
+      "CallExpression[typeArguments.params.length > 0] > Identifier[name=/^(from|of)$/]": report,
+      "NewExpression[typeArguments.params.length > 0][arguments.0.value='N'] > Identifier[name='Notification']": checkNotifications
+    };
+  }
+});
+
+const defaultAllowedTypesRegExp = /^EventEmitter$/;
+const defaultOptions$8 = [];
+const noExposedSubjectsRule = ruleCreator({
+  defaultOptions: defaultOptions$8,
+  meta: {
+    docs: {
+      description: "Forbids exposed (i.e. non-private) subjects.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Subject '{{subject}}' must be private.",
+      forbiddenAllowProtected: "Subject '{{subject}}' must be private or protected."
+    },
+    schema: [
+      {
+        properties: {
+          allowProtected: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-exposed-subjects",
+  create: (context) => {
+    const [config = {}] = context.options;
+    const { allowProtected = false } = config;
+    const { couldBeSubject, couldBeType } = getTypeServices(context);
+    const messageId = allowProtected ? "forbiddenAllowProtected" : "forbidden";
+    const accessibilityRexExp = allowProtected ? /^(private|protected)$/ : /^private$/;
+    function isSubject(node) {
+      return couldBeSubject(node) && !couldBeType(node, defaultAllowedTypesRegExp);
+    }
+    return {
+      [`PropertyDefinition[accessibility!=${accessibilityRexExp}]`]: (node) => {
+        if (isSubject(node)) {
+          const { key } = node;
+          if (isIdentifier(key)) {
+            context.report({
+              messageId,
+              node: key,
+              data: {
+                subject: key.name
+              }
+            });
+          }
+        }
+      },
+      [`MethodDefinition[kind='constructor'] > FunctionExpression > TSParameterProperty[accessibility!=${accessibilityRexExp}] > Identifier`]: (node) => {
+        if (isSubject(node)) {
+          const { loc } = node;
+          context.report({
+            messageId,
+            loc: {
+              ...loc,
+              end: {
+                ...loc.start,
+                column: loc.start.column + node.name.length
+              }
+            },
+            data: {
+              subject: node.name
+            }
+          });
+        }
+      },
+      [`MethodDefinition[accessibility!=${accessibilityRexExp}][kind=/^(get|set)$/]`]: (node) => {
+        if (isSubject(node)) {
+          const key = node.key;
+          context.report({
+            messageId,
+            node: key,
+            data: {
+              subject: key.name
+            }
+          });
+        }
+      },
+      [`MethodDefinition[accessibility!=${accessibilityRexExp}][kind='method']`]: (node) => {
+        const functionExpression = node.value;
+        const returnType = functionExpression.returnType;
+        if (!returnType) {
+          return;
+        }
+        const typeAnnotation = returnType.typeAnnotation;
+        if (!typeAnnotation) {
+          return;
+        }
+        if (isSubject(typeAnnotation)) {
+          const key = node.key;
+          context.report({
+            messageId,
+            node: key,
+            data: {
+              subject: key.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const noFinnishRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the use of Finnish notation.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Finnish notation is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-finnish",
+  create: (context) => {
+    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
+    const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
+    function checkNode(nameNode, typeNode) {
+      if (couldBeObservable(typeNode || nameNode) || couldReturnObservable(typeNode || nameNode)) {
+        const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
+        if (/[$]+$/.test(tsNode.getText())) {
+          context.report({
+            loc: getLoc(tsNode),
+            messageId: "forbidden"
+          });
+        }
+      }
+    }
+    return {
+      "ArrayPattern > Identifier[name=/[$]+$/]": (node) => {
+        checkNode(node);
+      },
+      "ArrowFunctionExpression > Identifier[name=/[$]+$/]": (node) => {
+        const parent = node.parent;
+        if (node !== parent.body) {
+          checkNode(node);
+        }
+      },
+      "PropertyDefinition[key.name=/[$]+$/] > Identifier": (node) => {
+        checkNode(node, node.parent);
+      },
+      "FunctionDeclaration > Identifier[name=/[$]+$/]": (node) => {
+        const parent = node.parent;
+        if (node === parent.id) {
+          checkNode(node, parent);
+        } else {
+          checkNode(node);
+        }
+      },
+      "FunctionExpression > Identifier[name=/[$]+$/]": (node) => {
+        const parent = node.parent;
+        if (node === parent.id) {
+          checkNode(node, parent);
+        } else {
+          checkNode(node);
+        }
+      },
+      "MethodDefinition[key.name=/[$]+$/]": (node) => {
+        checkNode(node.key, node);
+      },
+      "ObjectExpression > Property[computed=false][key.name=/[$]+$/]": (node) => {
+        checkNode(node.key);
+      },
+      "ObjectPattern > Property[value.name=/[$]+$/]": (node) => {
+        checkNode(node.value);
+      },
+      "TSCallSignatureDeclaration > Identifier[name=/[$]+$/]": (node) => {
+        checkNode(node);
+      },
+      "TSConstructSignatureDeclaration > Identifier[name=/[$]+$/]": (node) => {
+        checkNode(node);
+      },
+      "TSParameterProperty > Identifier[name=/[$]+$/]": (node) => {
+        checkNode(node);
+      },
+      "TSPropertySignature > Identifier[name=/[$]+$/]": (node) => {
+        checkNode(node, node.parent);
+      },
+      "TSMethodSignature > Identifier[name=/[$]+$/]": (node) => {
+        const parent = node.parent;
+        if (node === parent.key) {
+          checkNode(node, parent);
+        } else {
+          checkNode(node);
+        }
+      },
+      "VariableDeclarator[id.name=/[$]+$/]": (node) => {
+        checkNode(node.id, node.init ?? node);
+      }
+    };
+  }
+});
+
+const noIgnoredErrorRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the calling of `subscribe` without specifying an error handler.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Calling subscribe without an error handler is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-error",
+  create: (context) => {
+    const { couldBeObservable, couldBeFunction } = 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])) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const noIgnoredNotifierRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids observables not composed from the `repeatWhen` or `retryWhen` notifier.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Ignoring the notifier is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-notifier",
+  create: (context) => {
+    const { couldBeMonoTypeOperatorFunction } = getTypeServices(context);
+    const entries = [];
+    function getEntry() {
+      const { length, [length - 1]: entry } = entries;
+      return entry;
+    }
+    return {
+      "CallExpression[callee.name=/^(repeatWhen|retryWhen)$/]": (node) => {
+        if (couldBeMonoTypeOperatorFunction(node)) {
+          const [arg] = node.arguments;
+          if (isArrowFunctionExpression(arg) || isFunctionExpression(arg)) {
+            const [param] = arg.params;
+            if (param) {
+              entries.push({
+                node,
+                param,
+                sightings: 0
+              });
+            } else {
+              context.report({
+                messageId: "forbidden",
+                node: node.callee
+              });
+            }
+          }
+        }
+      },
+      "CallExpression[callee.name=/^(repeatWhen|retryWhen)$/]:exit": (node) => {
+        const entry = getEntry();
+        if (!entry) {
+          return;
+        }
+        if (entry.node === node) {
+          if (entry.sightings < 2) {
+            context.report({
+              messageId: "forbidden",
+              node: node.callee
+            });
+          }
+          entries.pop();
+        }
+      },
+      "Identifier": (node) => {
+        const entry = getEntry();
+        if (!entry) {
+          return;
+        }
+        if (node.name === entry.param.name) {
+          ++entry.sightings;
+        }
+      }
+    };
+  }
+});
+
+const noIgnoredObservableRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the ignoring of observables returned by functions.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Ignoring a returned Observable is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-observable",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    return {
+      "ExpressionStatement > CallExpression": (node) => {
+        if (couldBeObservable(node)) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const noIgnoredReplayBufferRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.",
+      recommended: true
+    },
+    messages: {
+      forbidden: "Ignoring the buffer size is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-replay-buffer",
+  create: (context) => {
+    function checkNode(node, { arguments: args }) {
+      if (!args || args.length === 0) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+      }
+    }
+    return {
+      "NewExpression > Identifier[name='ReplaySubject']": (node) => {
+        const newExpression = node.parent;
+        checkNode(node, newExpression);
+      },
+      "NewExpression > MemberExpression > Identifier[name='ReplaySubject']": (node) => {
+        const memberExpression = node.parent;
+        const newExpression = memberExpression.parent;
+        checkNode(node, newExpression);
+      },
+      "CallExpression > Identifier[name=/^(publishReplay|shareReplay)$/]": (node) => {
+        const callExpression = node.parent;
+        checkNode(node, callExpression);
+      }
+    };
+  }
+});
+
+const noIgnoredSubscribeRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the calling of `subscribe` without specifying arguments.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Calling subscribe without arguments is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-subscribe",
+  create: (context) => {
+    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    return {
+      "CallExpression[arguments.length = 0][callee.property.name='subscribe']": (node) => {
+        const callee = node.callee;
+        if (couldBeObservable(callee.object) || couldBeType(callee.object, "Subscribable")) {
+          context.report({
+            messageId: "forbidden",
+            node: callee.property
+          });
+        }
+      }
+    };
+  }
+});
+
+const noIgnoredSubscriptionRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids ignoring the subscription returned by `subscribe`.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Ignoring returned subscriptions is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-subscription",
+  create: (context) => {
+    const { couldBeObservable, couldBeType } = 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")) {
+            return;
+          }
+          context.report({
+            messageId: "forbidden",
+            node: node.property
+          });
+        }
+      }
+    };
+  }
+});
+
+const noIgnoredTakewhileValueRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids ignoring the value within `takeWhile`.",
+      recommended: true
+    },
+    messages: {
+      forbidden: "Ignoring the value within takeWhile is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-takewhile-value",
+  create: (context) => {
+    function checkNode(expression) {
+      const scope = context.sourceCode.getScope(expression);
+      if (!isImport(scope, "takeWhile", /^rxjs\/?/)) {
+        return;
+      }
+      let ignored = true;
+      const [param] = expression.params;
+      if (param) {
+        if (isIdentifier(param)) {
+          const variable = scope.variables.find(
+            ({ name }) => name === param.name
+          );
+          if (variable && variable.references.length > 0) {
+            ignored = false;
+          }
+        } else if (isArrayPattern(param)) {
+          ignored = false;
+        } else if (isObjectPattern(param)) {
+          ignored = false;
+        }
+      }
+      if (ignored) {
+        context.report({
+          messageId: "forbidden",
+          node: expression
+        });
+      }
+    }
+    return {
+      "CallExpression[callee.name='takeWhile'] > ArrowFunctionExpression": (node) => {
+        checkNode(node);
+      },
+      "CallExpression[callee.name='takeWhile'] > FunctionExpression": (node) => {
+        checkNode(node);
+      }
+    };
+  }
+});
+
+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,
+  meta: {
+    docs: {
+      description: "Forbids implicit `any` error parameters in `catchError` operators.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      explicitAny: "Explicit `any` in `catchError`.",
+      implicitAny: "Implicit `any` in `catchError`.",
+      narrowed: "Error type must be `unknown` or `any`.",
+      suggestExplicitUnknown: "Use `unknown` instead, this will force you to explicitly and safely assert the type is correct."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowExplicitAny: {
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: "no-implicit-any-catch",
+  create: (context) => {
+    const [config = {}] = context.options;
+    const { allowExplicitAny = false } = config;
+    const { couldBeObservable } = getTypeServices(context);
+    const sourceCode = context.sourceCode;
+    function checkCallback(callback) {
+      if (isArrowFunctionExpression(callback) || isFunctionExpression(callback)) {
+        const [param] = callback.params;
+        if (!param) {
+          return;
+        }
+        if (hasTypeAnnotation(param)) {
+          const { typeAnnotation } = param;
+          const {
+            typeAnnotation: { type }
+          } = typeAnnotation;
+          if (type === utils.AST_NODE_TYPES.TSAnyKeyword) {
+            let fix = function(fixer) {
+              return fixer.replaceText(typeAnnotation, ": unknown");
+            };
+            if (allowExplicitAny) {
+              return;
+            }
+            context.report({
+              fix,
+              messageId: "explicitAny",
+              node: param,
+              suggest: [
+                {
+                  messageId: "suggestExplicitUnknown",
+                  fix
+                }
+              ]
+            });
+          } else if (type !== utils.AST_NODE_TYPES.TSUnknownKeyword) {
+            let fix = function(fixer) {
+              return fixer.replaceText(typeAnnotation, ": unknown");
+            };
+            context.report({
+              messageId: "narrowed",
+              node: param,
+              suggest: [
+                {
+                  messageId: "suggestExplicitUnknown",
+                  fix
+                }
+              ]
+            });
+          }
+        } else {
+          let fix = function(fixer) {
+            if (isParenthesised(sourceCode, param)) {
+              return fixer.insertTextAfter(param, ": unknown");
+            }
+            return [
+              fixer.insertTextBefore(param, "("),
+              fixer.insertTextAfter(param, ": unknown)")
+            ];
+          };
+          context.report({
+            fix,
+            messageId: "implicitAny",
+            node: param,
+            suggest: [
+              {
+                messageId: "suggestExplicitUnknown",
+                fix
+              }
+            ]
+          });
+        }
+      }
+    }
+    return {
+      "CallExpression[callee.name='catchError']": (node) => {
+        const [callback] = node.arguments;
+        if (!callback) {
+          return;
+        }
+        checkCallback(callback);
+      },
+      "CallExpression[callee.property.name='subscribe'],CallExpression[callee.name='tap']": (node) => {
+        const { callee } = node;
+        if (isMemberExpression(callee) && !couldBeObservable(callee.object)) {
+          return;
+        }
+        const [observer, callback] = node.arguments;
+        if (callback) {
+          checkCallback(callback);
+        } else if (observer && isObjectExpression(observer)) {
+          const errorProperty = observer.properties.find(
+            (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error"
+          );
+          if (errorProperty) {
+            checkCallback(errorProperty.value);
+          }
+        }
+      }
+    };
+  }
+});
+
+const noIndexRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the importation from index modules.",
+      recommended: true
+    },
+    messages: {
+      forbidden: "RxJS imports from index modules are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-index",
+  create: (context) => {
+    return {
+      [String.raw`ImportDeclaration Literal[value=/^rxjs(?:\u002f\w+)?\u002findex/]`]: (node) => {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+      }
+    };
+  }
+});
+
+const noInternalRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the importation of internals.",
+      recommended: true
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      forbidden: "RxJS imports from internal are forbidden.",
+      suggest: "Import from a non-internal location."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-internal",
+  create: (context) => {
+    function getReplacement(location) {
+      const match = /^\s*('|")/.exec(location);
+      if (!match) {
+        return void 0;
+      }
+      const [, quote] = match;
+      if (/^['"]rxjs\/internal\/ajax/.test(location)) {
+        return `${quote}rxjs/ajax${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/observable\/dom\/fetch/.test(location)) {
+        return `${quote}rxjs/fetch${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/observable\/dom\/webSocket/i.test(location)) {
+        return `${quote}rxjs/webSocket${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/observable/.test(location)) {
+        return `${quote}rxjs${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/operators/.test(location)) {
+        return `${quote}rxjs/operators${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/scheduled/.test(location)) {
+        return `${quote}rxjs${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/scheduler/.test(location)) {
+        return `${quote}rxjs${quote}`;
+      }
+      if (/^['"]rxjs\/internal\/testing/.test(location)) {
+        return `${quote}rxjs/testing${quote}`;
+      }
+      return void 0;
+    }
+    return {
+      [String.raw`ImportDeclaration Literal[value=/^rxjs\u002finternal/]`]: (node) => {
+        const replacement = getReplacement(node.raw);
+        if (replacement) {
+          let fix = function(fixer) {
+            return fixer.replaceText(node, replacement);
+          };
+          context.report({
+            fix,
+            messageId: "forbidden",
+            node,
+            suggest: [{ fix, messageId: "suggest" }]
+          });
+        } else {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const noNestedSubscribeRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the calling of `subscribe` within a `subscribe` callback.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Nested subscribe calls are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-nested-subscribe",
+  create: (context) => {
+    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    const argumentsMap = /* @__PURE__ */ new WeakMap();
+    return {
+      [`CallExpression > MemberExpression[property.name='subscribe']`]: (node) => {
+        if (!couldBeObservable(node.object) && !couldBeType(node.object, "Subscribable")) {
+          return;
+        }
+        const callExpression = node.parent;
+        let parent = callExpression.parent;
+        while (parent) {
+          if (argumentsMap.has(parent)) {
+            context.report({
+              messageId: "forbidden",
+              node: node.property
+            });
+            return;
+          }
+          parent = parent.parent;
+        }
+        for (const arg of callExpression.arguments) {
+          argumentsMap.set(arg);
+        }
+      }
+    };
+  }
+});
+
+const noRedundantNotifyRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids redundant notifications from completed or errored observables.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Redundant notifications are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-redundant-notify",
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+    const { couldBeType } = getTypeServices(context);
+    return {
+      "ExpressionStatement[expression.callee.property.name=/^(complete|error)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error)$/]": (node) => {
+        const parent = node.parent;
+        if (!parent) {
+          return;
+        }
+        if (!isBlockStatement(parent) && !isProgram(parent)) {
+          return;
+        }
+        const { body } = parent;
+        const index = body.indexOf(node);
+        const sibling = body[index - 1];
+        if (getExpressionText(sibling, sourceCode) !== getExpressionText(node, sourceCode)) {
+          return;
+        }
+        if (!isExpressionObserver(sibling, couldBeType) || !isExpressionObserver(node, couldBeType)) {
+          return;
+        }
+        const { expression } = node;
+        if (isCallExpression(expression)) {
+          const { callee } = expression;
+          if (isMemberExpression(callee)) {
+            const { property } = callee;
+            if (isIdentifier(property)) {
+              context.report({
+                messageId: "forbidden",
+                node: property
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+function getExpressionText(expressionStatement, sourceCode) {
+  if (!isCallExpression(expressionStatement.expression)) {
+    return void 0;
+  }
+  const callExpression = expressionStatement.expression;
+  if (!isMemberExpression(callExpression.callee)) {
+    return void 0;
+  }
+  const { object } = callExpression.callee;
+  return sourceCode.getText(object);
+}
+function isExpressionObserver(expressionStatement, couldBeType) {
+  if (!isCallExpression(expressionStatement.expression)) {
+    return false;
+  }
+  const callExpression = expressionStatement.expression;
+  if (!isMemberExpression(callExpression.callee)) {
+    return false;
+  }
+  const { object } = callExpression.callee;
+  return couldBeType(object, /^(Subject|Subscriber)$/);
+}
+
+const defaultOptions$6 = [];
+const noSharereplayRule = ruleCreator({
+  defaultOptions: defaultOptions$6,
+  meta: {
+    docs: {
+      description: "Forbids using the `shareReplay` operator.",
+      recommended: true
+    },
+    messages: {
+      forbidden: "shareReplay is forbidden.",
+      forbiddenWithoutConfig: "shareReplay is forbidden unless a config argument is passed."
+    },
+    schema: [
+      {
+        properties: {
+          allowConfig: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-sharereplay",
+  create: (context) => {
+    const [config = {}] = context.options;
+    const { allowConfig = true } = config;
+    return {
+      "CallExpression[callee.name='shareReplay']": (node) => {
+        let report = true;
+        if (allowConfig) {
+          report = node.arguments.length !== 1 || node.arguments[0].type !== utils.AST_NODE_TYPES.ObjectExpression;
+        }
+        if (report) {
+          context.report({
+            messageId: allowConfig ? "forbiddenWithoutConfig" : "forbidden",
+            node: node.callee
+          });
+        }
+      }
+    };
+  }
+});
+
+const noSubclassRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids subclassing RxJS classes.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Subclassing RxJS classes is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-subclass",
+  create: (context) => {
+    const { couldBeType } = getTypeServices(context);
+    const queryNames = [
+      "AsyncSubject",
+      "BehaviorSubject",
+      "Observable",
+      "ReplaySubject",
+      "Scheduler",
+      "Subject",
+      "Subscriber"
+    ];
+    return {
+      [`ClassDeclaration[superClass.name=/^(${queryNames.join(
+        "|"
+      )})$/] > Identifier.superClass`]: (node) => {
+        if (queryNames.some(
+          (name) => couldBeType(node, name, { name: /[/\\]rxjs[/\\]/ })
+        )) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const noSubjectUnsubscribeRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids calling the `unsubscribe` method of a subject instance.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Calling unsubscribe on a subject is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-subject-unsubscribe",
+  create: (context) => {
+    const { couldBeSubject, couldBeSubscription } = getTypeServices(context);
+    return {
+      "MemberExpression[property.name='unsubscribe']": (node) => {
+        if (couldBeSubject(node.object)) {
+          context.report({
+            messageId: "forbidden",
+            node: node.property
+          });
+        }
+      },
+      "CallExpression[callee.property.name='add'][arguments.length > 0]": (node) => {
+        const memberExpression = node.callee;
+        if (couldBeSubscription(memberExpression.object)) {
+          const [arg] = node.arguments;
+          if (couldBeSubject(arg)) {
+            context.report({
+              messageId: "forbidden",
+              node: arg
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+const noSubjectValueRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids accessing the `value` property of a `BehaviorSubject` instance.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Accessing the value property of a BehaviorSubject is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-subject-value",
+  create: (context) => {
+    const { couldBeBehaviorSubject } = getTypeServices(context);
+    return {
+      "Identifier[name=/^(value|getValue)$/]": (node) => {
+        const parent = node.parent;
+        if (!parent || !("object" in parent)) {
+          return;
+        }
+        if (couldBeBehaviorSubject(parent.object)) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const noSubscribeHandlersRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the passing of handlers to `subscribe`.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Passing handlers to subscribe is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-subscribe-handlers",
+  create: (context) => {
+    const { couldBeObservable, couldBeType } = getTypeServices(context);
+    return {
+      "CallExpression[arguments.length > 0][callee.property.name='subscribe']": (node) => {
+        const callee = node.callee;
+        if (couldBeObservable(callee.object) || couldBeType(callee.object, "Subscribable")) {
+          context.report({
+            messageId: "forbidden",
+            node: callee.property
+          });
+        }
+      }
+    };
+  }
+});
+
+const noTapRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: "Forbids the use of the `tap` operator."
+    },
+    messages: {
+      forbidden: "The tap operator is forbidden."
+    },
+    replacedBy: ["ban-operators"],
+    schema: [],
+    type: "problem"
+  },
+  name: "no-tap",
+  create: (context) => {
+    return {
+      [String.raw`ImportDeclaration[source.value=/^rxjs(\u002foperators)?$/] > ImportSpecifier[imported.name='tap']`]: (node) => {
+        const { loc } = node;
+        context.report({
+          messageId: "forbidden",
+          loc: {
+            ...loc,
+            end: {
+              ...loc.start,
+              column: loc.start.column + 3
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+const noTopromiseRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the use of the `toPromise` method.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "The toPromise method is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-topromise",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    return {
+      [`MemberExpression[property.name="toPromise"]`]: (node) => {
+        if (couldBeObservable(node.object)) {
+          context.report({
+            messageId: "forbidden",
+            node: node.property
+          });
+        }
+      }
+    };
+  }
+});
+
+const noUnboundMethodsRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids the passing of unbound methods.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Unbound methods are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-unbound-methods",
+  create: (context) => {
+    const { couldBeObservable, couldBeSubscription, getType } = getTypeServices(context);
+    const nodeMap = /* @__PURE__ */ new WeakMap();
+    function mapArguments(node) {
+      node.arguments.filter(isMemberExpression).forEach((arg) => {
+        const argType = getType(arg);
+        if (argType.getCallSignatures().length > 0) {
+          nodeMap.set(arg);
+        }
+      });
+    }
+    function isObservableOrSubscription(node, action) {
+      if (!isMemberExpression(node.callee)) {
+        return;
+      }
+      if (couldBeObservable(node.callee.object) || couldBeSubscription(node.callee.object)) {
+        action(node);
+      }
+    }
+    return {
+      "CallExpression[callee.property.name='pipe']": (node) => {
+        isObservableOrSubscription(node, ({ arguments: args }) => {
+          args.filter(isCallExpression).forEach(mapArguments);
+        });
+      },
+      "CallExpression[callee.property.name=/^(add|subscribe)$/]": (node) => {
+        isObservableOrSubscription(node, mapArguments);
+      },
+      "NewExpression[callee.name='Subscription']": mapArguments,
+      "ThisExpression": (node) => {
+        let parent = node.parent;
+        while (parent) {
+          if (nodeMap.has(parent)) {
+            context.report({
+              messageId: "forbidden",
+              node: parent
+            });
+            return;
+          }
+          parent = parent.parent;
+        }
+      }
+    };
+  }
+});
+
+const defaultOptions$5 = [];
+const noUnsafeCatchRule = ruleCreator({
+  defaultOptions: defaultOptions$5,
+  meta: {
+    docs: {
+      description: "Forbids unsafe `catchError` usage in effects and epics.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Unsafe catchError usage in effects and epics are forbidden."
+    },
+    schema: [
+      {
+        properties: {
+          observable: { type: "string" }
+        },
+        type: "object",
+        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.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-unsafe-catch",
+  create: (context) => {
+    const invalidOperatorsRegExp = /^(catchError)$/;
+    const [config = {}] = context.options;
+    const { observable = defaultObservable } = config;
+    const observableRegExp = new RegExp(observable);
+    const { couldBeObservable } = getTypeServices(context);
+    function isUnsafe([arg]) {
+      if (arg && (isFunctionDeclaration(arg) || isArrowFunctionExpression(arg))) {
+        return arg.params.length < 2;
+      }
+      return false;
+    }
+    function checkNode(node) {
+      if (!node.arguments || !couldBeObservable(node)) {
+        return;
+      }
+      node.arguments.forEach((arg) => {
+        if (isCallExpression(arg) && isIdentifier(arg.callee)) {
+          if (invalidOperatorsRegExp.test(arg.callee.name) && isUnsafe(arg.arguments)) {
+            context.report({
+              messageId: "forbidden",
+              node: arg.callee
+            });
+          }
+        }
+      });
+    }
+    return {
+      [`CallExpression[callee.property.name='pipe'][callee.object.name=${observableRegExp}]`]: checkNode,
+      [`CallExpression[callee.property.name='pipe'][callee.object.property.name=${observableRegExp}]`]: checkNode
+    };
+  }
+});
+
+const defaultOptions$4 = [];
+const noUnsafeFirstRule = ruleCreator({
+  defaultOptions: defaultOptions$4,
+  meta: {
+    docs: {
+      description: "Forbids unsafe `first`/`take` usage in effects and epics.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Unsafe first and take usage in effects and epics are forbidden."
+    },
+    schema: [
+      {
+        properties: {
+          observable: { type: "string" }
+        },
+        type: "object",
+        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.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-unsafe-first",
+  create: (context) => {
+    const invalidOperatorsRegExp = /^(take|first)$/;
+    const [config = {}] = context.options;
+    const { observable = defaultObservable } = config;
+    const observableRegExp = new RegExp(observable);
+    const { couldBeObservable } = getTypeServices(context);
+    const nodes = [];
+    function checkNode(node) {
+      if (!node.arguments || !couldBeObservable(node)) {
+        return;
+      }
+      node.arguments.forEach((arg) => {
+        if (isCallExpression(arg) && isIdentifier(arg.callee)) {
+          if (invalidOperatorsRegExp.test(arg.callee.name)) {
+            context.report({
+              messageId: "forbidden",
+              node: arg.callee
+            });
+          }
+        }
+      });
+    }
+    return {
+      [`CallExpression[callee.property.name='pipe'][callee.object.name=${observableRegExp}]`]: (node) => {
+        if (nodes.push(node) === 1) {
+          checkNode(node);
+        }
+      },
+      [`CallExpression[callee.property.name='pipe'][callee.object.name=${observableRegExp}]:exit`]: () => {
+        nodes.pop();
+      },
+      [`CallExpression[callee.property.name='pipe'][callee.object.property.name=${observableRegExp}]`]: (node) => {
+        if (nodes.push(node) === 1) {
+          checkNode(node);
+        }
+      },
+      [`CallExpression[callee.property.name='pipe'][callee.object.property.name=${observableRegExp}]:exit`]: () => {
+        nodes.pop();
+      }
+    };
+  }
+});
+
+const noUnsafeSubjectNext = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids unsafe optional `next` calls.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Unsafe optional next calls are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-unsafe-subject-next",
+  create: (context) => {
+    const { getType, typeChecker } = getTypeServices(context);
+    return {
+      [`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")) {
+            const [typeArg] = typeChecker.getTypeArguments(type);
+            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Any)) {
+              return;
+            }
+            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Unknown)) {
+              return;
+            }
+            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Void)) {
+              return;
+            }
+            if (tsutils.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils__namespace$1.isTypeFlagSet(t, ts__namespace.TypeFlags.Void)
+            )) {
+              return;
+            }
+            context.report({
+              messageId: "forbidden",
+              node: node.callee.property
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+const defaultOptions$3 = [];
+const noUnsafeSwitchmapRule = ruleCreator({
+  defaultOptions: defaultOptions$3,
+  meta: {
+    docs: {
+      description: "Forbids unsafe `switchMap` usage in effects and epics.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Unsafe switchMap usage in effects and epics is forbidden."
+    },
+    schema: [
+      {
+        properties: {
+          allow: {
+            oneOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          disallow: {
+            oneOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          observable: {
+            oneOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          }
+        },
+        type: "object",
+        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
+          \`switchMap\` is allowed will depend upon the matching of action types with \`allow\` or \`disallow\`.
+          The \`observable\` property is used to identify the action observables from which effects and epics are composed.
+        `
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-unsafe-switchmap",
+  create: (context) => {
+    const defaultDisallow = [
+      "add",
+      "create",
+      "delete",
+      "post",
+      "put",
+      "remove",
+      "set",
+      "update"
+    ];
+    let allowRegExp;
+    let disallowRegExp;
+    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);
+    } else {
+      allowRegExp = void 0;
+      disallowRegExp = createRegExpForWords(defaultDisallow);
+      observableRegExp = new RegExp(defaultObservable);
+    }
+    const { couldBeObservable } = getTypeServices(context);
+    function shouldDisallow(args) {
+      const names = args.map((arg) => {
+        if (isLiteral(arg) && typeof arg.value === "string") {
+          return arg.value;
+        }
+        if (isIdentifier(arg)) {
+          return arg.name;
+        }
+        if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+          return arg.property.name;
+        }
+        return "";
+      }).map((name) => decamelize__default(name));
+      if (allowRegExp) {
+        return !names.every((name) => allowRegExp?.test(name));
+      }
+      if (disallowRegExp) {
+        return names.some((name) => disallowRegExp?.test(name));
+      }
+      return false;
+    }
+    function checkNode(node) {
+      if (!node.arguments || !couldBeObservable(node)) {
+        return;
+      }
+      const hasUnsafeOfType = node.arguments.some((arg) => {
+        if (isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "ofType") {
+          return shouldDisallow(arg.arguments);
+        }
+        return false;
+      });
+      if (!hasUnsafeOfType) {
+        return;
+      }
+      node.arguments.forEach((arg) => {
+        if (isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "switchMap") {
+          context.report({
+            messageId: "forbidden",
+            node: arg.callee
+          });
+        }
+      });
+    }
+    return {
+      [`CallExpression[callee.property.name='pipe'][callee.object.name=${observableRegExp}]`]: checkNode,
+      [`CallExpression[callee.property.name='pipe'][callee.object.property.name=${observableRegExp}]`]: checkNode
+    };
+  }
+});
+
+const defaultOptions$2 = [];
+const noUnsafeTakeuntilRule = ruleCreator({
+  defaultOptions: defaultOptions$2,
+  meta: {
+    docs: {
+      description: "Forbids the application of operators after `takeUntil`.",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Applying operators after takeUntil is forbidden."
+    },
+    schema: [
+      {
+        properties: {
+          alias: { type: "array", items: { type: "string" } },
+          allow: { type: "array", items: { type: "string" } }
+        },
+        type: "object",
+        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\`.`
+      }
+    ],
+    type: "problem"
+  },
+  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) {
+      checkedOperatorsRegExp = new RegExp(
+        `^(${alias.concat("takeUntil").join("|")})$`
+      );
+    }
+    const { couldBeObservable } = getTypeServices(context);
+    function checkNode(node) {
+      const pipeCallExpression = node.parent;
+      if (!pipeCallExpression.arguments || !couldBeObservable(pipeCallExpression)) {
+        return;
+      }
+      pipeCallExpression.arguments.reduceRight((state, arg) => {
+        if (state === "taken") {
+          return state;
+        }
+        if (!isCallExpression(arg)) {
+          return "disallowed";
+        }
+        let operatorName;
+        if (isIdentifier(arg.callee)) {
+          operatorName = arg.callee.name;
+        } else if (isMemberExpression(arg.callee) && isIdentifier(arg.callee.property)) {
+          operatorName = arg.callee.property.name;
+        } else {
+          return "disallowed";
+        }
+        if (checkedOperatorsRegExp.test(operatorName)) {
+          if (state === "disallowed") {
+            context.report({
+              messageId: "forbidden",
+              node: arg.callee
+            });
+          }
+          return "taken";
+        }
+        if (!allow.includes(operatorName)) {
+          return "disallowed";
+        }
+        return state;
+      }, "allowed");
+    }
+    return {
+      [`CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=${checkedOperatorsRegExp}]`]: checkNode,
+      [`CallExpression[callee.property.name='pipe'] > CallExpression[callee.property.name=${checkedOperatorsRegExp}]`]: checkNode
+    };
+  }
+});
+
+const defaultOptions$1 = [];
+const preferObserverRule = ruleCreator({
+  defaultOptions: defaultOptions$1,
+  meta: {
+    docs: {
+      description: "Forbids the passing separate handlers to `subscribe` and `tap`.",
+      requiresTypeChecking: true
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      forbidden: "Passing separate handlers is forbidden; pass an observer instead."
+    },
+    schema: [
+      {
+        properties: {
+          allowNext: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "prefer-observer",
+  create: (context) => {
+    const { couldBeFunction, couldBeObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { allowNext = true } = config;
+    function checkArgs(callExpression, reportNode) {
+      const { arguments: args, callee } = callExpression;
+      if (isMemberExpression(callee) && !couldBeObservable(callee.object)) {
+        return;
+      }
+      function* fix(fixer) {
+        const sourceCode = context.sourceCode;
+        const [nextArg, errorArg, completeArg] = args;
+        const nextArgText = nextArg ? sourceCode.getText(nextArg) : "";
+        const errorArgText = errorArg ? sourceCode.getText(errorArg) : "";
+        const completeArgText = completeArg ? sourceCode.getText(completeArg) : "";
+        let observer = "{";
+        if (nextArgText && nextArgText !== "undefined" && nextArgText !== "null") {
+          observer += ` next: ${nextArgText}${isValidArgText(errorArgText) || isValidArgText(completeArgText) ? "," : ""}`;
+        }
+        if (errorArgText && errorArgText !== "undefined" && errorArgText !== "null") {
+          observer += ` error: ${errorArgText}${isValidArgText(completeArgText) ? "," : ""}`;
+        }
+        if (completeArgText && completeArgText !== "undefined" && completeArgText !== "null") {
+          observer += ` complete: ${completeArgText}`;
+        }
+        observer += " }";
+        yield fixer.replaceText(callExpression.arguments[0], observer);
+        const [, start] = callExpression.arguments[0].range;
+        const [, end] = callExpression.arguments[callExpression.arguments.length - 1].range;
+        yield fixer.removeRange([start, end]);
+      }
+      if (args.length > 1) {
+        context.report({
+          messageId: "forbidden",
+          node: reportNode,
+          fix,
+          suggest: [
+            {
+              messageId: "forbidden",
+              fix
+            }
+          ]
+        });
+      } else if (args.length === 1 && !allowNext) {
+        const [arg] = args;
+        if (isArrowFunctionExpression(arg) || isFunctionExpression(arg) || couldBeFunction(arg)) {
+          context.report({
+            messageId: "forbidden",
+            node: reportNode,
+            fix,
+            suggest: [
+              {
+                messageId: "forbidden",
+                fix
+              }
+            ]
+          });
+        }
+      }
+    }
+    return {
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name='tap']": (node) => {
+        checkArgs(node, node.callee);
+      },
+      "CallExpression[callee.property.name='subscribe']": (node) => {
+        checkArgs(node, node.callee.property);
+      }
+    };
+  }
+});
+function isValidArgText(argText) {
+  return argText && argText !== "undefined" && argText !== "null";
+}
+
+const defaultOptions = [];
+const suffixSubjectsRule = ruleCreator({
+  defaultOptions,
+  meta: {
+    docs: {
+      description: "Enforces the use of a suffix in subject identifiers.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: `Subject identifiers must end with "{{suffix}}".`
+    },
+    schema: [
+      {
+        properties: {
+          parameters: { type: "boolean" },
+          properties: { type: "boolean" },
+          suffix: { type: "string" },
+          types: { type: "object" },
+          variables: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "suffix-subjects",
+  create: (context) => {
+    const { esTreeNodeToTSNodeMap } = utils.ESLintUtils.getParserServices(context);
+    const { couldBeType } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const validate = {
+      parameters: true,
+      properties: true,
+      variables: true,
+      ...config
+    };
+    const types = [];
+    if (config.types) {
+      Object.entries(config.types).forEach(
+        ([key, validate2]) => {
+          types.push({ regExp: new RegExp(key), validate: validate2 });
+        }
+      );
+    } else {
+      types.push({
+        regExp: /^EventEmitter$/,
+        validate: false
+      });
+    }
+    const { suffix = "Subject" } = config;
+    const suffixRegex = new RegExp(
+      String.raw`${escapeRegExp(suffix)}\$?$`,
+      "i"
+    );
+    function checkNode(nameNode, typeNode) {
+      const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
+      const text = tsNode.getText();
+      if (!suffixRegex.test(text) && couldBeType(typeNode || nameNode, "Subject")) {
+        for (const type of types) {
+          const { regExp, validate: validate2 } = type;
+          if (couldBeType(typeNode || nameNode, regExp) && !validate2) {
+            return;
+          }
+        }
+        context.report({
+          data: { suffix },
+          loc: getLoc(tsNode),
+          messageId: "forbidden"
+        });
+      }
+    }
+    return {
+      "ArrayPattern > Identifier": (node) => {
+        const found = findParent(
+          node,
+          "ArrowFunctionExpression",
+          "FunctionDeclaration",
+          "FunctionExpression",
+          "VariableDeclarator"
+        );
+        if (!found) {
+          return;
+        }
+        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+          return;
+        }
+        if (!validate.parameters) {
+          return;
+        }
+        checkNode(node);
+      },
+      "ArrowFunctionExpression > Identifier": (node) => {
+        if (validate.parameters) {
+          const parent = node.parent;
+          if (node !== parent.body) {
+            checkNode(node);
+          }
+        }
+      },
+      "PropertyDefinition[computed=false]": (node) => {
+        const anyNode = node;
+        if (validate.properties) {
+          checkNode(anyNode.key);
+        }
+      },
+      "FunctionDeclaration > Identifier": (node) => {
+        if (validate.parameters) {
+          const parent = node.parent;
+          if (node !== parent.id) {
+            checkNode(node);
+          }
+        }
+      },
+      "FunctionExpression > Identifier": (node) => {
+        if (validate.parameters) {
+          const parent = node.parent;
+          if (node !== parent.id) {
+            checkNode(node);
+          }
+        }
+      },
+      "MethodDefinition[kind='get'][computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key, node);
+        }
+      },
+      "MethodDefinition[kind='set'][computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key, node);
+        }
+      },
+      "ObjectExpression > Property[computed=false] > Identifier": (node) => {
+        if (validate.properties) {
+          const parent = node.parent;
+          if (node === parent.key) {
+            checkNode(node);
+          }
+        }
+      },
+      "ObjectPattern > Property > Identifier": (node) => {
+        const found = findParent(
+          node,
+          "ArrowFunctionExpression",
+          "FunctionDeclaration",
+          "FunctionExpression",
+          "VariableDeclarator"
+        );
+        if (!found) {
+          return;
+        }
+        if (!validate.variables && found.type === utils.AST_NODE_TYPES.VariableDeclarator) {
+          return;
+        }
+        if (!validate.parameters) {
+          return;
+        }
+        const parent = node.parent;
+        if (node === parent.value) {
+          checkNode(node);
+        }
+      },
+      "TSCallSignatureDeclaration > Identifier": (node) => {
+        if (validate.parameters) {
+          checkNode(node);
+        }
+      },
+      "TSConstructSignatureDeclaration > Identifier": (node) => {
+        if (validate.parameters) {
+          checkNode(node);
+        }
+      },
+      "TSMethodSignature > Identifier": (node) => {
+        if (validate.parameters) {
+          checkNode(node);
+        }
+      },
+      "TSParameterProperty > Identifier": (node) => {
+        if (validate.parameters || validate.properties) {
+          checkNode(node);
+        }
+      },
+      "TSPropertySignature[computed=false]": (node) => {
+        if (validate.properties) {
+          checkNode(node.key);
+        }
+      },
+      "VariableDeclarator > Identifier": (node) => {
+        const parent = node.parent;
+        if (validate.variables && node === parent.id) {
+          checkNode(node);
+        }
+      }
+    };
+  }
+});
+
+const throwErrorRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforces the passing of `Error` values to error notifications.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Passing non-Error values are forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "throw-error",
+  create: (context) => {
+    const { esTreeNodeToTSNodeMap, program } = utils.ESLintUtils.getParserServices(context);
+    const { couldBeObservable, getType } = getTypeServices(context);
+    function checkNode(node) {
+      let type = getType(node);
+      if (tsutils.couldBeFunction(type)) {
+        const tsNode = esTreeNodeToTSNodeMap.get(node);
+        const annotation = tsNode.type;
+        const body = tsNode.body;
+        type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
+      }
+      if (!tsutils.isAny(type) && !tsutils.isUnknown(type) && !tsutils.couldBeType(type, /^(Error|DOMException)$/)) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+      }
+    }
+    return {
+      "ThrowStatement > *": checkNode,
+      "CallExpression[callee.name='throwError']": (node) => {
+        if (couldBeObservable(node)) {
+          const [arg] = node.arguments;
+          if (arg) {
+            checkNode(arg);
+          }
+        }
+      }
+    };
+  }
+});
+
+const plugin = {
+  meta: { name, version },
+  rules: {
+    "ban-observables": banObservablesRule,
+    "ban-operators": banOperatorsRule,
+    "finnish": finnishRule,
+    "just": justRule,
+    "macro": macroRule,
+    "no-async-subscribe": noAsyncSubscribeRule,
+    "no-compat": noCompatRule,
+    "no-connectable": noConnectableRule,
+    "no-create": noCreateRule,
+    "no-cyclic-action": noCyclicActionRule,
+    "no-explicit-generics": noExplicitGenericsRule,
+    "no-exposed-subjects": noExposedSubjectsRule,
+    "no-finnish": noFinnishRule,
+    "no-ignored-error": noIgnoredErrorRule,
+    "no-ignored-notifier": noIgnoredNotifierRule,
+    "no-ignored-observable": noIgnoredObservableRule,
+    "no-ignored-replay-buffer": noIgnoredReplayBufferRule,
+    "no-ignored-subscribe": noIgnoredSubscribeRule,
+    "no-ignored-subscription": noIgnoredSubscriptionRule,
+    "no-ignored-takewhile-value": noIgnoredTakewhileValueRule,
+    "no-implicit-any-catch": noImplicitAnyCatchRule,
+    "no-index": noIndexRule,
+    "no-internal": noInternalRule,
+    "no-nested-subscribe": noNestedSubscribeRule,
+    "no-redundant-notify": noRedundantNotifyRule,
+    "no-sharereplay": noSharereplayRule,
+    "no-subclass": noSubclassRule,
+    "no-subject-unsubscribe": noSubjectUnsubscribeRule,
+    "no-subject-value": noSubjectValueRule,
+    "no-subscribe-handlers": noSubscribeHandlersRule,
+    "no-tap": noTapRule,
+    "no-topromise": noTopromiseRule,
+    "no-unbound-methods": noUnboundMethodsRule,
+    "no-unsafe-catch": noUnsafeCatchRule,
+    "no-unsafe-first": noUnsafeFirstRule,
+    "no-unsafe-subject-next": noUnsafeSubjectNext,
+    "no-unsafe-switchmap": noUnsafeSwitchmapRule,
+    "no-unsafe-takeuntil": noUnsafeTakeuntilRule,
+    "prefer-observer": preferObserverRule,
+    "suffix-subjects": suffixSubjectsRule,
+    "throw-error": throwErrorRule
+  }
+};
+const configs = {
+  recommended: createRecommendedConfig(plugin)
+};
+const index = {
+  ...plugin,
+  configs
+};
+
+module.exports = index;