eslint-plugin-rxjs-x 0.9.4 → 1.0.0

package/dist/index.mjs

@@ -1,4576 +0,0 @@
-// package.json
-var name = "eslint-plugin-rxjs-x";
-var version = "0.9.4";
-
-// src/configs/recommended.ts
-var createRecommendedConfig = (plugin2) => ({
-  ...baseConfig,
-  name: "rxjs-x/recommended",
-  plugins: {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- "A type annotation is necessary."
-    "rxjs-x": plugin2
-  }
-});
-var createLegacyRecommendedConfig = () => ({
-  ...baseConfig,
-  plugins: ["rxjs-x"]
-});
-var baseConfig = {
-  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",
-    "rxjs-x/no-subject-unsubscribe": "error",
-    "rxjs-x/no-subscribe-in-pipe": "error",
-    "rxjs-x/no-topromise": "error",
-    "rxjs-x/no-unbound-methods": "error",
-    "rxjs-x/no-unsafe-subject-next": "error",
-    "rxjs-x/no-unsafe-takeuntil": "error",
-    "rxjs-x/prefer-observer": "error",
-    "rxjs-x/prefer-root-operators": "error",
-    "rxjs-x/throw-error": "error"
-  }
-};
-
-// src/configs/strict.ts
-var createStrictConfig = (plugin2) => ({
-  name: "rxjs-x/strict",
-  plugins: {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- "A type annotation is necessary."
-    "rxjs-x": plugin2
-  },
-  rules: {
-    "rxjs-x/no-async-subscribe": "error",
-    "rxjs-x/no-create": "error",
-    "rxjs-x/no-exposed-subjects": "error",
-    "rxjs-x/no-floating-observables": "error",
-    "rxjs-x/no-ignored-default-value": "error",
-    "rxjs-x/no-ignored-error": "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", {
-      allowExplicitAny: false
-    }],
-    "rxjs-x/no-index": "error",
-    "rxjs-x/no-internal": "error",
-    "rxjs-x/no-misused-observables": "error",
-    "rxjs-x/no-nested-subscribe": "error",
-    "rxjs-x/no-redundant-notify": "error",
-    "rxjs-x/no-sharereplay-before-takeuntil": "error",
-    "rxjs-x/no-sharereplay": "error",
-    "rxjs-x/no-subclass": "error",
-    "rxjs-x/no-subject-unsubscribe": "error",
-    "rxjs-x/no-subscribe-in-pipe": "error",
-    "rxjs-x/no-topromise": "error",
-    "rxjs-x/no-unbound-methods": "error",
-    "rxjs-x/no-unnecessary-collection": "error",
-    "rxjs-x/no-unsafe-subject-next": "error",
-    "rxjs-x/no-unsafe-takeuntil": "error",
-    "rxjs-x/prefer-observer": "error",
-    "rxjs-x/prefer-root-operators": "error",
-    "rxjs-x/throw-error": ["error", {
-      allowThrowingAny: false,
-      allowThrowingUnknown: false
-    }]
-  }
-});
-
-// src/rules/ban-observables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
-import { stripIndent } from "common-tags";
-
-// src/utils/create-regexp-for-words.ts
-function createRegExpForWords(config) {
-  if (!(config == null ? void 0 : 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);
-}
-
-// src/utils/escape-regexp.ts
-function escapeRegExp(text) {
-  return text.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-}
-
-// src/etc/could-be-function.ts
-import ts2 from "typescript";
-
-// src/etc/could-be-type.ts
-import * as tsutils from "ts-api-utils";
-import ts from "typescript";
-function couldBeType(type, name2, qualified) {
-  if (tsutils.isTypeReference(type)) {
-    type = type.target;
-  }
-  if (isType(type.symbol, name2, qualified)) {
-    return true;
-  }
-  if (type.aliasSymbol && isType(type.aliasSymbol, 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(symbol, name2, qualified) {
-  if (!symbol) {
-    return false;
-  }
-  if (qualified && !qualified.name.test(
-    qualified.typeChecker.getFullyQualifiedName(symbol)
-  )) {
-    return false;
-  }
-  return typeof name2 === "string" ? symbol.name === name2 : Boolean(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";
-  let parent = node.parent;
-  while (parent) {
-    switch (predicate(parent.type)) {
-      case "break":
-        return void 0;
-      case "return":
-        return parent;
-      default:
-        break;
-    }
-    parent = parent.parent;
-  }
-  return void 0;
-}
-
-// src/etc/get-loc.ts
-import ts3 from "typescript";
-function getLoc(node) {
-  const sourceFile = node.getSourceFile();
-  const start = ts3.getLineAndCharacterOfPosition(sourceFile, node.getStart());
-  const end = ts3.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
-  return {
-    start: {
-      line: start.line + 1,
-      column: start.character
-    },
-    end: {
-      line: end.line + 1,
-      column: end.character
-    }
-  };
-}
-
-// src/etc/get-type-services.ts
-import { ESLintUtils } from "@typescript-eslint/utils";
-import * as tsutils2 from "ts-api-utils";
-
-// src/etc/is.ts
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-function hasTypeAnnotation(node) {
-  return "typeAnnotation" in node && !!node.typeAnnotation;
-}
-function isAccessorProperty(node) {
-  return node.type === AST_NODE_TYPES.AccessorProperty;
-}
-function isArrayExpression(node) {
-  return node.type === AST_NODE_TYPES.ArrayExpression;
-}
-function isArrayPattern(node) {
-  return node.type === AST_NODE_TYPES.ArrayPattern;
-}
-function isArrowFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES.ArrowFunctionExpression;
-}
-function isBlockStatement(node) {
-  return node.type === AST_NODE_TYPES.BlockStatement;
-}
-function isCallExpression(node) {
-  return node.type === AST_NODE_TYPES.CallExpression;
-}
-function isChainExpression(node) {
-  return node.type === AST_NODE_TYPES.ChainExpression;
-}
-function isFunctionDeclaration(node) {
-  return node.type === AST_NODE_TYPES.FunctionDeclaration;
-}
-function isFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES.FunctionExpression;
-}
-function isIdentifier(node) {
-  return node.type === AST_NODE_TYPES.Identifier;
-}
-function isImportDeclaration(node) {
-  return node.type === AST_NODE_TYPES.ImportDeclaration;
-}
-function isImportNamespaceSpecifier(node) {
-  return node.type === AST_NODE_TYPES.ImportNamespaceSpecifier;
-}
-function isImportSpecifier(node) {
-  return node.type === AST_NODE_TYPES.ImportSpecifier;
-}
-function isJSXExpressionContainer(node) {
-  return node.type === AST_NODE_TYPES.JSXExpressionContainer;
-}
-function isLiteral(node) {
-  return node.type === AST_NODE_TYPES.Literal;
-}
-function isTemplateLiteral(node) {
-  return node.type === AST_NODE_TYPES.TemplateLiteral;
-}
-function isMemberExpression(node) {
-  return node.type === AST_NODE_TYPES.MemberExpression;
-}
-function isMethodDefinition(node) {
-  return node.type === AST_NODE_TYPES.MethodDefinition;
-}
-function isObjectExpression(node) {
-  return node.type === AST_NODE_TYPES.ObjectExpression;
-}
-function isObjectPattern(node) {
-  return node.type === AST_NODE_TYPES.ObjectPattern;
-}
-function isProgram(node) {
-  return node.type === AST_NODE_TYPES.Program;
-}
-function isProperty(node) {
-  return node.type === AST_NODE_TYPES.Property;
-}
-function isPropertyDefinition(node) {
-  return node.type === AST_NODE_TYPES.PropertyDefinition;
-}
-function isSpreadElement(node) {
-  return node.type === AST_NODE_TYPES.SpreadElement;
-}
-function isTSAsExpression(node) {
-  return node.type === AST_NODE_TYPES.TSAsExpression;
-}
-function isTSSatisfiesExpression(node) {
-  return node.type === AST_NODE_TYPES.TSSatisfiesExpression;
-}
-function isUnaryExpression(node) {
-  return node.type === AST_NODE_TYPES.UnaryExpression;
-}
-function isUnionType(node) {
-  return node.type === AST_NODE_TYPES.TSUnionType;
-}
-function isVariableDeclarator(node) {
-  return node.type === AST_NODE_TYPES.VariableDeclarator;
-}
-
-// src/etc/get-type-services.ts
-function getTypeServices(context) {
-  const services = ESLintUtils.getParserServices(context);
-  const { program, getTypeAtLocation } = services;
-  const typeChecker = program.getTypeChecker();
-  const couldBeType2 = (node, name2, qualified) => {
-    const type = getTypeAtLocation(node);
-    return couldBeType(
-      type,
-      name2,
-      qualified ? { ...qualified, typeChecker } : void 0
-    );
-  };
-  const couldReturnType = (node, name2, qualified) => {
-    const type = getTypeAtLocation(node);
-    for (const signature of tsutils2.getCallSignaturesOfType(type)) {
-      const returnType = signature.getReturnType();
-      if (couldBeType(
-        returnType,
-        name2,
-        qualified ? { ...qualified, typeChecker } : void 0
-      )) {
-        return true;
-      }
-    }
-    return false;
-  };
-  return {
-    couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
-    couldBeFunction: (node) => {
-      if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
-        return true;
-      }
-      return couldBeFunction(getTypeAtLocation(node));
-    },
-    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
-  };
-}
-
-// src/etc/is-import.ts
-import { DefinitionType } from "@typescript-eslint/scope-manager";
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
-function isImport(scope, name2, source) {
-  const variable = scope.variables.find((variable2) => variable2.name === name2);
-  if (variable) {
-    return variable.defs.some(
-      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES2.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
-    );
-  }
-  return scope.upper ? isImport(scope.upper, name2, source) : false;
-}
-
-// src/utils/find-is-last-operator-order-valid.ts
-function findIsLastOperatorOrderValid(pipeCallExpression, operatorsRegExp, allow) {
-  let isOrderValid = true;
-  let operatorNode;
-  for (let i = pipeCallExpression.arguments.length - 1; i >= 0; i--) {
-    const arg = pipeCallExpression.arguments[i];
-    if (operatorNode) {
-      break;
-    }
-    if (!isCallExpression(arg)) {
-      isOrderValid = false;
-      continue;
-    }
-    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 {
-      isOrderValid = false;
-      continue;
-    }
-    if (operatorsRegExp.test(operatorName)) {
-      operatorNode = arg.callee;
-      break;
-    }
-    if (!allow.includes(operatorName)) {
-      isOrderValid = false;
-      continue;
-    }
-  }
-  return { isOrderValid, operatorNode };
-}
-
-// src/utils/rule-creator.ts
-import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-var REPO_URL = "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x";
-var ruleCreator = ESLintUtils2.RuleCreator(
-  (name2) => `${REPO_URL}/blob/v${version}/docs/rules/${name2}.md`
-  // Ensure the resulting types are narrowed to exactly what each rule declares.
-);
-
-// src/rules/ban-observables.ts
-var defaultOptions = [];
-var banObservablesRule = ruleCreator({
-  defaultOptions,
-  meta: {
-    docs: {
-      description: "Disallow banned observable creators."
-    },
-    messages: {
-      forbidden: "RxJS observable is banned: {{name}}{{explanation}}."
-    },
-    schema: [
-      {
-        type: "object",
-        description: 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(name2) {
-      for (let b = 0, length = bans.length; b < length; ++b) {
-        const ban = bans[b];
-        if (ban.regExp.test(name2)) {
-          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
-          return {
-            messageId: "forbidden",
-            data: { name: name2, explanation }
-          };
-        }
-      }
-      return void 0;
-    }
-    return {
-      "ImportDeclaration[source.value='rxjs'] > ImportSpecifier": (node) => {
-        const identifier = node.imported;
-        const name2 = identifier.type === AST_NODE_TYPES3.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name2);
-        if (failure) {
-          context.report({
-            ...failure,
-            node: identifier
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/ban-operators.ts
-import { stripIndent as stripIndent2 } from "common-tags";
-var defaultOptions2 = [];
-var banOperatorsRule = ruleCreator({
-  defaultOptions: defaultOptions2,
-  meta: {
-    docs: {
-      description: "Disallow banned operators.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
-    },
-    schema: [
-      {
-        type: "object",
-        description: stripIndent2`
-          An object containing keys that are names of operators
-          and values that are either booleans or strings containing the explanation for the ban.`
-      }
-    ],
-    type: "problem"
-  },
-  name: "ban-operators",
-  create: (context) => {
-    const { couldBeType: couldBeType2 } = getTypeServices(context);
-    const bans = [];
-    const [config] = context.options;
-    if (!config) {
-      return {};
-    }
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== false) {
-        bans.push({
-          name: key,
-          explanation: typeof value === "string" ? value : ""
-        });
-      }
-    });
-    function checkNode(node) {
-      for (const ban of bans) {
-        if (couldBeType2(node, ban.name, { name: /[/\\]rxjs[/\\]/ })) {
-          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
-          context.report({
-            messageId: "forbidden",
-            data: { name: ban.name, explanation },
-            node
-          });
-          return;
-        }
-      }
-    }
-    return {
-      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name]": (node) => {
-        checkNode(node.callee);
-      },
-      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.type=\"MemberExpression\"]": (node) => {
-        const callee = node.callee;
-        checkNode(callee.property);
-      }
-    };
-  }
-});
-
-// src/rules/finnish.ts
-import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
-var defaultOptions3 = [];
-var baseShouldBeFinnish = "Finnish notation should be used here.";
-var finnishRule = ruleCreator({
-  defaultOptions: defaultOptions3,
-  meta: {
-    docs: {
-      description: "Enforce Finnish notation.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      shouldBeFinnish: baseShouldBeFinnish,
-      shouldBeFinnishProperty: `${baseShouldBeFinnish} Add a type annotation, assertion, or 'satisfies' to silence this rule.`,
-      shouldNotBeFinnish: "Finnish notation should not be used here."
-    },
-    schema: [
-      {
-        properties: {
-          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, except object literal keys (see "objects" option).' },
-          objects: { type: "boolean", description: "Require for object literal keys." },
-          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"
-      }
-    ],
-    type: "problem"
-  },
-  name: "finnish",
-  create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils3.getParserServices(context);
-    const {
-      couldBeObservable,
-      couldBeType: couldBeType2,
-      couldReturnObservable,
-      couldReturnType
-    } = getTypeServices(context);
-    const [config = {}] = context.options;
-    const { strict = false } = config;
-    const validate = {
-      functions: true,
-      methods: true,
-      parameters: true,
-      properties: true,
-      objects: 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, shouldMessage = "shouldBeFinnish") {
-      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: shouldMessage
-        });
-      };
-      const shouldNotBeFinnish = hasFinnish ? () => {
-        context.report({
-          loc: getLoc(tsNode),
-          messageId: "shouldNotBeFinnish"
-        });
-      } : () => {
-      };
-      const nameWithoutDollar = text.endsWith("$") ? text.slice(0, -1) : text;
-      for (const name2 of names) {
-        const { regExp, validate: validate2 } = name2;
-        if (regExp.test(text) || regExp.test(nameWithoutDollar)) {
-          if (validate2) {
-            shouldBeFinnish();
-          } else {
-            shouldNotBeFinnish();
-          }
-          return;
-        }
-      }
-      for (const type of types) {
-        const { regExp, validate: validate2 } = type;
-        if (couldBeType2(typeNode != null ? typeNode : nameNode, regExp) || couldReturnType(typeNode != null ? typeNode : nameNode, regExp)) {
-          if (validate2) {
-            shouldBeFinnish();
-          } else {
-            shouldNotBeFinnish();
-          }
-          return;
-        }
-      }
-      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
-        shouldBeFinnish();
-      } else {
-        shouldNotBeFinnish();
-      }
-    }
-    return {
-      "ArrayPattern > Identifier": (node) => {
-        const found = findParent(
-          node,
-          "ArrowFunctionExpression",
-          "FunctionDeclaration",
-          "FunctionExpression",
-          "VariableDeclarator"
-        );
-        if (!found) {
-          return;
-        }
-        if (!validate.variables && isVariableDeclarator(found)) {
-          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) {
-          if (node.override) {
-            return;
-          }
-          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) {
-          if (node.override) {
-            return;
-          }
-          checkNode(node.key, node);
-        }
-      },
-      "MethodDefinition[kind='method'][computed=false]": (node) => {
-        if (validate.methods) {
-          if (node.override) {
-            return;
-          }
-          checkNode(node.key, node);
-        }
-      },
-      "MethodDefinition[kind='set'][computed=false]": (node) => {
-        if (validate.properties) {
-          if (node.override) {
-            return;
-          }
-          checkNode(node.key, node);
-        }
-      },
-      "TSAbstractMethodDefinition[computed=false]": (node) => {
-        if (node.override) {
-          return;
-        }
-        if (validate.methods && node.kind === "method") {
-          checkNode(node.key, node);
-        }
-        if (validate.properties && (node.kind === "get" || node.kind === "set")) {
-          checkNode(node.key, node);
-        }
-        if (validate.parameters) {
-          node.value.params.forEach((param) => {
-            checkNode(param);
-          });
-        }
-      },
-      "ObjectExpression > Property[computed=false] > Identifier": (node) => {
-        if (!validate.objects) {
-          return;
-        }
-        const found = findParent(
-          node,
-          "CallExpression",
-          "VariableDeclarator",
-          "TSSatisfiesExpression",
-          "TSAsExpression"
-        );
-        if (found) {
-          if (isCallExpression(found)) {
-            return;
-          } else if (isVariableDeclarator(found) && !!found.id.typeAnnotation) {
-            return;
-          } else if (isTSAsExpression(found) || isTSSatisfiesExpression(found)) {
-            return;
-          }
-        }
-        const parent = node.parent;
-        if (node === parent.key) {
-          checkNode(node, void 0, "shouldBeFinnishProperty");
-        }
-      },
-      "ObjectPattern > Property > Identifier": (node) => {
-        const found = findParent(
-          node,
-          "ArrowFunctionExpression",
-          "FunctionDeclaration",
-          "FunctionExpression",
-          "VariableDeclarator"
-        );
-        if (!found) {
-          return;
-        }
-        if (!validate.variables && isVariableDeclarator(found)) {
-          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);
-        }
-      }
-    };
-  }
-});
-
-// src/rules/just.ts
-var justRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Require the use of `just` instead of `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")
-          });
-        });
-      }
-    };
-  }
-});
-
-// src/rules/macro.ts
-var macroRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: "Require 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;
-      }
-    };
-  }
-});
-
-// src/rules/no-async-subscribe.ts
-var noAsyncSubscribeRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow passing `async` functions to `subscribe`.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Passing async functions to subscribe is forbidden. Use operators like `concatMap` or `switchMap` to avoid race conditions."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-async-subscribe",
-  create: (context) => {
-    const { couldBeObservable } = getTypeServices(context);
-    function report(node) {
-      const { loc } = node;
-      const asyncLoc = {
-        ...loc,
-        end: {
-          ...loc.start,
-          column: loc.start.column + 5
-        }
-      };
-      context.report({
-        messageId: "forbidden",
-        loc: asyncLoc
-      });
-    }
-    function checkSingleNext(funcNode) {
-      const parentNode = funcNode.parent;
-      const callee = parentNode.callee;
-      if (couldBeObservable(callee.object)) {
-        report(funcNode);
-      }
-    }
-    function checkObserverObjectProp(propNode) {
-      const parentNode = propNode.parent.parent;
-      const callee = parentNode.callee;
-      if (couldBeObservable(callee.object) && (isArrowFunctionExpression(propNode.value) || isFunctionExpression(propNode.value))) {
-        report(propNode.value);
-      }
-    }
-    return {
-      "CallExpression[callee.property.name='subscribe'] > FunctionExpression[async=true]": checkSingleNext,
-      "CallExpression[callee.property.name='subscribe'] > ArrowFunctionExpression[async=true]": checkSingleNext,
-      "CallExpression[callee.property.name='subscribe'] > ObjectExpression > Property[key.name='next'][value.type=\"ArrowFunctionExpression\"][value.async=true]": checkObserverObjectProp,
-      "CallExpression[callee.property.name='subscribe'] > ObjectExpression > Property[key.name='next'][value.type=\"FunctionExpression\"][value.async=true]": checkObserverObjectProp
-    };
-  }
-});
-
-// src/rules/no-compat.ts
-var noCompatRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: "Disallow the `rxjs-compat` package."
-    },
-    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
-        });
-      }
-    };
-  }
-});
-
-// src/rules/no-connectable.ts
-var noConnectableRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow operators that return connectable observables.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Connectable observables are forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-connectable",
-  create: (context) => {
-    const { couldBeFunction: couldBeFunction2 } = 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) => couldBeFunction2(arg))) {
-          context.report({
-            messageId: "forbidden",
-            node: node.callee
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-create.ts
-var noCreateRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow the static `Observable.create` and `Subject.create` functions.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Observable.create is forbidden; use new Observable.",
-      forbiddenSubject: "Subject.create is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-create",
-  create: (context) => {
-    const { couldBeObservable, couldBeType: couldBeType2 } = 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
-          });
-        }
-      },
-      "CallExpression > MemberExpression[object.name=/^(Subject|BehaviorSubject|AsyncSubject|ReplaySubject)$/] > Identifier[name='create']": (node) => {
-        const memberExpression = node.parent;
-        if (couldBeType2(memberExpression.object, /^(Subject|BehaviorSubject|AsyncSubject|ReplaySubject)$/)) {
-          context.report({
-            messageId: "forbiddenSubject",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-cyclic-action.ts
-import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
-import { stripIndent as stripIndent3 } from "common-tags";
-import ts4 from "typescript";
-
-// src/constants.ts
-var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
-var SOURCES_OBJECT_ACCEPTING_STATIC_OBSERVABLE_CREATORS = [
-  "combineLatest",
-  "forkJoin"
-];
-var MULTIPLE_OBSERVABLE_ACCEPTING_STATIC_OBSERVABLE_CREATORS = [
-  "combineLatest",
-  "forkJoin",
-  "merge",
-  "zip",
-  "concat",
-  "race"
-];
-var DEFAULT_UNBOUND_ALLOWED_TYPES = [
-  "Signal"
-];
-var DEFAULT_VALID_POST_COMPLETION_OPERATORS = [
-  "count",
-  "defaultIfEmpty",
-  "endWith",
-  "every",
-  "finalize",
-  "finally",
-  "isEmpty",
-  "last",
-  "max",
-  "min",
-  "publish",
-  "publishBehavior",
-  "publishLast",
-  "publishReplay",
-  "reduce",
-  "share",
-  "shareReplay",
-  "skipLast",
-  "takeLast",
-  "throwIfEmpty",
-  "toArray"
-];
-
-// src/rules/no-cyclic-action.ts
-function isTypeReference2(type) {
-  return Boolean(type.target);
-}
-var defaultOptions4 = [];
-var noCyclicActionRule = ruleCreator({
-  defaultOptions: defaultOptions4,
-  meta: {
-    docs: {
-      description: "Disallow cyclic actions in effects and epics.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Effects and epics that re-emit filtered actions are forbidden."
-    },
-    schema: [
-      {
-        properties: {
-          observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
-        },
-        type: "object",
-        description: stripIndent3`
-          An optional object with an optional \`observable\` property.
-          The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-cyclic-action",
-  create: (context) => {
-    const [config = {}] = context.options;
-    const { observable = defaultObservable } = config;
-    const observableRegExp = new RegExp(observable);
-    const { getTypeAtLocation, program } = ESLintUtils4.getParserServices(context);
-    const typeChecker = program.getTypeChecker();
-    function checkNode(pipeCallExpression) {
-      const operatorCallExpression = pipeCallExpression.arguments.find(
-        (arg) => isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "ofType"
-      );
-      if (!operatorCallExpression) {
-        return;
-      }
-      const operatorType = getTypeAtLocation(operatorCallExpression);
-      const [signature] = typeChecker.getSignaturesOfType(
-        operatorType,
-        ts4.SignatureKind.Call
-      );
-      if (!signature) {
-        return;
-      }
-      const operatorReturnType = typeChecker.getReturnTypeOfSignature(signature);
-      if (!isTypeReference2(operatorReturnType)) {
-        return;
-      }
-      const [operatorElementType] = typeChecker.getTypeArguments(operatorReturnType);
-      if (!operatorElementType) {
-        return;
-      }
-      const pipeType = getTypeAtLocation(pipeCallExpression);
-      if (!isTypeReference2(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 == null ? void 0 : 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
-    };
-  }
-});
-
-// src/rules/no-explicit-generics.ts
-import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
-import * as tsutils3 from "ts-api-utils";
-var noExplicitGenericsRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow unnecessary explicit generic type arguments.",
-      requiresTypeChecking: true
-    },
-    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 isUnion(node) {
-      if (!node) {
-        return false;
-      }
-      if (isUnionType(node)) {
-        return true;
-      }
-      const { getTypeAtLocation } = ESLintUtils5.getParserServices(context);
-      const type = getTypeAtLocation(node);
-      return tsutils3.isUnionOrIntersectionType(type);
-    }
-    function checkBehaviorSubjects(node) {
-      var _a;
-      const parent = node.parent;
-      const {
-        arguments: [value]
-      } = parent;
-      const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
-        return;
-      }
-      report(node);
-    }
-    function checkNotifications(node) {
-      var _a;
-      const parent = node.parent;
-      const {
-        arguments: [, value]
-      } = parent;
-      const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
-        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
-    };
-  }
-});
-
-// src/rules/no-exposed-subjects.ts
-var defaultAllowedTypesRegExp = /^EventEmitter$/;
-var defaultOptions5 = [];
-var noExposedSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions5,
-  meta: {
-    docs: {
-      description: "Disallow public and protected subjects.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Subject '{{subject}}' must be private.",
-      forbiddenAllowProtected: "Subject '{{subject}}' must be private or protected."
-    },
-    schema: [
-      {
-        properties: {
-          allowProtected: { type: "boolean", description: "Allow protected subjects.", default: false }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-exposed-subjects",
-  create: (context) => {
-    const [config = {}] = context.options;
-    const { allowProtected = false } = config;
-    const { couldBeSubject, couldBeType: couldBeType2 } = getTypeServices(context);
-    const messageId = allowProtected ? "forbiddenAllowProtected" : "forbidden";
-    const accessibilityRexExp = allowProtected ? /^(private|protected)$/ : /^private$/;
-    function isSubject(node) {
-      return couldBeSubject(node) && !couldBeType2(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
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-finnish.ts
-import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-var noFinnishRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow Finnish notation.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Finnish notation is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-finnish",
-  create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils6.getParserServices(context);
-    const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
-    function checkNode(nameNode, typeNode) {
-      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? 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) => {
-        var _a;
-        checkNode(node.id, (_a = node.init) != null ? _a : node);
-      }
-    };
-  }
-});
-
-// src/rules/no-floating-observables.ts
-var defaultOptions6 = [];
-var messageBase = "Observables must be subscribed to, returned, converted to a promise and awaited, or be explicitly marked as ignored with the `void` operator.";
-var messageBaseNoVoid = "Observables must be subscribed to, returned, or converted to a promise and awaited.";
-var noFloatingObservablesRule = ruleCreator({
-  defaultOptions: defaultOptions6,
-  meta: {
-    docs: {
-      description: "Require Observables to be handled appropriately.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: messageBase,
-      forbiddenNoVoid: messageBaseNoVoid
-    },
-    schema: [
-      {
-        properties: {
-          ignoreVoid: { type: "boolean", default: true, description: "Whether to ignore `void` expressions." }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-floating-observables",
-  create: (context) => {
-    const { couldBeObservable } = getTypeServices(context);
-    const [config = {}] = context.options;
-    const { ignoreVoid = true } = config;
-    function checkNode(node) {
-      if (couldBeObservable(node)) {
-        context.report({
-          messageId: ignoreVoid ? "forbidden" : "forbiddenNoVoid",
-          node
-        });
-      }
-    }
-    function checkVoid(node) {
-      if (ignoreVoid) return;
-      if (node.operator !== "void") return;
-      let expression = node.argument;
-      if (isChainExpression(expression)) {
-        expression = expression.expression;
-      }
-      if (!isCallExpression(expression)) return;
-      checkNode(expression);
-    }
-    return {
-      "ExpressionStatement > CallExpression": (node) => {
-        checkNode(node);
-      },
-      "ExpressionStatement > UnaryExpression": (node) => {
-        checkVoid(node);
-      },
-      "ExpressionStatement > ChainExpression": (node) => {
-        if (!isCallExpression(node.expression)) return;
-        checkNode(node.expression);
-      },
-      "ExpressionStatement > SequenceExpression": (node) => {
-        node.expressions.forEach((expression) => {
-          if (isCallExpression(expression)) {
-            checkNode(expression);
-          }
-        });
-      },
-      "ExpressionStatement > ArrayExpression": (node) => {
-        node.elements.forEach((expression) => {
-          if (!expression) return;
-          if (isCallExpression(expression)) {
-            checkNode(expression);
-          } else if (isUnaryExpression(expression)) {
-            checkVoid(expression);
-          }
-        });
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-default-value.ts
-import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
-var noIgnoredDefaultValueRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Not specifying a default value is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-ignored-default-value",
-  create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils7.getParserServices(context);
-    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
-    function checkConfigObj(configArg) {
-      if (!configArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "defaultValue")) {
-        context.report({
-          messageId: "forbidden",
-          node: configArg
-        });
-      }
-    }
-    function checkConfigType(configArg) {
-      const configArgType = getTypeAtLocation(configArg);
-      if (!(configArgType == null ? void 0 : configArgType.getProperties().some((p) => p.name === "defaultValue"))) {
-        context.report({
-          messageId: "forbidden",
-          node: configArg
-        });
-      }
-    }
-    function checkArg(arg) {
-      if (isIdentifier(arg)) {
-        checkConfigType(arg);
-        return;
-      } else if (isMemberExpression(arg) && isIdentifier(arg.property)) {
-        checkConfigType(arg.property);
-        return;
-      }
-      if (!isObjectExpression(arg)) {
-        return;
-      }
-      checkConfigObj(arg);
-    }
-    function checkFunctionArgs(node, args) {
-      if (!couldBeType2(node, "firstValueFrom", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "lastValueFrom", { name: /[/\\]rxjs[/\\]/ })) {
-        return;
-      }
-      if (!args || args.length <= 0) {
-        return;
-      }
-      const [observableArg, configArg] = args;
-      if (!couldBeObservable(observableArg)) {
-        return;
-      }
-      if (!configArg) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
-        return;
-      }
-      checkArg(configArg);
-    }
-    function checkOperatorArgs(node, args) {
-      if (!couldBeType2(node, "first", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "last", { name: /[/\\]rxjs[/\\]/ })) {
-        return;
-      }
-      if (!args || args.length <= 0) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
-        return;
-      }
-      const [arg] = args;
-      checkArg(arg);
-    }
-    return {
-      "CallExpression[callee.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
-        checkFunctionArgs(node.callee, node.arguments);
-      },
-      "CallExpression[callee.property.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
-        const memberExpression = node.callee;
-        checkFunctionArgs(memberExpression.property, node.arguments);
-      },
-      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=/^(first|last)$/]": (node) => {
-        checkOperatorArgs(node.callee, node.arguments);
-      },
-      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.property.name=/^(first|last)$/]": (node) => {
-        const memberExpression = node.callee;
-        checkOperatorArgs(memberExpression.property, node.arguments);
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-error.ts
-import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
-var noIgnoredErrorRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow calling `subscribe` without specifying an error handler.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Calling subscribe without an error handler is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-ignored-error",
-  create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils8.getParserServices(context);
-    const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
-    function isMissingErrorCallback(callExpression) {
-      if (callExpression.arguments.length >= 2) {
-        return false;
-      }
-      return couldBeFunction2(callExpression.arguments[0]);
-    }
-    function isObjMissingError(arg) {
-      return !arg.properties.some(
-        (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error"
-      );
-    }
-    function isTypeMissingError(arg) {
-      const argType = getTypeAtLocation(arg);
-      return !(argType == null ? void 0 : argType.getProperties().some((p) => p.name === "error"));
-    }
-    function isMissingErrorProperty(callExpression) {
-      if (callExpression.arguments.length !== 1) {
-        return false;
-      }
-      const [arg] = callExpression.arguments;
-      if (isObjectExpression(arg)) {
-        return isObjMissingError(arg);
-      }
-      if (isIdentifier(arg)) {
-        return isTypeMissingError(arg);
-      }
-      if (isMemberExpression(arg) && isIdentifier(arg.property)) {
-        return isTypeMissingError(arg.property);
-      }
-      return false;
-    }
-    return {
-      "CallExpression[arguments.length > 0] > MemberExpression > Identifier[name='subscribe']": (node) => {
-        const memberExpression = node.parent;
-        const callExpression = memberExpression.parent;
-        if ((isMissingErrorCallback(callExpression) || isMissingErrorProperty(callExpression)) && couldBeObservable(memberExpression.object)) {
-          context.report({
-            messageId: "forbidden",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-notifier.ts
-var noIgnoredNotifierRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier.",
-      recommended: "recommended",
-      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;
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-observable.ts
-var noIgnoredObservableRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: "Disallow ignoring of observables returned by functions."
-    },
-    messages: {
-      forbidden: "Ignoring a returned Observable is forbidden."
-    },
-    replacedBy: ["no-floating-observables"],
-    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
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-replay-buffer.ts
-var noIgnoredReplayBufferRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.",
-      recommended: "recommended"
-    },
-    messages: {
-      forbidden: "Ignoring the buffer size is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-ignored-replay-buffer",
-  create: (context) => {
-    function checkShareReplayConfig(node, shareReplayConfigArg) {
-      if (!shareReplayConfigArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "bufferSize")) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
-      }
-    }
-    function checkNode(node, { arguments: args }) {
-      if (!args || args.length === 0) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
-      }
-      if (node.name === "shareReplay" && (args == null ? void 0 : args.length) === 1) {
-        const [arg] = args;
-        if (isObjectExpression(arg)) {
-          checkShareReplayConfig(node, arg);
-        }
-      }
-    }
-    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);
-      },
-      "CallExpression > MemberExpression > Identifier[name=/^(publishReplay|shareReplay)$/]": (node) => {
-        const memberExpression = node.parent;
-        const callExpression = memberExpression.parent;
-        checkNode(node, callExpression);
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-subscribe.ts
-var noIgnoredSubscribeRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow calling `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: couldBeType2 } = getTypeServices(context);
-    return {
-      "CallExpression[arguments.length = 0][callee.property.name='subscribe']": (node) => {
-        const callee = node.callee;
-        if (couldBeObservable(callee.object) || couldBeType2(callee.object, "Subscribable")) {
-          context.report({
-            messageId: "forbidden",
-            node: callee.property
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-subscription.ts
-import { stripIndent as stripIndent4 } from "common-tags";
-var defaultOptions7 = [];
-var noIgnoredSubscriptionRule = ruleCreator({
-  defaultOptions: defaultOptions7,
-  meta: {
-    docs: {
-      description: "Disallow ignoring the subscription returned by `subscribe`.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Ignoring returned subscriptions is forbidden."
-    },
-    schema: [
-      {
-        properties: {
-          completers: { type: "array", items: { type: "string" }, description: "An array of operator names that will complete the observable and silence this rule.", default: ["takeUntil", "takeWhile", "take", "first", "last", "takeUntilDestroyed"] },
-          postCompleters: { type: "array", items: { type: "string" }, description: "An array of operator names that are allowed to follow the completion operators.", default: DEFAULT_VALID_POST_COMPLETION_OPERATORS }
-        },
-        type: "object",
-        description: stripIndent4`
-          An object with optional \`completers\` and \`postCompleters\` properties.
-          The \`completers\` property is an array containing the names of operators that will complete the observable and silence this rule.
-          The \`postCompleters\` property is an array containing the names of the operators that are allowed to follow the completion operators.
-        `
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-ignored-subscription",
-  create: (context) => {
-    const [config = {}] = context.options;
-    const {
-      completers = ["takeUntil", "takeWhile", "take", "first", "last", "takeUntilDestroyed"],
-      postCompleters = DEFAULT_VALID_POST_COMPLETION_OPERATORS
-    } = config;
-    const checkedOperatorsRegExp = new RegExp(
-      `^(${completers.join("|")})$`
-    );
-    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
-    function hasAllowedOperator(node) {
-      if (isCallExpression(node) && isMemberExpression(node.callee) && isIdentifier(node.callee.property) && node.callee.property.name === "pipe") {
-        const { isOrderValid, operatorNode } = findIsLastOperatorOrderValid(
-          node,
-          checkedOperatorsRegExp,
-          postCompleters
-        );
-        return isOrderValid && !!operatorNode;
-      }
-      return false;
-    }
-    return {
-      "ExpressionStatement > CallExpression > MemberExpression[property.name='subscribe']": (node) => {
-        if (couldBeObservable(node.object)) {
-          const callExpression = node.parent;
-          if (callExpression.arguments.length === 1 && couldBeType2(callExpression.arguments[0], "Subscriber")) {
-            return;
-          }
-          if (hasAllowedOperator(node.object)) {
-            return;
-          }
-          context.report({
-            messageId: "forbidden",
-            node: node.property
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-ignored-takewhile-value.ts
-var noIgnoredTakewhileValueRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow ignoring the value within `takeWhile`.",
-      recommended: "recommended"
-    },
-    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: name2 }) => name2 === 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);
-      }
-    };
-  }
-});
-
-// src/rules/no-implicit-any-catch.ts
-import {
-  AST_NODE_TYPES as AST_NODE_TYPES4
-} from "@typescript-eslint/utils";
-function isParenthesised(sourceCode, node) {
-  const before = sourceCode.getTokenBefore(node);
-  const after = sourceCode.getTokenAfter(node);
-  return before && after && before.value === "(" && before.range[1] <= node.range[0] && after.value === ")" && after.range[0] >= node.range[1];
-}
-var defaultOptions8 = [];
-var noImplicitAnyCatchRule = ruleCreator({
-  defaultOptions: defaultOptions8,
-  meta: {
-    docs: {
-      description: "Disallow implicit `any` error parameters in `catchError`, `subscribe`, and `tap`.",
-      recommended: {
-        recommended: true,
-        strict: [{
-          allowExplicitAny: false
-        }]
-      },
-      requiresTypeChecking: true
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      explicitAny: "Explicit `any` in error callback.",
-      implicitAny: "Implicit `any` in error callback.",
-      narrowed: "Error type must be `unknown` or `any`.",
-      narrowedAllowError: "Error type must be `unknown`, `any`, or `Error`.",
-      suggestExplicitUnknown: "Use `unknown` instead to explicitly and safely assert the type is correct.",
-      suggestExplicitAny: "Use `any` instead to explicitly opt out of type safety.",
-      suggestExplicitError: "Use `Error` instead."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowExplicitAny: {
-            type: "boolean",
-            description: "Allow error variable to be explicitly typed as `any`.",
-            default: true
-          },
-          allowExplicitError: {
-            type: "boolean",
-            description: "Allow narrowing error type to `Error`.",
-            default: false
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "suggestion"
-  },
-  name: "no-implicit-any-catch",
-  create: (context) => {
-    const [config = {}] = context.options;
-    const { allowExplicitAny = true, allowExplicitError = false } = config;
-    const { couldBeObservable } = getTypeServices(context);
-    const sourceCode = context.sourceCode;
-    function createReplacerFix(typeAnnotation, replaceWith) {
-      return function fix(fixer) {
-        return fixer.replaceText(typeAnnotation, `: ${replaceWith}`);
-      };
-    }
-    function createInserterFix(param, annotateWith, { hasRestParams = false } = {}) {
-      return function fix(fixer) {
-        if (hasRestParams || isParenthesised(sourceCode, param)) {
-          return fixer.insertTextAfter(param, `: ${annotateWith}`);
-        }
-        return [
-          fixer.insertTextBefore(param, "("),
-          fixer.insertTextAfter(param, `: ${annotateWith})`)
-        ];
-      };
-    }
-    function checkCallback(callback) {
-      if (isArrowFunctionExpression(callback) || isFunctionExpression(callback)) {
-        const [param, ...restParams] = callback.params;
-        if (!param) {
-          return;
-        }
-        if (hasTypeAnnotation(param)) {
-          const { typeAnnotation } = param;
-          const {
-            typeAnnotation: { type }
-          } = typeAnnotation;
-          if (type === AST_NODE_TYPES4.TSAnyKeyword) {
-            if (allowExplicitAny) {
-              return;
-            }
-            context.report({
-              messageId: "explicitAny",
-              node: param,
-              suggest: [
-                {
-                  messageId: "suggestExplicitUnknown",
-                  fix: createReplacerFix(typeAnnotation, "unknown")
-                }
-              ]
-            });
-          } else if (type !== AST_NODE_TYPES4.TSUnknownKeyword) {
-            let isAllowedError = false;
-            if (allowExplicitError && type === AST_NODE_TYPES4.TSTypeReference) {
-              const typeRef = typeAnnotation.typeAnnotation;
-              if (isIdentifier(typeRef.typeName)) {
-                isAllowedError = typeRef.typeName.name === "Error";
-              }
-            }
-            if (!isAllowedError) {
-              context.report({
-                messageId: allowExplicitError ? "narrowedAllowError" : "narrowed",
-                node: param,
-                suggest: [
-                  {
-                    messageId: "suggestExplicitUnknown",
-                    fix: createReplacerFix(typeAnnotation, "unknown")
-                  },
-                  allowExplicitAny ? {
-                    messageId: "suggestExplicitAny",
-                    fix: createReplacerFix(typeAnnotation, "any")
-                  } : null,
-                  allowExplicitError && !isAllowedError ? {
-                    messageId: "suggestExplicitError",
-                    fix: createReplacerFix(typeAnnotation, "Error")
-                  } : null
-                ].filter((x) => !!x)
-              });
-            }
-          }
-        } else {
-          const hasRestParams = restParams.length > 0;
-          context.report({
-            fix: allowExplicitAny ? createInserterFix(param, "any", { hasRestParams }) : void 0,
-            messageId: "implicitAny",
-            node: param,
-            suggest: [
-              {
-                messageId: "suggestExplicitUnknown",
-                fix: createInserterFix(param, "unknown", { hasRestParams })
-              },
-              allowExplicitAny ? {
-                messageId: "suggestExplicitAny",
-                fix: createInserterFix(param, "any", { hasRestParams })
-              } : null
-            ].filter((x) => !!x)
-          });
-        }
-      }
-    }
-    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);
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-index.ts
-var noIndexRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow importing index modules.",
-      recommended: "recommended"
-    },
-    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
-        });
-      }
-    };
-  }
-});
-
-// src/rules/no-internal.ts
-var noInternalRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow importing internal modules.",
-      recommended: "recommended"
-    },
-    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 fix2 = function(fixer) {
-            return fixer.replaceText(node, replacement);
-          };
-          var fix = fix2;
-          context.report({
-            fix: fix2,
-            messageId: "forbidden",
-            node,
-            suggest: [{ fix: fix2, messageId: "suggest" }]
-          });
-        } else {
-          context.report({
-            messageId: "forbidden",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-misused-observables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
-import { getFunctionHeadLocation, isFunction } from "@typescript-eslint/utils/ast-utils";
-import * as tsutils4 from "ts-api-utils";
-import ts5 from "typescript";
-function parseChecksVoidReturn(checksVoidReturn) {
-  var _a, _b, _c, _d, _e, _f;
-  switch (checksVoidReturn) {
-    case false:
-      return false;
-    case true:
-    case void 0:
-      return {
-        arguments: true,
-        attributes: true,
-        inheritedMethods: true,
-        properties: true,
-        returns: true,
-        variables: true
-      };
-    default:
-      return {
-        arguments: (_a = checksVoidReturn.arguments) != null ? _a : true,
-        attributes: (_b = checksVoidReturn.attributes) != null ? _b : true,
-        inheritedMethods: (_c = checksVoidReturn.inheritedMethods) != null ? _c : true,
-        properties: (_d = checksVoidReturn.properties) != null ? _d : true,
-        returns: (_e = checksVoidReturn.returns) != null ? _e : true,
-        variables: (_f = checksVoidReturn.variables) != null ? _f : true
-      };
-  }
-}
-var defaultOptions9 = [];
-var noMisusedObservablesRule = ruleCreator({
-  defaultOptions: defaultOptions9,
-  meta: {
-    docs: {
-      description: "Disallow Observables in places not designed to handle them.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbiddenVoidReturnArgument: "Observable returned in function argument where a void return was expected.",
-      forbiddenVoidReturnAttribute: "Observable-returning function provided to attribute where a void return was expected.",
-      forbiddenVoidReturnInheritedMethod: "Observable-returning method provided where a void return was expected by extended/implemented type '{{heritageTypeName}}'.",
-      forbiddenVoidReturnProperty: "Observable-returning function provided to property where a void return was expected.",
-      forbiddenVoidReturnReturnValue: "Observable-returning function provided to return value where a void return was expected.",
-      forbiddenVoidReturnVariable: "Observable-returning function provided to variable where a void return was expected.",
-      forbiddenSpread: "Expected a non-Observable value to be spread into an object."
-    },
-    schema: [
-      {
-        properties: {
-          checksVoidReturn: {
-            default: true,
-            description: "Disallow returning an Observable from a function typed as returning `void`.",
-            oneOf: [
-              {
-                default: true,
-                type: "boolean",
-                description: "Disallow returning an Observable from all types of functions typed as returning `void`."
-              },
-              {
-                type: "object",
-                additionalProperties: false,
-                description: "Which forms of functions may have checking disabled.",
-                properties: {
-                  arguments: { type: "boolean", description: "Disallow passing an Observable-returning function as an argument where the parameter type expects a function that returns `void`." },
-                  attributes: { type: "boolean", description: "Disallow passing an Observable-returning function as a JSX attribute expected to be a function that returns `void`." },
-                  inheritedMethods: { type: "boolean", description: "Disallow providing an Observable-returning function where a function that returns `void` is expected by an extended or implemented type." },
-                  properties: { type: "boolean", description: "Disallow providing an Observable-returning function where a function that returns `void` is expected by a property." },
-                  returns: { type: "boolean", description: "Disallow returning an Observable-returning function where a function that returns `void` is expected." },
-                  variables: { type: "boolean", description: "Disallow assigning or declaring an Observable-returning function where a function that returns `void` is expected." }
-                }
-              }
-            ]
-          },
-          checksSpreads: { type: "boolean", default: true, description: "Disallow `...` spreading an Observable." }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-misused-observables",
-  create: (context) => {
-    const { program, esTreeNodeToTSNodeMap, getTypeAtLocation } = ESLintUtils9.getParserServices(context);
-    const checker = program.getTypeChecker();
-    const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
-    const [config = {}] = context.options;
-    const { checksVoidReturn = true, checksSpreads = true } = config;
-    const parsedChecksVoidReturn = parseChecksVoidReturn(checksVoidReturn);
-    const voidReturnChecks = parsedChecksVoidReturn ? {
-      ...parsedChecksVoidReturn.arguments && {
-        CallExpression: checkArguments,
-        NewExpression: checkArguments
-      },
-      ...parsedChecksVoidReturn.attributes && {
-        JSXAttribute: checkJSXAttribute
-      },
-      ...parsedChecksVoidReturn.inheritedMethods && {
-        ClassDeclaration: checkClassLikeOrInterfaceNode,
-        ClassExpression: checkClassLikeOrInterfaceNode,
-        TSInterfaceDeclaration: checkClassLikeOrInterfaceNode
-      },
-      ...parsedChecksVoidReturn.properties && {
-        Property: checkProperty
-      },
-      ...parsedChecksVoidReturn.returns && {
-        ReturnStatement: checkReturnStatement
-      },
-      ...parsedChecksVoidReturn.variables && {
-        AssignmentExpression: checkAssignment,
-        VariableDeclarator: checkVariableDeclaration
-      }
-    } : {};
-    const spreadChecks = {
-      SpreadElement: (node) => {
-        if (couldBeObservable(node.argument)) {
-          context.report({
-            messageId: "forbiddenSpread",
-            node: node.argument
-          });
-        }
-      }
-    };
-    function checkArguments(node) {
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      const voidArgs = voidFunctionArguments(checker, tsNode);
-      if (!voidArgs.size) {
-        return;
-      }
-      for (const [index, argument] of node.arguments.entries()) {
-        if (!voidArgs.has(index)) {
-          continue;
-        }
-        if (couldReturnObservable(argument)) {
-          context.report({
-            messageId: "forbiddenVoidReturnArgument",
-            node: argument
-          });
-        }
-      }
-    }
-    function checkJSXAttribute(node) {
-      if (node.value == null || !isJSXExpressionContainer(node.value)) {
-        return;
-      }
-      const expressionContainer = esTreeNodeToTSNodeMap.get(
-        node.value
-      );
-      const contextualType = checker.getContextualType(expressionContainer);
-      if (contextualType != null && isVoidReturningFunctionType(contextualType) && couldReturnObservable(node.value.expression)) {
-        context.report({
-          messageId: "forbiddenVoidReturnAttribute",
-          node: node.value
-        });
-      }
-    }
-    function checkClassLikeOrInterfaceNode(node) {
-      var _a;
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      const heritageTypes = getHeritageTypes(checker, tsNode);
-      if (!(heritageTypes == null ? void 0 : heritageTypes.length)) {
-        return;
-      }
-      for (const element of node.body.body) {
-        const tsElement = esTreeNodeToTSNodeMap.get(element);
-        const memberName = (_a = tsElement == null ? void 0 : tsElement.name) == null ? void 0 : _a.getText();
-        if (memberName == null) {
-          continue;
-        }
-        if (!couldReturnObservable(element)) {
-          continue;
-        }
-        if (isStaticMember(element)) {
-          continue;
-        }
-        for (const heritageType of heritageTypes) {
-          const heritageMember = getMemberIfExists(heritageType, memberName);
-          if (heritageMember == null) {
-            continue;
-          }
-          const memberType = checker.getTypeOfSymbolAtLocation(heritageMember, tsElement);
-          if (!isVoidReturningFunctionType(memberType)) {
-            continue;
-          }
-          context.report({
-            messageId: "forbiddenVoidReturnInheritedMethod",
-            node: element,
-            data: { heritageTypeName: checker.typeToString(heritageType) }
-          });
-        }
-      }
-    }
-    function checkProperty(node) {
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      const contextualType = getPropertyContextualType(checker, tsNode);
-      if (contextualType == null) {
-        return;
-      }
-      if (!isVoidReturningFunctionType(contextualType)) {
-        return;
-      }
-      if (!couldReturnObservable(node.value)) {
-        return;
-      }
-      if (isFunction(node.value)) {
-        const functionNode = node.value;
-        if (functionNode.returnType) {
-          context.report({
-            messageId: "forbiddenVoidReturnProperty",
-            node: functionNode.returnType.typeAnnotation
-          });
-        } else {
-          context.report({
-            messageId: "forbiddenVoidReturnProperty",
-            loc: getFunctionHeadLocation(functionNode, context.sourceCode)
-          });
-        }
-      } else {
-        context.report({
-          messageId: "forbiddenVoidReturnProperty",
-          node: node.value
-        });
-      }
-    }
-    function checkReturnStatement(node) {
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      if (tsNode.expression == null || !node.argument) {
-        return;
-      }
-      function getFunctionNode() {
-        let current = node.parent;
-        while (current && !isArrowFunctionExpression(current) && !isFunctionExpression(current) && !isFunctionDeclaration(current)) {
-          current = current.parent;
-        }
-        return current;
-      }
-      const functionNode = getFunctionNode();
-      if ((functionNode == null ? void 0 : functionNode.returnType) && !isPossiblyFunctionType(functionNode.returnType)) {
-        return;
-      }
-      const contextualType = checker.getContextualType(tsNode.expression);
-      if (contextualType == null) {
-        return;
-      }
-      if (!isVoidReturningFunctionType(contextualType)) {
-        return;
-      }
-      if (!couldReturnObservable(node.argument)) {
-        return;
-      }
-      context.report({
-        node: node.argument,
-        messageId: "forbiddenVoidReturnReturnValue"
-      });
-    }
-    function checkAssignment(node) {
-      const varType = getTypeAtLocation(node.left);
-      if (!isVoidReturningFunctionType(varType)) {
-        return;
-      }
-      if (couldReturnObservable(node.right)) {
-        context.report({
-          messageId: "forbiddenVoidReturnVariable",
-          node: node.right
-        });
-      }
-    }
-    function checkVariableDeclaration(node) {
-      const tsNode = esTreeNodeToTSNodeMap.get(node);
-      if (tsNode.initializer == null || node.init == null || node.id.typeAnnotation == null) {
-        return;
-      }
-      if (!isPossiblyFunctionType(node.id.typeAnnotation)) {
-        return;
-      }
-      const varType = getTypeAtLocation(node.id);
-      if (!isVoidReturningFunctionType(varType)) {
-        return;
-      }
-      if (couldReturnObservable(node.init)) {
-        context.report({
-          messageId: "forbiddenVoidReturnVariable",
-          node: node.init
-        });
-      }
-    }
-    return {
-      ...checksVoidReturn ? voidReturnChecks : {},
-      ...checksSpreads ? spreadChecks : {}
-    };
-  }
-});
-function voidFunctionArguments(checker, tsNode) {
-  if (!tsNode.arguments) {
-    return /* @__PURE__ */ new Set();
-  }
-  const voidReturnIndices = /* @__PURE__ */ new Set();
-  const type = checker.getTypeAtLocation(tsNode.expression);
-  for (const subType of tsutils4.unionConstituents(type)) {
-    const signatures = ts5.isCallExpression(tsNode) ? subType.getCallSignatures() : subType.getConstructSignatures();
-    for (const signature of signatures) {
-      for (const [index, parameter] of signature.parameters.entries()) {
-        const type2 = checker.getTypeOfSymbolAtLocation(parameter, tsNode.expression);
-        if (isVoidReturningFunctionType(type2)) {
-          voidReturnIndices.add(index);
-        }
-      }
-    }
-  }
-  return voidReturnIndices;
-}
-function isVoidReturningFunctionType(type) {
-  let hasVoidReturn = false;
-  for (const subType of tsutils4.unionConstituents(type)) {
-    for (const signature of subType.getCallSignatures()) {
-      const returnType = signature.getReturnType();
-      if (couldBeType(returnType, "Observable")) {
-        return false;
-      }
-      hasVoidReturn || (hasVoidReturn = tsutils4.isTypeFlagSet(returnType, ts5.TypeFlags.Void));
-    }
-  }
-  return hasVoidReturn;
-}
-function getHeritageTypes(checker, tsNode) {
-  var _a;
-  return (_a = tsNode.heritageClauses) == null ? void 0 : _a.flatMap((clause) => clause.types).map((typeExpressions) => checker.getTypeAtLocation(typeExpressions));
-}
-function getMemberIfExists(type, memberName) {
-  var _a, _b;
-  const escapedMemberName = ts5.escapeLeadingUnderscores(memberName);
-  const symbolMemberMatch = (_b = (_a = type.getSymbol()) == null ? void 0 : _a.members) == null ? void 0 : _b.get(escapedMemberName);
-  return symbolMemberMatch != null ? symbolMemberMatch : tsutils4.getPropertyOfType(type, escapedMemberName);
-}
-function isStaticMember(node) {
-  return (isMethodDefinition(node) || isPropertyDefinition(node) || isAccessorProperty(node)) && node.static;
-}
-function getPropertyContextualType(checker, tsNode) {
-  if (ts5.isPropertyAssignment(tsNode)) {
-    return checker.getContextualType(tsNode.initializer);
-  } else if (ts5.isShorthandPropertyAssignment(tsNode)) {
-    return checker.getContextualType(tsNode.name);
-  } else if (ts5.isMethodDeclaration(tsNode)) {
-    if (ts5.isComputedPropertyName(tsNode.name)) {
-      return;
-    }
-    const obj = tsNode.parent;
-    if (!ts5.isObjectLiteralExpression(obj)) {
-      return;
-    }
-    const objType = checker.getContextualType(obj);
-    if (objType == null) {
-      return;
-    }
-    const propertySymbol = tsutils4.unionConstituents(objType).map((t) => checker.getPropertyOfType(t, tsNode.name.getText())).find((p) => p);
-    if (propertySymbol == null) {
-      return;
-    }
-    return checker.getTypeOfSymbolAtLocation(propertySymbol, tsNode.name);
-  } else {
-    return void 0;
-  }
-}
-function isPossiblyFunctionType(node) {
-  switch (node.typeAnnotation.type) {
-    case AST_NODE_TYPES5.TSConditionalType:
-    case AST_NODE_TYPES5.TSConstructorType:
-    case AST_NODE_TYPES5.TSFunctionType:
-    case AST_NODE_TYPES5.TSImportType:
-    case AST_NODE_TYPES5.TSIndexedAccessType:
-    case AST_NODE_TYPES5.TSInferType:
-    case AST_NODE_TYPES5.TSIntersectionType:
-    case AST_NODE_TYPES5.TSQualifiedName:
-    case AST_NODE_TYPES5.TSThisType:
-    case AST_NODE_TYPES5.TSTypeOperator:
-    case AST_NODE_TYPES5.TSTypeQuery:
-    case AST_NODE_TYPES5.TSTypeReference:
-    case AST_NODE_TYPES5.TSUnionType:
-      return true;
-    case AST_NODE_TYPES5.TSTypeLiteral:
-      return node.typeAnnotation.members.some(
-        (member) => member.type === AST_NODE_TYPES5.TSCallSignatureDeclaration || member.type === AST_NODE_TYPES5.TSConstructSignatureDeclaration
-      );
-    case AST_NODE_TYPES5.TSAbstractKeyword:
-    case AST_NODE_TYPES5.TSAnyKeyword:
-    case AST_NODE_TYPES5.TSArrayType:
-    case AST_NODE_TYPES5.TSAsyncKeyword:
-    case AST_NODE_TYPES5.TSBigIntKeyword:
-    case AST_NODE_TYPES5.TSBooleanKeyword:
-    case AST_NODE_TYPES5.TSDeclareKeyword:
-    case AST_NODE_TYPES5.TSExportKeyword:
-    case AST_NODE_TYPES5.TSIntrinsicKeyword:
-    case AST_NODE_TYPES5.TSLiteralType:
-    case AST_NODE_TYPES5.TSMappedType:
-    case AST_NODE_TYPES5.TSNamedTupleMember:
-    case AST_NODE_TYPES5.TSNeverKeyword:
-    case AST_NODE_TYPES5.TSNullKeyword:
-    case AST_NODE_TYPES5.TSNumberKeyword:
-    case AST_NODE_TYPES5.TSObjectKeyword:
-    case AST_NODE_TYPES5.TSOptionalType:
-    case AST_NODE_TYPES5.TSPrivateKeyword:
-    case AST_NODE_TYPES5.TSProtectedKeyword:
-    case AST_NODE_TYPES5.TSPublicKeyword:
-    case AST_NODE_TYPES5.TSReadonlyKeyword:
-    case AST_NODE_TYPES5.TSRestType:
-    case AST_NODE_TYPES5.TSStaticKeyword:
-    case AST_NODE_TYPES5.TSStringKeyword:
-    case AST_NODE_TYPES5.TSSymbolKeyword:
-    case AST_NODE_TYPES5.TSTemplateLiteralType:
-    case AST_NODE_TYPES5.TSTupleType:
-    case AST_NODE_TYPES5.TSTypePredicate:
-    case AST_NODE_TYPES5.TSUndefinedKeyword:
-    case AST_NODE_TYPES5.TSUnknownKeyword:
-    case AST_NODE_TYPES5.TSVoidKeyword:
-      return false;
-  }
-}
-
-// src/rules/no-nested-subscribe.ts
-var noNestedSubscribeRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow calling `subscribe` within a `subscribe` callback.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Nested subscribe calls are forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-nested-subscribe",
-  create: (context) => {
-    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
-    const argumentsMap = /* @__PURE__ */ new WeakMap();
-    return {
-      [`CallExpression > MemberExpression[property.name='subscribe']`]: (node) => {
-        if (!couldBeObservable(node.object) && !couldBeType2(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);
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-redundant-notify.ts
-var noRedundantNotifyRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow sending redundant notifications from completed or errored observables.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Redundant notifications are forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-redundant-notify",
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const { couldBeType: couldBeType2 } = getTypeServices(context);
-    return {
-      "ExpressionStatement[expression.callee.property.name=/^(complete|error|unsubscribe)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error|unsubscribe)$/]": (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, couldBeType2) || !isExpressionObserver(node, couldBeType2)) {
-          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, couldBeType2) {
-  if (!isCallExpression(expressionStatement.expression)) {
-    return false;
-  }
-  const callExpression = expressionStatement.expression;
-  if (!isMemberExpression(callExpression.callee)) {
-    return false;
-  }
-  const { object } = callExpression.callee;
-  return couldBeType2(object, /^(Subject|Subscriber)$/);
-}
-
-// src/rules/no-sharereplay.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
-var defaultOptions10 = [];
-var noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions10,
-  meta: {
-    docs: {
-      description: "Disallow unsafe `shareReplay` usage.",
-      recommended: "recommended"
-    },
-    messages: {
-      forbidden: "shareReplay is forbidden.",
-      forbiddenWithoutConfig: "shareReplay is forbidden unless a config argument is passed."
-    },
-    schema: [
-      {
-        properties: {
-          allowConfig: { type: "boolean", description: "Allow shareReplay if a config argument is specified.", default: true }
-        },
-        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 !== AST_NODE_TYPES6.ObjectExpression;
-        }
-        if (report) {
-          context.report({
-            messageId: allowConfig ? "forbiddenWithoutConfig" : "forbidden",
-            node: node.callee
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-sharereplay-before-takeuntil.ts
-var defaultOptions11 = [];
-var noSharereplayBeforeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions11,
-  meta: {
-    docs: {
-      description: "Disallow using `shareReplay({ refCount: false })` before `takeUntil`.",
-      recommended: "strict"
-    },
-    messages: {
-      forbidden: "shareReplay before '{{takeUntilAlias}}' is forbidden unless 'refCount: true' is specified."
-    },
-    schema: [{
-      properties: {
-        takeUntilAlias: { type: "array", description: "List of operators to treat as takeUntil.", default: ["takeUntilDestroyed"] }
-      },
-      type: "object"
-    }],
-    type: "problem"
-  },
-  name: "no-sharereplay-before-takeuntil",
-  create: (context) => {
-    const [config = {}] = context.options;
-    const { takeUntilAlias = ["takeUntilDestroyed"] } = config;
-    function checkCallExpression(node) {
-      const pipeCallExpression = node.parent;
-      if (!pipeCallExpression.arguments || !isMemberExpression(pipeCallExpression.callee) || !isIdentifier(pipeCallExpression.callee.property) || pipeCallExpression.callee.property.name !== "pipe") {
-        return;
-      }
-      const allTakeUntilAlias = ["takeUntil", ...takeUntilAlias];
-      const takeUntilRegex = new RegExp(`^(${allTakeUntilAlias.join("|")})$`);
-      const { isOrderValid, operatorNode: takeUntilNode } = findIsLastOperatorOrderValid(
-        pipeCallExpression,
-        takeUntilRegex,
-        DEFAULT_VALID_POST_COMPLETION_OPERATORS
-      );
-      if (!isOrderValid || !takeUntilNode) {
-        return;
-      }
-      if (takeUntilNode.range[0] < node.range[0]) {
-        return;
-      }
-      const shareReplayConfig = node.arguments[0];
-      if (!shareReplayConfig || !isObjectExpression(shareReplayConfig)) {
-        context.report({
-          messageId: "forbidden",
-          data: { takeUntilAlias: isIdentifier(takeUntilNode) ? takeUntilNode.name : "takeUntil" },
-          node: node.callee
-        });
-        return;
-      }
-      const refCountElement = shareReplayConfig.properties.filter(isProperty).find((prop) => isIdentifier(prop.key) && prop.key.name === "refCount");
-      if (!refCountElement || isLiteral(refCountElement.value) && refCountElement.value.value === false) {
-        context.report({
-          messageId: "forbidden",
-          data: { takeUntilAlias: isIdentifier(takeUntilNode) ? takeUntilNode.name : "takeUntil" },
-          node: node.callee
-        });
-      }
-    }
-    return {
-      'CallExpression[callee.name="shareReplay"]': (node) => {
-        checkCallExpression(node);
-      },
-      'CallExpression[callee.property.name="shareReplay"]': (node) => {
-        checkCallExpression(node);
-      }
-    };
-  }
-});
-
-// src/rules/no-subclass.ts
-var noSubclassRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow subclassing RxJS classes.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Subclassing RxJS classes is forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-subclass",
-  create: (context) => {
-    const { couldBeType: couldBeType2 } = getTypeServices(context);
-    const queryNames = [
-      "AsyncSubject",
-      "BehaviorSubject",
-      "Observable",
-      "ReplaySubject",
-      "Scheduler",
-      "Subject",
-      "Subscriber"
-    ];
-    return {
-      [`ClassDeclaration[superClass.name=/^(${queryNames.join(
-        "|"
-      )})$/] > Identifier.superClass`]: (node) => {
-        if (queryNames.some(
-          (name2) => couldBeType2(node, name2, { name: /[/\\]rxjs[/\\]/ })
-        )) {
-          context.report({
-            messageId: "forbidden",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-subject-unsubscribe.ts
-var noSubjectUnsubscribeRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow calling the `unsubscribe` method of subjects.",
-      recommended: "recommended",
-      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
-            });
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-subject-value.ts
-var noSubjectValueRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow 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
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-subscribe-handlers.ts
-var noSubscribeHandlersRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow passing 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: couldBeType2 } = getTypeServices(context);
-    return {
-      "CallExpression[arguments.length > 0][callee.property.name='subscribe']": (node) => {
-        const callee = node.callee;
-        if (couldBeObservable(callee.object) || couldBeType2(callee.object, "Subscribable")) {
-          context.report({
-            messageId: "forbidden",
-            node: callee.property
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-subscribe-in-pipe.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
-var noSubscribeInPipeRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow calling of `subscribe` within any RxJS operator inside a `pipe`.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Subscribe calls within pipe operators are forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-subscribe-in-pipe",
-  create: (context) => {
-    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
-    function isWithinPipe(node) {
-      let parent = node.parent;
-      while (parent) {
-        if (parent.type === AST_NODE_TYPES7.CallExpression && parent.callee.type === AST_NODE_TYPES7.MemberExpression && parent.callee.property.type === AST_NODE_TYPES7.Identifier && parent.callee.property.name === "pipe") {
-          return true;
-        }
-        parent = parent.parent;
-      }
-      return false;
-    }
-    return {
-      "CallExpression > MemberExpression[property.name='subscribe']": (node) => {
-        if (!couldBeObservable(node.object) && !couldBeType2(node.object, "Subscribable")) {
-          return;
-        }
-        if (isWithinPipe(node)) {
-          context.report({
-            messageId: "forbidden",
-            node: node.property
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-tap.ts
-var noTapRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: "Disallow 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
-            }
-          }
-        });
-      }
-    };
-  }
-});
-
-// src/rules/no-topromise.ts
-var noTopromiseRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow use of the `toPromise` method.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    hasSuggestions: true,
-    messages: {
-      forbidden: "The toPromise method is forbidden.",
-      suggestLastValueFromWithDefault: "Use lastValueFrom(..., { defaultValue: undefined }) instead.",
-      suggestLastValueFrom: "Use lastValueFrom instead.",
-      suggestFirstValueFrom: "Use firstValueFrom instead."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-topromise",
-  create: (context) => {
-    const { couldBeObservable } = getTypeServices(context);
-    function getQuote(raw) {
-      const match = /^\s*('|")/.exec(raw);
-      if (!match) {
-        return void 0;
-      }
-      const [, quote] = match;
-      return quote;
-    }
-    function createFix(conversion, callExpression, observableNode, importDeclarations, { withDefault } = {}) {
-      return function* fix(fixer) {
-        var _a, _b, _c;
-        let namespace = "";
-        let functionName = conversion;
-        const rxjsImportDeclaration = importDeclarations.find((node) => node.source.value === "rxjs");
-        if ((_a = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _a.every(isImportNamespaceSpecifier)) {
-          namespace = rxjsImportDeclaration.specifiers[0].local.name + ".";
-        } else if ((_b = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _b.every(isImportSpecifier)) {
-          const { specifiers } = rxjsImportDeclaration;
-          const existingSpecifier = specifiers.find((node) => (isIdentifier(node.imported) ? node.imported.name : node.imported.value) === functionName);
-          if (existingSpecifier) {
-            functionName = existingSpecifier.local.name;
-          } else {
-            const lastSpecifier = specifiers[specifiers.length - 1];
-            yield fixer.insertTextAfter(lastSpecifier, `, ${functionName}`);
-          }
-        } else if (importDeclarations.length) {
-          const lastImport = importDeclarations[importDeclarations.length - 1];
-          const quote = (_c = getQuote(lastImport.source.raw)) != null ? _c : '"';
-          yield fixer.insertTextAfter(
-            importDeclarations[importDeclarations.length - 1],
-            `
-import { ${functionName} } from ${quote}rxjs${quote};`
-          );
-        } else {
-          console.warn("No import declarations found. Unable to suggest a fix.");
-          return;
-        }
-        yield fixer.replaceText(
-          callExpression,
-          `${namespace}${functionName}(${context.sourceCode.getText(observableNode)}${withDefault ? ", { defaultValue: undefined }" : ""})`
-        );
-      };
-    }
-    return {
-      [`CallExpression[callee.property.name="toPromise"]`]: (node) => {
-        const memberExpression = node.callee;
-        if (!couldBeObservable(memberExpression.object)) {
-          return;
-        }
-        const { body } = context.sourceCode.ast;
-        const importDeclarations = body.filter(isImportDeclaration);
-        if (!importDeclarations.length) {
-          return;
-        }
-        context.report({
-          messageId: "forbidden",
-          node: memberExpression.property,
-          suggest: [
-            {
-              messageId: "suggestLastValueFromWithDefault",
-              fix: createFix("lastValueFrom", node, memberExpression.object, importDeclarations, { withDefault: true })
-            },
-            {
-              messageId: "suggestLastValueFrom",
-              fix: createFix("lastValueFrom", node, memberExpression.object, importDeclarations)
-            },
-            {
-              messageId: "suggestFirstValueFrom",
-              fix: createFix("firstValueFrom", node, memberExpression.object, importDeclarations)
-            }
-          ]
-        });
-      }
-    };
-  }
-});
-
-// src/rules/no-unbound-methods.ts
-import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var defaultOptions12 = [];
-var noUnboundMethodsRule = ruleCreator({
-  defaultOptions: defaultOptions12,
-  meta: {
-    docs: {
-      description: "Disallow passing unbound methods.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Unbound methods are forbidden."
-    },
-    schema: [
-      {
-        properties: {
-          allowTypes: { type: "array", items: { type: "string" }, description: "An array of function types that are allowed to be passed unbound.", default: DEFAULT_UNBOUND_ALLOWED_TYPES }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: "no-unbound-methods",
-  create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils10.getParserServices(context);
-    const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
-    const nodeMap = /* @__PURE__ */ new WeakMap();
-    const [config = {}] = context.options;
-    const { allowTypes = DEFAULT_UNBOUND_ALLOWED_TYPES } = config;
-    function mapArguments(node) {
-      node.arguments.filter(isMemberExpression).forEach((arg) => {
-        const argType = getTypeAtLocation(arg);
-        if (allowTypes.some((t) => couldBeType(argType, t))) {
-          return;
-        }
-        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;
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-unnecessary-collection.ts
-var noUnnecessaryCollectionRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow unnecessary usage of collection arguments with single values.",
-      recommended: "strict",
-      requiresTypeChecking: false
-    },
-    messages: {
-      forbidden: "Unnecessary {{operator}} with {{inputType}}. Use the observable directly instead."
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  name: "no-unnecessary-collection",
-  create: (context) => {
-    const { couldBeType: couldBeType2, couldBeObservable } = getTypeServices(context);
-    function couldBeFromRxjs(node, operatorName) {
-      return couldBeType2(node, operatorName, { name: /[/\\]rxjs[/\\]/ });
-    }
-    function checkCallExpression(node, operatorName) {
-      const args = node.arguments;
-      if (args.length === 0) {
-        return;
-      }
-      const firstArg = args[0];
-      if (isArrayExpression(firstArg)) {
-        const nonNullElements = firstArg.elements.filter((element) => element !== null);
-        if (nonNullElements.length === 1 && couldBeObservable(nonNullElements[0])) {
-          context.report({
-            messageId: "forbidden",
-            node: node.callee,
-            data: {
-              operator: operatorName,
-              inputType: "single-valued array"
-            }
-          });
-        }
-        return;
-      }
-      if (isObjectExpression(firstArg) && SOURCES_OBJECT_ACCEPTING_STATIC_OBSERVABLE_CREATORS.includes(operatorName)) {
-        if (firstArg.properties.length === 1 && isProperty(firstArg.properties[0])) {
-          const property = firstArg.properties[0];
-          if (property.value && couldBeObservable(property.value)) {
-            context.report({
-              messageId: "forbidden",
-              node: node.callee,
-              data: {
-                operator: operatorName,
-                inputType: "single-property object"
-              }
-            });
-          }
-        }
-        return;
-      }
-      if (args.length === 1 && !isSpreadElement(firstArg) && couldBeObservable(firstArg)) {
-        context.report({
-          messageId: "forbidden",
-          node: node.callee,
-          data: {
-            operator: operatorName,
-            inputType: "single argument"
-          }
-        });
-      }
-    }
-    const callExpressionVisitors = {};
-    for (const operator of MULTIPLE_OBSERVABLE_ACCEPTING_STATIC_OBSERVABLE_CREATORS) {
-      callExpressionVisitors[`CallExpression[callee.name="${operator}"]`] = (node) => {
-        if (couldBeFromRxjs(node.callee, operator)) {
-          checkCallExpression(node, operator);
-        }
-      };
-    }
-    for (const operator of MULTIPLE_OBSERVABLE_ACCEPTING_STATIC_OBSERVABLE_CREATORS) {
-      callExpressionVisitors[`CallExpression[callee.type="MemberExpression"][callee.property.name="${operator}"]`] = (node) => {
-        const memberExpr = node.callee;
-        if (couldBeFromRxjs(memberExpr.property, operator)) {
-          checkCallExpression(node, operator);
-        }
-      };
-    }
-    return callExpressionVisitors;
-  }
-});
-
-// src/rules/no-unsafe-catch.ts
-import { stripIndent as stripIndent5 } from "common-tags";
-var defaultOptions13 = [];
-var noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions13,
-  meta: {
-    docs: {
-      description: "Disallow 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", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
-        },
-        type: "object",
-        description: stripIndent5`
-          An optional object with an optional \`observable\` property.
-          The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
-      }
-    ],
-    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
-    };
-  }
-});
-
-// src/rules/no-unsafe-first.ts
-import { stripIndent as stripIndent6 } from "common-tags";
-var defaultOptions14 = [];
-var noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions14,
-  meta: {
-    docs: {
-      description: "Disallow 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", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
-        },
-        type: "object",
-        description: stripIndent6`
-          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();
-      }
-    };
-  }
-});
-
-// src/rules/no-unsafe-subject-next.ts
-import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-import * as tsutils5 from "ts-api-utils";
-import ts6 from "typescript";
-var noUnsafeSubjectNext = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow unsafe optional `next` calls.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Unsafe optional next calls are forbidden."
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: "no-unsafe-subject-next",
-  create: (context) => {
-    const { getTypeAtLocation, program } = ESLintUtils11.getParserServices(context);
-    const typeChecker = program.getTypeChecker();
-    return {
-      [`CallExpression[callee.property.name='next']`]: (node) => {
-        if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
-          const type = getTypeAtLocation(node.callee.object);
-          if (tsutils5.isTypeReference(type) && couldBeType(type, "Subject")) {
-            const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
-              return;
-            }
-            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
-              return;
-            }
-            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
-              return;
-            }
-            if (tsutils5.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils5.isTypeFlagSet(t, ts6.TypeFlags.Void)
-            )) {
-              return;
-            }
-            context.report({
-              messageId: "forbidden",
-              node: node.callee.property
-            });
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/rules/no-unsafe-switchmap.ts
-import { stripIndent as stripIndent7 } from "common-tags";
-import decamelize from "decamelize";
-var DEFAULT_DISALLOW = [
-  "add",
-  "create",
-  "delete",
-  "post",
-  "put",
-  "remove",
-  "set",
-  "update"
-];
-var defaultOptions15 = [];
-var noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions15,
-  meta: {
-    docs: {
-      description: "Disallow unsafe `switchMap` usage in effects and epics.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Unsafe switchMap usage in effects and epics is forbidden."
-    },
-    schema: [
-      {
-        properties: {
-          allow: {
-            description: "Action types that are allowed to be used with switchMap. Mutually exclusive with `disallow`.",
-            oneOf: [
-              { 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", description: "A regular expression string." },
-              { type: "array", items: { type: "string" }, description: "An array of words." }
-            ],
-            default: DEFAULT_DISALLOW
-          },
-          observable: {
-            type: "string",
-            description: "A RegExp that matches an effect or epic's actions observable.",
-            default: defaultObservable
-          }
-        },
-        type: "object",
-        description: stripIndent7`
-          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) => {
-    var _a, _b, _c;
-    let allowRegExp = void 0;
-    let disallowRegExp = void 0;
-    const [config = {}] = context.options;
-    if (config.allow) {
-      allowRegExp = createRegExpForWords((_a = config.allow) != null ? _a : []);
-    } else {
-      disallowRegExp = createRegExpForWords((_b = config.disallow) != null ? _b : DEFAULT_DISALLOW);
-    }
-    const observableRegExp = new RegExp((_c = config.observable) != null ? _c : 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((name2) => decamelize(name2));
-      if (allowRegExp) {
-        return !names.every((name2) => allowRegExp == null ? void 0 : allowRegExp.test(name2));
-      }
-      if (disallowRegExp) {
-        return names.some((name2) => disallowRegExp == null ? void 0 : disallowRegExp.test(name2));
-      }
-      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
-    };
-  }
-});
-
-// src/rules/no-unsafe-takeuntil.ts
-import { stripIndent as stripIndent8 } from "common-tags";
-var defaultOptions16 = [];
-var noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions16,
-  meta: {
-    docs: {
-      description: "Disallow applying operators after `takeUntil`.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Applying operators after takeUntil is forbidden."
-    },
-    schema: [
-      {
-        properties: {
-          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: DEFAULT_VALID_POST_COMPLETION_OPERATORS }
-        },
-        type: "object",
-        description: stripIndent8`
-          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 [config = {}] = context.options;
-    const { alias, allow = DEFAULT_VALID_POST_COMPLETION_OPERATORS } = 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;
-      }
-      const { isOrderValid, operatorNode } = findIsLastOperatorOrderValid(
-        pipeCallExpression,
-        checkedOperatorsRegExp,
-        allow
-      );
-      if (!isOrderValid && operatorNode) {
-        context.report({
-          messageId: "forbidden",
-          node: operatorNode
-        });
-      }
-    }
-    return {
-      [`CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=${checkedOperatorsRegExp}]`]: checkNode,
-      [`CallExpression[callee.property.name='pipe'] > CallExpression[callee.property.name=${checkedOperatorsRegExp}]`]: checkNode
-    };
-  }
-});
-
-// src/rules/prefer-observer.ts
-var defaultOptions17 = [];
-var preferObserverRule = ruleCreator({
-  defaultOptions: defaultOptions17,
-  meta: {
-    docs: {
-      description: "Disallow passing separate handlers to `subscribe` and `tap`.",
-      recommended: "recommended",
-      requiresTypeChecking: true
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      forbidden: "Passing separate handlers is forbidden; pass an observer instead.",
-      suggest: "Replace with observer object."
-    },
-    schema: [
-      {
-        properties: {
-          allowNext: { type: "boolean", description: "Allows a single `next` callback.", default: true }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: "prefer-observer",
-  create: (context) => {
-    const { couldBeFunction: couldBeFunction2, 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: "suggest",
-              fix
-            }
-          ]
-        });
-      } else if (args.length === 1 && !allowNext) {
-        const [arg] = args;
-        if (isArrowFunctionExpression(arg) || isFunctionExpression(arg) || couldBeFunction2(arg)) {
-          context.report({
-            messageId: "forbidden",
-            node: reportNode,
-            fix,
-            suggest: [
-              {
-                messageId: "suggest",
-                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";
-}
-
-// src/rules/prefer-root-operators.ts
-var RENAMED_OPERATORS = {
-  combineLatest: "combineLatestWith",
-  concat: "concatWith",
-  merge: "mergeWith",
-  onErrorResumeNext: "onErrorResumeNextWith",
-  race: "raceWith",
-  zip: "zipWith"
-};
-var DEPRECATED_OPERATORS = [
-  "partition"
-];
-var preferRootOperatorsRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow importing operators from `rxjs/operators`.",
-      recommended: "recommended"
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      forbidden: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead.",
-      forbiddenWithoutFix: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead. Note some operators may have been renamed or deprecated.",
-      suggest: "Replace with import from `rxjs`."
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  name: "prefer-root-operators",
-  create: (context) => {
-    function getQuote(raw) {
-      const match = /^\s*('|")/.exec(raw);
-      if (!match) {
-        return void 0;
-      }
-      const [, quote] = match;
-      return quote;
-    }
-    function getSourceReplacement(rawLocation) {
-      const quote = getQuote(rawLocation);
-      if (!quote) {
-        return void 0;
-      }
-      if (/^['"]rxjs\/operators/.test(rawLocation)) {
-        return `${quote}rxjs${quote}`;
-      }
-      return void 0;
-    }
-    function hasDeprecatedOperators(specifiers) {
-      return !!(specifiers == null ? void 0 : specifiers.some((s) => DEPRECATED_OPERATORS.includes(getName(getOperatorNode(s)))));
-    }
-    function getName(node) {
-      return isIdentifier(node) ? node.name : node.value;
-    }
-    function getOperatorNode(node) {
-      return isImportSpecifier(node) ? node.imported : node.local;
-    }
-    function getAliasNode(node) {
-      return isImportSpecifier(node) ? node.local : node.exported;
-    }
-    function getOperatorReplacement(name2) {
-      return RENAMED_OPERATORS[name2];
-    }
-    function isNodesEqual(a, b) {
-      return a.range[0] === b.range[0] && a.range[1] === b.range[1];
-    }
-    function createFix(source, replacement, specifiers) {
-      return function* fix(fixer) {
-        yield fixer.replaceText(source, replacement);
-        for (const specifier of specifiers) {
-          const operatorNode = getOperatorNode(specifier);
-          const operatorName = getName(operatorNode);
-          const operatorReplacement = getOperatorReplacement(operatorName);
-          if (!operatorReplacement) {
-            continue;
-          }
-          const aliasNode = getAliasNode(specifier);
-          if (isNodesEqual(aliasNode, operatorNode)) {
-            yield fixer.insertTextBefore(operatorNode, operatorReplacement + " as ");
-          } else if (isIdentifier(operatorNode)) {
-            yield fixer.replaceText(operatorNode, operatorReplacement);
-          } else {
-            const quote = getQuote(operatorNode.raw);
-            if (!quote) {
-              continue;
-            }
-            yield fixer.replaceText(operatorNode, quote + operatorReplacement + quote);
-          }
-        }
-      };
-    }
-    function reportNode(source, specifiers) {
-      const replacement = getSourceReplacement(source.raw);
-      if (!replacement || hasDeprecatedOperators(specifiers)) {
-        context.report({
-          messageId: "forbiddenWithoutFix",
-          node: source
-        });
-        return;
-      }
-      if (!specifiers) {
-        context.report({
-          messageId: "forbiddenWithoutFix",
-          node: source,
-          suggest: [{ messageId: "suggest", fix: (fixer) => fixer.replaceText(source, replacement) }]
-        });
-        return;
-      }
-      const fix = createFix(source, replacement, specifiers);
-      context.report({
-        fix,
-        messageId: "forbidden",
-        node: source,
-        suggest: [{ messageId: "suggest", fix }]
-      });
-    }
-    return {
-      'ImportDeclaration[source.value="rxjs/operators"]': (node) => {
-        const specifiers = node.specifiers.length && node.specifiers.every((importClause) => isImportSpecifier(importClause)) ? node.specifiers : void 0;
-        reportNode(node.source, specifiers);
-      },
-      'ImportExpression[source.value="rxjs/operators"]': (node) => {
-        if (isLiteral(node.source)) {
-          reportNode(node.source);
-        }
-      },
-      'ExportNamedDeclaration[source.value="rxjs/operators"]': (node) => {
-        reportNode(node.source, node.specifiers);
-      },
-      'ExportAllDeclaration[source.value="rxjs/operators"]': (node) => {
-        reportNode(node.source);
-      }
-    };
-  }
-});
-
-// src/rules/suffix-subjects.ts
-import { ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
-var defaultOptions18 = [];
-var baseShouldHaveSuffix = 'Subject identifiers must end with "{{suffix}}".';
-var suffixSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions18,
-  meta: {
-    docs: {
-      description: "Enforce the use of a suffix in subject identifiers.",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: baseShouldHaveSuffix,
-      forbiddenProperty: `${baseShouldHaveSuffix} Add a type annotation, assertion, or 'satisfies' to silence this rule.`
-    },
-    schema: [
-      {
-        properties: {
-          parameters: { type: "boolean", description: "Require for parameters." },
-          properties: { type: "boolean", description: 'Require for properties, except object literal keys (see "objects" option).' },
-          objects: { type: "boolean", description: "Require for object literal keys." },
-          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"
-      }
-    ],
-    type: "problem"
-  },
-  name: "suffix-subjects",
-  create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils12.getParserServices(context);
-    const { couldBeType: couldBeType2 } = getTypeServices(context);
-    const [config = {}] = context.options;
-    const validate = {
-      parameters: true,
-      properties: true,
-      objects: 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, shouldMessage = "forbidden") {
-      const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
-      const text = tsNode.getText();
-      if (!suffixRegex.test(text) && couldBeType2(typeNode != null ? typeNode : nameNode, "Subject")) {
-        for (const type of types) {
-          const { regExp, validate: validate2 } = type;
-          if (couldBeType2(typeNode != null ? typeNode : nameNode, regExp) && !validate2) {
-            return;
-          }
-        }
-        context.report({
-          data: { suffix },
-          loc: getLoc(tsNode),
-          messageId: shouldMessage
-        });
-      }
-    }
-    return {
-      "ArrayPattern > Identifier": (node) => {
-        const found = findParent(
-          node,
-          "ArrowFunctionExpression",
-          "FunctionDeclaration",
-          "FunctionExpression",
-          "VariableDeclarator"
-        );
-        if (!found) {
-          return;
-        }
-        if (!validate.variables && isVariableDeclarator(found)) {
-          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) {
-          if (node.override) {
-            return;
-          }
-          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) {
-          if (node.override) {
-            return;
-          }
-          checkNode(node.key, node);
-        }
-      },
-      "MethodDefinition[kind='set'][computed=false]": (node) => {
-        if (validate.properties) {
-          if (node.override) {
-            return;
-          }
-          checkNode(node.key, node);
-        }
-      },
-      "TSAbstractMethodDefinition[computed=false]": (node) => {
-        if (node.override) {
-          return;
-        }
-        if (validate.properties && (node.kind === "get" || node.kind === "set")) {
-          checkNode(node.key, node);
-        }
-        if (validate.parameters) {
-          node.value.params.forEach((param) => {
-            checkNode(param);
-          });
-        }
-      },
-      "ObjectExpression > Property[computed=false] > Identifier": (node) => {
-        if (!validate.objects) {
-          return;
-        }
-        const parent = node.parent;
-        if (node !== parent.key) {
-          return;
-        }
-        const found = findParent(
-          node,
-          "CallExpression",
-          "VariableDeclarator",
-          "TSSatisfiesExpression",
-          "TSAsExpression"
-        );
-        if (found) {
-          if (isCallExpression(found)) {
-            return;
-          } else if (isVariableDeclarator(found) && !!found.id.typeAnnotation) {
-            return;
-          } else if (isTSAsExpression(found) || isTSSatisfiesExpression(found)) {
-            return;
-          }
-        }
-        checkNode(node, void 0, "forbiddenProperty");
-      },
-      "ObjectPattern > Property > Identifier": (node) => {
-        const found = findParent(
-          node,
-          "ArrowFunctionExpression",
-          "FunctionDeclaration",
-          "FunctionExpression",
-          "VariableDeclarator"
-        );
-        if (!found) {
-          return;
-        }
-        if (!validate.variables && isVariableDeclarator(found)) {
-          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);
-        }
-      }
-    };
-  }
-});
-
-// src/rules/throw-error.ts
-import { ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
-import * as tsutils6 from "ts-api-utils";
-var defaultOptions19 = [];
-var throwErrorRule = ruleCreator({
-  defaultOptions: defaultOptions19,
-  meta: {
-    docs: {
-      description: "Enforce passing only `Error` values to `throwError` or `Subject.error`.",
-      recommended: {
-        recommended: true,
-        strict: [{ allowThrowingAny: false, allowThrowingUnknown: false }]
-      },
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Passing non-Error values is forbidden.",
-      suggestErrorConstructor: "Wrap string in Error constructor."
-    },
-    schema: [
-      {
-        properties: {
-          allowThrowingAny: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `any`." },
-          allowThrowingUnknown: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `unknown`." }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem",
-    hasSuggestions: true
-  },
-  name: "throw-error",
-  create: (context) => {
-    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils13.getParserServices(context);
-    const { couldBeObservable, couldBeSubject } = getTypeServices(context);
-    const [config = {}] = context.options;
-    const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
-    function checkThrowArgument(node, noFunction = false) {
-      var _a;
-      let type = getTypeAtLocation(node);
-      let reportNode = node;
-      if (!noFunction && couldBeFunction(type)) {
-        reportNode = (_a = node.body) != null ? _a : node;
-        const tsNode = esTreeNodeToTSNodeMap.get(node);
-        const annotation = tsNode.type;
-        const body = tsNode.body;
-        type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
-      }
-      if (allowThrowingAny && tsutils6.isIntrinsicAnyType(type)) {
-        return;
-      }
-      if (allowThrowingUnknown && tsutils6.isIntrinsicUnknownType(type)) {
-        return;
-      }
-      if (couldBeType(type, /^Error$/)) {
-        return;
-      }
-      const isString = isTemplateLiteral(reportNode) || isLiteral(reportNode) && typeof reportNode.value === "string";
-      context.report({
-        messageId: "forbidden",
-        node: reportNode,
-        ...isString && {
-          suggest: [
-            {
-              messageId: "suggestErrorConstructor",
-              fix: (fixer) => {
-                const sourceCode = context.sourceCode;
-                const nodeText = sourceCode.getText(reportNode);
-                return fixer.replaceText(reportNode, `new Error(${nodeText})`);
-              }
-            }
-          ]
-        }
-      });
-    }
-    function checkThrowError(node) {
-      if (couldBeObservable(node)) {
-        const [arg] = node.arguments;
-        if (arg) {
-          checkThrowArgument(arg);
-        }
-      }
-    }
-    function checkSubjectError(node) {
-      if (isMemberExpression(node.callee) && couldBeSubject(node.callee.object)) {
-        const [arg] = node.arguments;
-        if (arg) {
-          checkThrowArgument(arg, true);
-        }
-      }
-    }
-    return {
-      "CallExpression[callee.name='throwError']": checkThrowError,
-      "CallExpression[callee.property.name='throwError']": checkThrowError,
-      "CallExpression[callee.property.name='error']": checkSubjectError
-    };
-  }
-});
-
-// src/index.ts
-var allRules = {
-  "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-floating-observables": noFloatingObservablesRule,
-  "no-ignored-default-value": noIgnoredDefaultValueRule,
-  "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-misused-observables": noMisusedObservablesRule,
-  "no-nested-subscribe": noNestedSubscribeRule,
-  "no-redundant-notify": noRedundantNotifyRule,
-  "no-sharereplay": noSharereplayRule,
-  "no-sharereplay-before-takeuntil": noSharereplayBeforeTakeuntilRule,
-  "no-subclass": noSubclassRule,
-  "no-subject-unsubscribe": noSubjectUnsubscribeRule,
-  "no-subject-value": noSubjectValueRule,
-  "no-subscribe-handlers": noSubscribeHandlersRule,
-  "no-subscribe-in-pipe": noSubscribeInPipeRule,
-  "no-tap": noTapRule,
-  "no-topromise": noTopromiseRule,
-  "no-unbound-methods": noUnboundMethodsRule,
-  "no-unnecessary-collection": noUnnecessaryCollectionRule,
-  "no-unsafe-catch": noUnsafeCatchRule,
-  "no-unsafe-first": noUnsafeFirstRule,
-  "no-unsafe-subject-next": noUnsafeSubjectNext,
-  "no-unsafe-switchmap": noUnsafeSwitchmapRule,
-  "no-unsafe-takeuntil": noUnsafeTakeuntilRule,
-  "prefer-observer": preferObserverRule,
-  "prefer-root-operators": preferRootOperatorsRule,
-  "suffix-subjects": suffixSubjectsRule,
-  "throw-error": throwErrorRule
-};
-var plugin = {
-  meta: {
-    name,
-    version,
-    namespace: "rxjs-x"
-  },
-  /** Compatibility with `defineConfig` until https://github.com/typescript-eslint/typescript-eslint/issues/11543 is addressed. */
-  rules: allRules
-};
-var rxjsX = {
-  ...plugin,
-  configs: {
-    "recommended": createRecommendedConfig(plugin),
-    "strict": createStrictConfig(plugin),
-    "recommended-legacy": createLegacyRecommendedConfig()
-  }
-};
-var index_default = rxjsX;
-export {
-  index_default as default
-};