Upload folder using huggingface_hub (part 2)

node_modules/eslint-plugin-react/lib/rules/no-unsafe.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-unsafe.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-unsafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsafe.d.ts","sourceRoot":"","sources":["no-unsafe.js"],"names":[],"mappings":"wBAqBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-unsafe.js

@@ -0,0 +1,151 @@
+/**
+ * @fileoverview Prevent usage of unsafe lifecycle methods
+ * @author Sergei Startsev
+ */
+
+'use strict';
+
+const astUtil = require('../util/ast');
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const testReactVersion = require('../util/version').testReactVersion;
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  unsafeMethod: '{{method}} is unsafe for use in async rendering. Update the component to use {{newMethod}} instead. {{details}}',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of unsafe lifecycle methods',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-unsafe'),
+    },
+
+    messages,
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          checkAliases: {
+            default: false,
+            type: 'boolean',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const config = context.options[0] || {};
+    const checkAliases = config.checkAliases || false;
+
+    const isApplicable = testReactVersion(context, '>= 16.3.0');
+    if (!isApplicable) {
+      return {};
+    }
+
+    const unsafe = {
+      UNSAFE_componentWillMount: {
+        newMethod: 'componentDidMount',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+      },
+      UNSAFE_componentWillReceiveProps: {
+        newMethod: 'getDerivedStateFromProps',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+      },
+      UNSAFE_componentWillUpdate: {
+        newMethod: 'componentDidUpdate',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+      },
+    };
+    if (checkAliases) {
+      unsafe.componentWillMount = unsafe.UNSAFE_componentWillMount;
+      unsafe.componentWillReceiveProps = unsafe.UNSAFE_componentWillReceiveProps;
+      unsafe.componentWillUpdate = unsafe.UNSAFE_componentWillUpdate;
+    }
+
+    /**
+     * Returns a list of unsafe methods
+     * @returns {Array} A list of unsafe methods
+     */
+    function getUnsafeMethods() {
+      return Object.keys(unsafe);
+    }
+
+    /**
+     * Checks if a passed method is unsafe
+     * @param {string} method Life cycle method
+     * @returns {boolean} Returns true for unsafe methods, otherwise returns false
+     */
+    function isUnsafe(method) {
+      const unsafeMethods = getUnsafeMethods();
+      return unsafeMethods.indexOf(method) !== -1;
+    }
+
+    /**
+     * Reports the error for an unsafe method
+     * @param {ASTNode} node The AST node being checked
+     * @param {string} method Life cycle method
+     */
+    function checkUnsafe(node, method) {
+      if (!isUnsafe(method)) {
+        return;
+      }
+
+      const meta = unsafe[method];
+      const newMethod = meta.newMethod;
+      const details = meta.details;
+
+      const propertyNode = astUtil.getComponentProperties(node)
+        .find((property) => astUtil.getPropertyName(property) === method);
+
+      report(context, messages.unsafeMethod, 'unsafeMethod', {
+        node: propertyNode,
+        data: {
+          method,
+          newMethod,
+          details,
+        },
+      });
+    }
+
+    /**
+     * Returns life cycle methods if available
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {Array} The array of methods.
+     */
+    function getLifeCycleMethods(node) {
+      const properties = astUtil.getComponentProperties(node);
+      return properties.map((property) => astUtil.getPropertyName(property));
+    }
+
+    /**
+     * Checks life cycle methods
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function checkLifeCycleMethods(node) {
+      if (componentUtil.isES5Component(node, context) || componentUtil.isES6Component(node, context)) {
+        const methods = getLifeCycleMethods(node);
+        methods
+          .sort((a, b) => a.localeCompare(b))
+          .forEach((method) => checkUnsafe(node, method));
+      }
+    }
+
+    return {
+      ClassDeclaration: checkLifeCycleMethods,
+      ClassExpression: checkLifeCycleMethods,
+      ObjectExpression: checkLifeCycleMethods,
+    };
+  },
+};

node_modules/eslint-plugin-react/lib/rules/no-unstable-nested-components.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-unstable-nested-components.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-unstable-nested-components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unstable-nested-components.d.ts","sourceRoot":"","sources":["no-unstable-nested-components.js"],"names":[],"mappings":"wBAsQW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-unstable-nested-components.js

@@ -0,0 +1,491 @@
+/**
+ * @fileoverview Prevent creating unstable components inside components
+ * @author Ari Perkkiö
+ */
+
+'use strict';
+
+const minimatch = require('minimatch');
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
+const isCreateElement = require('../util/isCreateElement');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Constants
+// ------------------------------------------------------------------------------
+
+const COMPONENT_AS_PROPS_INFO = ' If you want to allow component creation in props, set allowAsProps option to true.';
+const HOOK_REGEXP = /^use[A-Z0-9].*$/;
+
+// ------------------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * Generate error message with given parent component name
+ * @param {string} parentName Name of the parent component, if known
+ * @returns {string} Error message with parent component name
+ */
+function generateErrorMessageWithParentName(parentName) {
+  return `Do not define components during render. React will see a new component type on every render and destroy the entire subtree’s DOM nodes and state (https://reactjs.org/docs/reconciliation.html#elements-of-different-types). Instead, move this component definition out of the parent component${parentName ? ` “${parentName}” ` : ' '}and pass data as props.`;
+}
+
+/**
+ * Check whether given text matches the pattern passed in.
+ * @param {string} text Text to validate
+ * @param {string} pattern Pattern to match against
+ * @returns {boolean}
+ */
+function propMatchesRenderPropPattern(text, pattern) {
+  return typeof text === 'string' && minimatch(text, pattern);
+}
+
+/**
+ * Get closest parent matching given matcher
+ * @param {ASTNode} node The AST node
+ * @param {Context} context eslint context
+ * @param {Function} matcher Method used to match the parent
+ * @returns {ASTNode} The matching parent node, if any
+ */
+function getClosestMatchingParent(node, context, matcher) {
+  if (!node || !node.parent || node.parent.type === 'Program') {
+    return;
+  }
+
+  if (matcher(node.parent, context)) {
+    return node.parent;
+  }
+
+  return getClosestMatchingParent(node.parent, context, matcher);
+}
+
+/**
+ * Matcher used to check whether given node is a `createElement` call
+ * @param {ASTNode} node The AST node
+ * @param {Context} context eslint context
+ * @returns {boolean} True if node is a `createElement` call, false if not
+ */
+function isCreateElementMatcher(node, context) {
+  return (
+    astUtil.isCallExpression(node)
+    && isCreateElement(context, node)
+  );
+}
+
+/**
+ * Matcher used to check whether given node is a `ObjectExpression`
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is a `ObjectExpression`, false if not
+ */
+function isObjectExpressionMatcher(node) {
+  return node && node.type === 'ObjectExpression';
+}
+
+/**
+ * Matcher used to check whether given node is a `JSXExpressionContainer`
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is a `JSXExpressionContainer`, false if not
+ */
+function isJSXExpressionContainerMatcher(node) {
+  return node && node.type === 'JSXExpressionContainer';
+}
+
+/**
+ * Matcher used to check whether given node is a `JSXAttribute` of `JSXExpressionContainer`
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is a `JSXAttribute` of `JSXExpressionContainer`, false if not
+ */
+function isJSXAttributeOfExpressionContainerMatcher(node) {
+  return (
+    node
+    && node.type === 'JSXAttribute'
+    && node.value
+    && node.value.type === 'JSXExpressionContainer'
+  );
+}
+
+/**
+ * Matcher used to check whether given node is an object `Property`
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is a `Property`, false if not
+ */
+function isPropertyOfObjectExpressionMatcher(node) {
+  return (
+    node
+    && node.parent
+    && node.parent.type === 'Property'
+  );
+}
+
+/**
+ * Check whether given node or its parent is directly inside `map` call
+ * ```jsx
+ * {items.map(item => <li />)}
+ * ```
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is directly inside `map` call, false if not
+ */
+function isMapCall(node) {
+  return (
+    node
+    && node.callee
+    && node.callee.property
+    && node.callee.property.name === 'map'
+  );
+}
+
+/**
+ * Check whether given node is `ReturnStatement` of a React hook
+ * @param {ASTNode} node The AST node
+ * @param {Context} context eslint context
+ * @returns {boolean} True if node is a `ReturnStatement` of a React hook, false if not
+ */
+function isReturnStatementOfHook(node, context) {
+  if (
+    !node
+    || !node.parent
+    || node.parent.type !== 'ReturnStatement'
+  ) {
+    return false;
+  }
+
+  const callExpression = getClosestMatchingParent(node, context, astUtil.isCallExpression);
+  return (
+    callExpression
+    && callExpression.callee
+    && HOOK_REGEXP.test(callExpression.callee.name)
+  );
+}
+
+/**
+ * Check whether given node is declared inside a render prop
+ * ```jsx
+ * <Component renderFooter={() => <div />} />
+ * <Component>{() => <div />}</Component>
+ * ```
+ * @param {ASTNode} node The AST node
+ * @param {Context} context eslint context
+ * @param {string} propNamePattern a pattern to match render props against
+ * @returns {boolean} True if component is declared inside a render prop, false if not
+ */
+function isComponentInRenderProp(node, context, propNamePattern) {
+  if (
+    node
+    && node.parent
+    && node.parent.type === 'Property'
+    && node.parent.key
+    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
+  ) {
+    return true;
+  }
+
+  // Check whether component is a render prop used as direct children, e.g. <Component>{() => <div />}</Component>
+  if (
+    node
+    && node.parent
+    && node.parent.type === 'JSXExpressionContainer'
+    && node.parent.parent
+    && node.parent.parent.type === 'JSXElement'
+  ) {
+    return true;
+  }
+
+  const jsxExpressionContainer = getClosestMatchingParent(node, context, isJSXExpressionContainerMatcher);
+
+  // Check whether prop name indicates accepted patterns
+  if (
+    jsxExpressionContainer
+    && jsxExpressionContainer.parent
+    && jsxExpressionContainer.parent.type === 'JSXAttribute'
+    && jsxExpressionContainer.parent.name
+    && jsxExpressionContainer.parent.name.type === 'JSXIdentifier'
+  ) {
+    const propName = jsxExpressionContainer.parent.name.name;
+
+    // Starts with render, e.g. <Component renderFooter={() => <div />} />
+    if (propMatchesRenderPropPattern(propName, propNamePattern)) {
+      return true;
+    }
+
+    // Uses children prop explicitly, e.g. <Component children={() => <div />} />
+    if (propName === 'children') {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check whether given node is declared directly inside a render property
+ * ```jsx
+ * const rows = { render: () => <div /> }
+ * <Component rows={ [{ render: () => <div /> }] } />
+ *  ```
+ * @param {ASTNode} node The AST node
+ * @param {string} propNamePattern The pattern to match render props against
+ * @returns {boolean} True if component is declared inside a render property, false if not
+ */
+function isDirectValueOfRenderProperty(node, propNamePattern) {
+  return (
+    node
+    && node.parent
+    && node.parent.type === 'Property'
+    && node.parent.key
+    && node.parent.key.type === 'Identifier'
+    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
+  );
+}
+
+/**
+ * Resolve the component name of given node
+ * @param {ASTNode} node The AST node of the component
+ * @returns {string} Name of the component, if any
+ */
+function resolveComponentName(node) {
+  const parentName = node.id && node.id.name;
+  if (parentName) return parentName;
+
+  return (
+    node.type === 'ArrowFunctionExpression'
+    && node.parent
+    && node.parent.id
+    && node.parent.id.name
+  );
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow creating unstable components inside components',
+      category: 'Possible Errors',
+      recommended: false,
+      url: docsUrl('no-unstable-nested-components'),
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        customValidators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        allowAsProps: {
+          type: 'boolean',
+        },
+        propNamePattern: {
+          type: 'string',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components, utils) => {
+    const allowAsProps = context.options.some((option) => option && option.allowAsProps);
+    const propNamePattern = (context.options[0] || {}).propNamePattern || 'render*';
+
+    /**
+     * Check whether given node is declared inside class component's render block
+     * ```jsx
+     * class Component extends React.Component {
+     *   render() {
+     *     class NestedClassComponent extends React.Component {
+     * ...
+     * ```
+     * @param {ASTNode} node The AST node being checked
+     * @returns {boolean} True if node is inside class component's render block, false if not
+     */
+    function isInsideRenderMethod(node) {
+      const parentComponent = utils.getParentComponent(node);
+
+      if (!parentComponent || parentComponent.type !== 'ClassDeclaration') {
+        return false;
+      }
+
+      return (
+        node
+        && node.parent
+        && node.parent.type === 'MethodDefinition'
+        && node.parent.key
+        && node.parent.key.name === 'render'
+      );
+    }
+
+    /**
+     * Check whether given node is a function component declared inside class component.
+     * Util's component detection fails to detect function components inside class components.
+     * ```jsx
+     * class Component extends React.Component {
+     *  render() {
+     *    const NestedComponent = () => <div />;
+     * ...
+     * ```
+     * @param {ASTNode} node The AST node being checked
+     * @returns {boolean} True if given node a function component declared inside class component, false if not
+     */
+    function isFunctionComponentInsideClassComponent(node) {
+      const parentComponent = utils.getParentComponent(node);
+      const parentStatelessComponent = utils.getParentStatelessComponent(node);
+
+      return (
+        parentComponent
+        && parentStatelessComponent
+        && parentComponent.type === 'ClassDeclaration'
+        && utils.getStatelessComponent(parentStatelessComponent)
+        && utils.isReturningJSX(node)
+      );
+    }
+
+    /**
+     * Check whether given node is declared inside `createElement` call's props
+     * ```js
+     * React.createElement(Component, {
+     *   footer: () => React.createElement("div", null)
+     * })
+     * ```
+     * @param {ASTNode} node The AST node
+     * @returns {boolean} True if node is declare inside `createElement` call's props, false if not
+     */
+    function isComponentInsideCreateElementsProp(node) {
+      if (!components.get(node)) {
+        return false;
+      }
+
+      const createElementParent = getClosestMatchingParent(node, context, isCreateElementMatcher);
+
+      return (
+        createElementParent
+        && createElementParent.arguments
+        && createElementParent.arguments[1] === getClosestMatchingParent(node, context, isObjectExpressionMatcher)
+      );
+    }
+
+    /**
+     * Check whether given node is declared inside a component/object prop.
+     * ```jsx
+     * <Component footer={() => <div />} />
+     * { footer: () => <div /> }
+     * ```
+     * @param {ASTNode} node The AST node being checked
+     * @returns {boolean} True if node is a component declared inside prop, false if not
+     */
+    function isComponentInProp(node) {
+      if (isPropertyOfObjectExpressionMatcher(node)) {
+        return utils.isReturningJSX(node);
+      }
+
+      const jsxAttribute = getClosestMatchingParent(node, context, isJSXAttributeOfExpressionContainerMatcher);
+
+      if (!jsxAttribute) {
+        return isComponentInsideCreateElementsProp(node);
+      }
+
+      return utils.isReturningJSX(node);
+    }
+
+    /**
+     * Check whether given node is a stateless component returning non-JSX
+     * ```jsx
+     * {{ a: () => null }}
+     * ```
+     * @param {ASTNode} node The AST node being checked
+     * @returns {boolean} True if node is a stateless component returning non-JSX, false if not
+     */
+    function isStatelessComponentReturningNull(node) {
+      const component = utils.getStatelessComponent(node);
+
+      return component && !utils.isReturningJSX(component);
+    }
+
+    /**
+     * Check whether given node is a unstable nested component
+     * @param {ASTNode} node The AST node being checked
+     */
+    function validate(node) {
+      if (!node || !node.parent) {
+        return;
+      }
+
+      const isDeclaredInsideProps = isComponentInProp(node);
+
+      if (
+        !components.get(node)
+        && !isFunctionComponentInsideClassComponent(node)
+        && !isDeclaredInsideProps) {
+        return;
+      }
+
+      if (
+        // Support allowAsProps option
+        (isDeclaredInsideProps && (allowAsProps || isComponentInRenderProp(node, context, propNamePattern)))
+
+        // Prevent reporting components created inside Array.map calls
+        || isMapCall(node)
+        || isMapCall(node.parent)
+
+        // Do not mark components declared inside hooks (or falsy '() => null' clean-up methods)
+        || isReturnStatementOfHook(node, context)
+
+        // Do not mark objects containing render methods
+        || isDirectValueOfRenderProperty(node, propNamePattern)
+
+        // Prevent reporting nested class components twice
+        || isInsideRenderMethod(node)
+
+        // Prevent falsely reporting detected "components" which do not return JSX
+        || isStatelessComponentReturningNull(node)
+      ) {
+        return;
+      }
+
+      // Get the closest parent component
+      const parentComponent = getClosestMatchingParent(
+        node,
+        context,
+        (nodeToMatch) => components.get(nodeToMatch)
+      );
+
+      if (parentComponent) {
+        const parentName = resolveComponentName(parentComponent);
+
+        // Exclude lowercase parents, e.g. function createTestComponent()
+        // React-dom prevents creating lowercase components
+        if (parentName && parentName[0] === parentName[0].toLowerCase()) {
+          return;
+        }
+
+        let message = generateErrorMessageWithParentName(parentName);
+
+        // Add information about allowAsProps option when component is declared inside prop
+        if (isDeclaredInsideProps && !allowAsProps) {
+          message += COMPONENT_AS_PROPS_INFO;
+        }
+
+        report(context, message, null, {
+          node,
+        });
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      FunctionDeclaration(node) { validate(node); },
+      ArrowFunctionExpression(node) { validate(node); },
+      FunctionExpression(node) { validate(node); },
+      ClassDeclaration(node) { validate(node); },
+      CallExpression(node) { validate(node); },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/no-unused-class-component-methods.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-unused-class-component-methods.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-unused-class-component-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-class-component-methods.d.ts","sourceRoot":"","sources":["no-unused-class-component-methods.js"],"names":[],"mappings":"wBAoGW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-unused-class-component-methods.js

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview Prevent declaring unused methods and properties of component class
+ * @author Paweł Nowak, Berton Zhu
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const componentUtil = require('../util/componentUtil');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const LIFECYCLE_METHODS = new Set([
+  'constructor',
+  'componentDidCatch',
+  'componentDidMount',
+  'componentDidUpdate',
+  'componentWillMount',
+  'componentWillReceiveProps',
+  'componentWillUnmount',
+  'componentWillUpdate',
+  'getChildContext',
+  'getSnapshotBeforeUpdate',
+  'render',
+  'shouldComponentUpdate',
+  'UNSAFE_componentWillMount',
+  'UNSAFE_componentWillReceiveProps',
+  'UNSAFE_componentWillUpdate',
+]);
+
+const ES6_LIFECYCLE = new Set([
+  'state',
+]);
+
+const ES5_LIFECYCLE = new Set([
+  'getInitialState',
+  'getDefaultProps',
+  'mixins',
+]);
+
+function isKeyLiteralLike(node, property) {
+  return property.type === 'Literal'
+     || (property.type === 'TemplateLiteral' && property.expressions.length === 0)
+     || (node.computed === false && property.type === 'Identifier');
+}
+
+// Descend through all wrapping TypeCastExpressions and return the expression
+// that was cast.
+function uncast(node) {
+  while (node.type === 'TypeCastExpression') {
+    node = node.expression;
+  }
+  return node;
+}
+
+// Return the name of an identifier or the string value of a literal. Useful
+// anywhere that a literal may be used as a key (e.g., member expressions,
+// method definitions, ObjectExpression property keys).
+function getName(node) {
+  node = uncast(node);
+  const type = node.type;
+
+  if (type === 'Identifier') {
+    return node.name;
+  }
+  if (type === 'Literal') {
+    return String(node.value);
+  }
+  if (type === 'TemplateLiteral' && node.expressions.length === 0) {
+    return node.quasis[0].value.raw;
+  }
+  return null;
+}
+
+function isThisExpression(node) {
+  return uncast(node).type === 'ThisExpression';
+}
+
+function getInitialClassInfo(node, isClass) {
+  return {
+    classNode: node,
+    isClass,
+    // Set of nodes where properties were defined.
+    properties: new Set(),
+
+    // Set of names of properties that we've seen used.
+    usedProperties: new Set(),
+
+    inStatic: false,
+  };
+}
+
+const messages = {
+  unused: 'Unused method or property "{{name}}"',
+  unusedWithClass: 'Unused method or property "{{name}}" of class "{{className}}"',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow declaring unused methods of component class',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-unused-class-component-methods'),
+    },
+    messages,
+    schema: [],
+  },
+
+  create: ((context) => {
+    let classInfo = null;
+
+    // Takes an ObjectExpression node and adds all named Property nodes to the
+    // current set of properties.
+    function addProperty(node) {
+      classInfo.properties.add(node);
+    }
+
+    // Adds the name of the given node as a used property if the node is an
+    // Identifier or a Literal. Other node types are ignored.
+    function addUsedProperty(node) {
+      const name = getName(node);
+      if (name) {
+        classInfo.usedProperties.add(name);
+      }
+    }
+
+    function reportUnusedProperties() {
+      // Report all unused properties.
+      for (const node of classInfo.properties) { // eslint-disable-line no-restricted-syntax
+        const name = getName(node);
+        if (
+          !classInfo.usedProperties.has(name)
+           && !LIFECYCLE_METHODS.has(name)
+           && (classInfo.isClass ? !ES6_LIFECYCLE.has(name) : !ES5_LIFECYCLE.has(name))
+        ) {
+          const className = (classInfo.classNode.id && classInfo.classNode.id.name) || '';
+
+          const messageID = className ? 'unusedWithClass' : 'unused';
+          report(
+            context,
+            messages[messageID],
+            messageID,
+            {
+              node,
+              data: {
+                name,
+                className,
+              },
+            }
+          );
+        }
+      }
+    }
+
+    function exitMethod() {
+      if (!classInfo || !classInfo.inStatic) {
+        return;
+      }
+
+      classInfo.inStatic = false;
+    }
+
+    return {
+      ClassDeclaration(node) {
+        if (componentUtil.isES6Component(node, context)) {
+          classInfo = getInitialClassInfo(node, true);
+        }
+      },
+
+      ObjectExpression(node) {
+        if (componentUtil.isES5Component(node, context)) {
+          classInfo = getInitialClassInfo(node, false);
+        }
+      },
+
+      'ClassDeclaration:exit'() {
+        if (!classInfo) {
+          return;
+        }
+        reportUnusedProperties();
+        classInfo = null;
+      },
+
+      'ObjectExpression:exit'(node) {
+        if (!classInfo || classInfo.classNode !== node) {
+          return;
+        }
+        reportUnusedProperties();
+        classInfo = null;
+      },
+
+      Property(node) {
+        if (!classInfo || classInfo.classNode !== node.parent) {
+          return;
+        }
+
+        if (isKeyLiteralLike(node, node.key)) {
+          addProperty(node.key);
+        }
+      },
+
+      'ClassProperty, MethodDefinition, PropertyDefinition'(node) {
+        if (!classInfo) {
+          return;
+        }
+
+        if (node.static) {
+          classInfo.inStatic = true;
+          return;
+        }
+
+        if (isKeyLiteralLike(node, node.key)) {
+          addProperty(node.key);
+        }
+      },
+
+      'ClassProperty:exit': exitMethod,
+      'MethodDefinition:exit': exitMethod,
+      'PropertyDefinition:exit': exitMethod,
+
+      MemberExpression(node) {
+        if (!classInfo || classInfo.inStatic) {
+          return;
+        }
+
+        if (isThisExpression(node.object) && isKeyLiteralLike(node, node.property)) {
+          if (node.parent.type === 'AssignmentExpression' && node.parent.left === node) {
+            // detect `this.property = xxx`
+            addProperty(node.property);
+          } else {
+            // detect `this.property()`, `x = this.property`, etc.
+            addUsedProperty(node.property);
+          }
+        }
+      },
+
+      VariableDeclarator(node) {
+        if (!classInfo || classInfo.inStatic) {
+          return;
+        }
+
+        // detect `{ foo, bar: baz } = this`
+        if (node.init && isThisExpression(node.init) && node.id.type === 'ObjectPattern') {
+          node.id.properties
+            .filter((prop) => prop.type === 'Property' && isKeyLiteralLike(prop, prop.key))
+            .forEach((prop) => {
+              addUsedProperty('key' in prop ? prop.key : undefined);
+            });
+        }
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/no-unused-prop-types.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-unused-prop-types.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-unused-prop-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-prop-types.d.ts","sourceRoot":"","sources":["no-unused-prop-types.js"],"names":[],"mappings":"wBAiCW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-unused-prop-types.js

@@ -0,0 +1,171 @@
+/**
+ * @fileoverview Prevent definitions of unused prop types
+ * @author Evgueni Naverniouk
+ */
+
+'use strict';
+
+const values = require('object.values');
+
+// As for exceptions for props.children or props.className (and alike) look at
+// https://github.com/jsx-eslint/eslint-plugin-react/issues/7
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+/**
+ * Checks if the component must be validated
+ * @param {Object} component The component to process
+ * @returns {boolean} True if the component must be validated, false if not.
+ */
+function mustBeValidated(component) {
+  return !!component && !component.ignoreUnusedPropTypesValidation;
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  unusedPropType: '\'{{name}}\' PropType is defined but prop is never used',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow definitions of unused propTypes',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-unused-prop-types'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+          uniqueItems: true,
+        },
+        customValidators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        skipShapeProps: {
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const defaults = { skipShapeProps: true, customValidators: [], ignore: [] };
+    const configuration = Object.assign({}, defaults, context.options[0] || {});
+
+    /**
+     * Checks if the prop is ignored
+     * @param {string} name Name of the prop to check.
+     * @returns {boolean} True if the prop is ignored, false if not.
+     */
+    function isIgnored(name) {
+      return configuration.ignore.indexOf(name) !== -1;
+    }
+
+    /**
+     * Checks if a prop is used
+     * @param {ASTNode} node The AST node being checked.
+     * @param {Object} prop Declared prop object
+     * @returns {boolean} True if the prop is used, false if not.
+     */
+    function isPropUsed(node, prop) {
+      const usedPropTypes = node.usedPropTypes || [];
+      for (let i = 0, l = usedPropTypes.length; i < l; i++) {
+        const usedProp = usedPropTypes[i];
+        if (
+          prop.type === 'shape'
+          || prop.type === 'exact'
+          || prop.name === '__ANY_KEY__'
+          || usedProp.name === prop.name
+        ) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Used to recursively loop through each declared prop type
+     * @param {Object} component The component to process
+     * @param {ASTNode[]|true} props List of props to validate
+     */
+    function reportUnusedPropType(component, props) {
+      // Skip props that check instances
+      if (props === true) {
+        return;
+      }
+
+      Object.keys(props || {}).forEach((key) => {
+        const prop = props[key];
+        // Skip props that check instances
+        if (prop === true) {
+          return;
+        }
+
+        if ((prop.type === 'shape' || prop.type === 'exact') && configuration.skipShapeProps) {
+          return;
+        }
+
+        if (prop.node && prop.node.typeAnnotation && prop.node.typeAnnotation.typeAnnotation
+          && prop.node.typeAnnotation.typeAnnotation.type === 'TSNeverKeyword') {
+          return;
+        }
+
+        if (prop.node && !isIgnored(prop.fullName) && !isPropUsed(component, prop)) {
+          report(context, messages.unusedPropType, 'unusedPropType', {
+            node: prop.node.key || prop.node,
+            data: {
+              name: prop.fullName,
+            },
+          });
+        }
+
+        if (prop.children) {
+          reportUnusedPropType(component, prop.children);
+        }
+      });
+    }
+
+    /**
+     * Reports unused proptypes for a given component
+     * @param {Object} component The component to process
+     */
+    function reportUnusedPropTypes(component) {
+      reportUnusedPropType(component, component.declaredPropTypes);
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      'Program:exit'() {
+        // Report undeclared proptypes for all classes
+        values(components.list())
+          .filter((component) => mustBeValidated(component))
+          .forEach((component) => {
+            reportUnusedPropTypes(component);
+          });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/no-unused-state.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-unused-state.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-unused-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-state.d.ts","sourceRoot":"","sources":["no-unused-state.js"],"names":[],"mappings":"wBAgFW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-unused-state.js

@@ -0,0 +1,529 @@
+/**
+ * @fileoverview  Attempts to discover all state fields in a React component and
+ * warn if any of them are never read.
+ *
+ * State field definitions are collected from `this.state = {}` assignments in
+ * the constructor, objects passed to `this.setState()`, and `state = {}` class
+ * property assignments.
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
+const componentUtil = require('../util/componentUtil');
+const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
+
+// Descend through all wrapping TypeCastExpressions and return the expression
+// that was cast.
+function uncast(node) {
+  while (node.type === 'TypeCastExpression') {
+    node = node.expression;
+  }
+  return node;
+}
+
+// Return the name of an identifier or the string value of a literal. Useful
+// anywhere that a literal may be used as a key (e.g., member expressions,
+// method definitions, ObjectExpression property keys).
+function getName(node) {
+  node = uncast(node);
+  const type = node.type;
+
+  if (type === 'Identifier') {
+    return node.name;
+  }
+  if (type === 'Literal') {
+    return String(node.value);
+  }
+  if (type === 'TemplateLiteral' && node.expressions.length === 0) {
+    return node.quasis[0].value.raw;
+  }
+  return null;
+}
+
+function isThisExpression(node) {
+  return astUtil.unwrapTSAsExpression(uncast(node)).type === 'ThisExpression';
+}
+
+function getInitialClassInfo() {
+  return {
+    // Set of nodes where state fields were defined.
+    stateFields: new Set(),
+
+    // Set of names of state fields that we've seen used.
+    usedStateFields: new Set(),
+
+    // Names of local variables that may be pointing to this.state. To
+    // track this properly, we would need to keep track of all locals,
+    // shadowing, assignments, etc. To keep things simple, we only
+    // maintain one set of aliases per method and accept that it will
+    // produce some false negatives.
+    aliases: null,
+  };
+}
+
+function isSetStateCall(node) {
+  const unwrappedCalleeNode = astUtil.unwrapTSAsExpression(node.callee);
+
+  return (
+    unwrappedCalleeNode.type === 'MemberExpression'
+    && isThisExpression(unwrappedCalleeNode.object)
+    && getName(unwrappedCalleeNode.property) === 'setState'
+  );
+}
+
+const messages = {
+  unusedStateField: 'Unused state field: \'{{name}}\'',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow definitions of unused state',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('no-unused-state'),
+    },
+
+    messages,
+
+    schema: [],
+  },
+
+  create(context) {
+    // Non-null when we are inside a React component ClassDeclaration and we have
+    // not yet encountered any use of this.state which we have chosen not to
+    // analyze. If we encounter any such usage (like this.state being spread as
+    // JSX attributes), then this is again set to null.
+    let classInfo = null;
+
+    function isStateParameterReference(node) {
+      const classMethods = [
+        'shouldComponentUpdate',
+        'componentWillUpdate',
+        'UNSAFE_componentWillUpdate',
+        'getSnapshotBeforeUpdate',
+        'componentDidUpdate',
+      ];
+
+      let scope = getScope(context, node);
+      while (scope) {
+        const parent = scope.block && scope.block.parent;
+        if (
+          parent
+          && parent.type === 'MethodDefinition' && (
+            (parent.static && parent.key.name === 'getDerivedStateFromProps')
+            || classMethods.indexOf(parent.key.name) !== -1
+          )
+          && parent.value.type === 'FunctionExpression'
+          && parent.value.params[1]
+          && parent.value.params[1].name === node.name
+        ) {
+          return true;
+        }
+        scope = scope.upper;
+      }
+
+      return false;
+    }
+
+    // Returns true if the given node is possibly a reference to `this.state` or the state parameter of
+    // a lifecycle method.
+    function isStateReference(node) {
+      node = uncast(node);
+
+      const isDirectStateReference = node.type === 'MemberExpression'
+        && isThisExpression(node.object)
+        && node.property.name === 'state';
+
+      const isAliasedStateReference = node.type === 'Identifier'
+        && classInfo.aliases
+        && classInfo.aliases.has(node.name);
+
+      return isDirectStateReference || isAliasedStateReference || isStateParameterReference(node);
+    }
+
+    // Takes an ObjectExpression node and adds all named Property nodes to the
+    // current set of state fields.
+    function addStateFields(node) {
+      node.properties.filter((prop) => (
+        prop.type === 'Property'
+          && (prop.key.type === 'Literal'
+          || (prop.key.type === 'TemplateLiteral' && prop.key.expressions.length === 0)
+          || (prop.computed === false && prop.key.type === 'Identifier'))
+          && getName(prop.key) !== null
+      )).forEach((prop) => {
+        classInfo.stateFields.add(prop);
+      });
+    }
+
+    // Adds the name of the given node as a used state field if the node is an
+    // Identifier or a Literal. Other node types are ignored.
+    function addUsedStateField(node) {
+      if (!classInfo) {
+        return;
+      }
+      const name = getName(node);
+      if (name) {
+        classInfo.usedStateFields.add(name);
+      }
+    }
+
+    // Records used state fields and new aliases for an ObjectPattern which
+    // destructures `this.state`.
+    function handleStateDestructuring(node) {
+      node.properties.forEach((prop) => {
+        if (prop.type === 'Property') {
+          addUsedStateField(prop.key);
+        } else if (
+          (prop.type === 'ExperimentalRestProperty' || prop.type === 'RestElement')
+          && classInfo.aliases
+        ) {
+          classInfo.aliases.add(getName(prop.argument));
+        }
+      });
+    }
+
+    // Used to record used state fields and new aliases for both
+    // AssignmentExpressions and VariableDeclarators.
+    function handleAssignment(left, right) {
+      const unwrappedRight = astUtil.unwrapTSAsExpression(right);
+
+      switch (left.type) {
+        case 'Identifier':
+          if (isStateReference(unwrappedRight) && classInfo.aliases) {
+            classInfo.aliases.add(left.name);
+          }
+          break;
+        case 'ObjectPattern':
+          if (isStateReference(unwrappedRight)) {
+            handleStateDestructuring(left);
+          } else if (isThisExpression(unwrappedRight) && classInfo.aliases) {
+            left.properties.forEach((prop) => {
+              if (prop.type === 'Property' && getName(prop.key) === 'state') {
+                const name = getName(prop.value);
+                if (name) {
+                  classInfo.aliases.add(name);
+                } else if (prop.value.type === 'ObjectPattern') {
+                  handleStateDestructuring(prop.value);
+                }
+              }
+            });
+          }
+          break;
+        default:
+        // pass
+      }
+    }
+
+    function reportUnusedFields() {
+      // Report all unused state fields.
+      classInfo.stateFields.forEach((node) => {
+        const name = getName(node.key);
+        if (!classInfo.usedStateFields.has(name)) {
+          report(context, messages.unusedStateField, 'unusedStateField', {
+            node,
+            data: {
+              name,
+            },
+          });
+        }
+      });
+    }
+
+    function handleES6ComponentEnter(node) {
+      if (componentUtil.isES6Component(node, context)) {
+        classInfo = getInitialClassInfo();
+      }
+    }
+
+    function handleES6ComponentExit() {
+      if (!classInfo) {
+        return;
+      }
+      reportUnusedFields();
+      classInfo = null;
+    }
+
+    function isGDSFP(node) {
+      const name = getName(node.key);
+      if (
+        !node.static
+        || name !== 'getDerivedStateFromProps'
+        || !node.value
+        || !node.value.params
+        || node.value.params.length < 2 // no `state` argument
+      ) {
+        return false;
+      }
+      return true;
+    }
+
+    return {
+      ClassDeclaration: handleES6ComponentEnter,
+
+      'ClassDeclaration:exit': handleES6ComponentExit,
+
+      ClassExpression: handleES6ComponentEnter,
+
+      'ClassExpression:exit': handleES6ComponentExit,
+
+      ObjectExpression(node) {
+        if (componentUtil.isES5Component(node, context)) {
+          classInfo = getInitialClassInfo();
+        }
+      },
+
+      'ObjectExpression:exit'(node) {
+        if (!classInfo) {
+          return;
+        }
+
+        if (componentUtil.isES5Component(node, context)) {
+          reportUnusedFields();
+          classInfo = null;
+        }
+      },
+
+      CallExpression(node) {
+        if (!classInfo) {
+          return;
+        }
+
+        const unwrappedNode = astUtil.unwrapTSAsExpression(node);
+        const unwrappedArgumentNode = astUtil.unwrapTSAsExpression(unwrappedNode.arguments[0]);
+
+        // If we're looking at a `this.setState({})` invocation, record all the
+        // properties as state fields.
+        if (
+          isSetStateCall(unwrappedNode)
+          && unwrappedNode.arguments.length > 0
+          && unwrappedArgumentNode.type === 'ObjectExpression'
+        ) {
+          addStateFields(unwrappedArgumentNode);
+        } else if (
+          isSetStateCall(unwrappedNode)
+          && unwrappedNode.arguments.length > 0
+          && unwrappedArgumentNode.type === 'ArrowFunctionExpression'
+        ) {
+          const unwrappedBodyNode = astUtil.unwrapTSAsExpression(unwrappedArgumentNode.body);
+
+          if (unwrappedBodyNode.type === 'ObjectExpression') {
+            addStateFields(unwrappedBodyNode);
+          }
+          if (unwrappedArgumentNode.params.length > 0 && classInfo.aliases) {
+            const firstParam = unwrappedArgumentNode.params[0];
+            if (firstParam.type === 'ObjectPattern') {
+              handleStateDestructuring(firstParam);
+            } else {
+              classInfo.aliases.add(getName(firstParam));
+            }
+          }
+        }
+      },
+
+      'ClassProperty, PropertyDefinition'(node) {
+        if (!classInfo) {
+          return;
+        }
+        // If we see state being assigned as a class property using an object
+        // expression, record all the fields of that object as state fields.
+        const unwrappedValueNode = astUtil.unwrapTSAsExpression(node.value);
+
+        const name = getName(node.key);
+        if (
+          name === 'state'
+          && !node.static
+          && unwrappedValueNode
+          && unwrappedValueNode.type === 'ObjectExpression'
+        ) {
+          addStateFields(unwrappedValueNode);
+        }
+
+        if (
+          !node.static
+          && unwrappedValueNode
+          && unwrappedValueNode.type === 'ArrowFunctionExpression'
+        ) {
+          // Create a new set for this.state aliases local to this method.
+          classInfo.aliases = new Set();
+        }
+      },
+
+      'ClassProperty:exit'(node) {
+        if (
+          classInfo
+          && !node.static
+          && node.value
+          && node.value.type === 'ArrowFunctionExpression'
+        ) {
+          // Forget our set of local aliases.
+          classInfo.aliases = null;
+        }
+      },
+
+      'PropertyDefinition, ClassProperty'(node) {
+        if (!isGDSFP(node)) {
+          return;
+        }
+
+        const childScope = getScope(context, node).childScopes.find((x) => x.block === node.value);
+        if (!childScope) {
+          return;
+        }
+        const scope = childScope.variableScope.childScopes.find((x) => x.block === node.value);
+        const stateArg = node.value.params[1]; // probably "state"
+        if (!scope || !scope.variables) {
+          return;
+        }
+        const argVar = scope.variables.find((x) => x.name === stateArg.name);
+
+        if (argVar) {
+          const stateRefs = argVar.references;
+
+          stateRefs.forEach((ref) => {
+            const identifier = ref.identifier;
+            if (identifier && identifier.parent && identifier.parent.type === 'MemberExpression') {
+              addUsedStateField(identifier.parent.property);
+            }
+          });
+        }
+      },
+
+      'PropertyDefinition:exit'(node) {
+        if (
+          classInfo
+          && !node.static
+          && node.value
+          && node.value.type === 'ArrowFunctionExpression'
+          && !isGDSFP(node)
+        ) {
+          // Forget our set of local aliases.
+          classInfo.aliases = null;
+        }
+      },
+
+      MethodDefinition() {
+        if (!classInfo) {
+          return;
+        }
+        // Create a new set for this.state aliases local to this method.
+        classInfo.aliases = new Set();
+      },
+
+      'MethodDefinition:exit'() {
+        if (!classInfo) {
+          return;
+        }
+        // Forget our set of local aliases.
+        classInfo.aliases = null;
+      },
+
+      FunctionExpression(node) {
+        if (!classInfo) {
+          return;
+        }
+
+        const parent = node.parent;
+        if (!componentUtil.isES5Component(parent.parent, context)) {
+          return;
+        }
+
+        if (
+          'key' in parent
+          && 'name' in parent.key
+          && parent.key.name === 'getInitialState'
+        ) {
+          const body = node.body.body;
+          const lastBodyNode = body[body.length - 1];
+
+          if (
+            lastBodyNode.type === 'ReturnStatement'
+            && lastBodyNode.argument.type === 'ObjectExpression'
+          ) {
+            addStateFields(lastBodyNode.argument);
+          }
+        } else {
+          // Create a new set for this.state aliases local to this method.
+          classInfo.aliases = new Set();
+        }
+      },
+
+      AssignmentExpression(node) {
+        if (!classInfo) {
+          return;
+        }
+
+        const unwrappedLeft = astUtil.unwrapTSAsExpression(node.left);
+        const unwrappedRight = astUtil.unwrapTSAsExpression(node.right);
+
+        // Check for assignments like `this.state = {}`
+        if (
+          unwrappedLeft.type === 'MemberExpression'
+          && isThisExpression(unwrappedLeft.object)
+          && getName(unwrappedLeft.property) === 'state'
+          && unwrappedRight.type === 'ObjectExpression'
+        ) {
+          // Find the nearest function expression containing this assignment.
+          /** @type {import('eslint').Rule.Node} */
+          let fn = node;
+          while (fn.type !== 'FunctionExpression' && fn.parent) {
+            fn = fn.parent;
+          }
+          // If the nearest containing function is the constructor, then we want
+          // to record all the assigned properties as state fields.
+          if (
+            fn.parent
+            && fn.parent.type === 'MethodDefinition'
+            && fn.parent.kind === 'constructor'
+          ) {
+            addStateFields(unwrappedRight);
+          }
+        } else {
+          // Check for assignments like `alias = this.state` and record the alias.
+          handleAssignment(unwrappedLeft, unwrappedRight);
+        }
+      },
+
+      VariableDeclarator(node) {
+        if (!classInfo || !node.init) {
+          return;
+        }
+        handleAssignment(node.id, node.init);
+      },
+
+      'MemberExpression, OptionalMemberExpression'(node) {
+        if (!classInfo) {
+          return;
+        }
+        if (isStateReference(astUtil.unwrapTSAsExpression(node.object))) {
+          // If we see this.state[foo] access, give up.
+          if (node.computed && node.property.type !== 'Literal') {
+            classInfo = null;
+            return;
+          }
+          // Otherwise, record that we saw this property being accessed.
+          addUsedStateField(node.property);
+        // If we see a `this.state` access in a CallExpression, give up.
+        } else if (isStateReference(node) && astUtil.isCallExpression(node.parent)) {
+          classInfo = null;
+        }
+      },
+
+      JSXSpreadAttribute(node) {
+        if (classInfo && isStateReference(node.argument)) {
+          classInfo = null;
+        }
+      },
+
+      'ExperimentalSpreadProperty, SpreadElement'(node) {
+        if (classInfo && isStateReference(node.argument)) {
+          classInfo = null;
+        }
+      },
+    };
+  },
+};

node_modules/eslint-plugin-react/lib/rules/no-will-update-set-state.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=no-will-update-set-state.d.ts.map

node_modules/eslint-plugin-react/lib/rules/no-will-update-set-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-will-update-set-state.d.ts","sourceRoot":"","sources":["no-will-update-set-state.js"],"names":[],"mappings":"wBAUW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/no-will-update-set-state.js

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Prevent usage of setState in componentWillUpdate
+ * @author Yannick Croissant
+ */
+
+'use strict';
+
+const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
+const testReactVersion = require('../util/version').testReactVersion;
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = makeNoMethodSetStateRule(
+  'componentWillUpdate',
+  (context) => testReactVersion(context, '>= 16.3.0')
+);

node_modules/eslint-plugin-react/lib/rules/prefer-es6-class.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=prefer-es6-class.d.ts.map

node_modules/eslint-plugin-react/lib/rules/prefer-es6-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-es6-class.d.ts","sourceRoot":"","sources":["prefer-es6-class.js"],"names":[],"mappings":"wBAoBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/prefer-es6-class.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Enforce ES5 or ES6 class for React Components
+ * @author Dan Hamilton
+ */
+
+'use strict';
+
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  shouldUseES6Class: 'Component should use es6 class instead of createClass',
+  shouldUseCreateClass: 'Component should use createClass instead of es6 class',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce ES5 or ES6 class for React Components',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('prefer-es6-class'),
+    },
+
+    messages,
+
+    schema: [{
+      enum: ['always', 'never'],
+    }],
+  },
+
+  create(context) {
+    const configuration = context.options[0] || 'always';
+
+    return {
+      ObjectExpression(node) {
+        if (componentUtil.isES5Component(node, context) && configuration === 'always') {
+          report(context, messages.shouldUseES6Class, 'shouldUseES6Class', {
+            node,
+          });
+        }
+      },
+      ClassDeclaration(node) {
+        if (componentUtil.isES6Component(node, context) && configuration === 'never') {
+          report(context, messages.shouldUseCreateClass, 'shouldUseCreateClass', {
+            node,
+          });
+        }
+      },
+    };
+  },
+};

node_modules/eslint-plugin-react/lib/rules/prefer-exact-props.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=prefer-exact-props.d.ts.map

node_modules/eslint-plugin-react/lib/rules/prefer-exact-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-exact-props.d.ts","sourceRoot":"","sources":["prefer-exact-props.js"],"names":[],"mappings":"wBAwBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/prefer-exact-props.js

@@ -0,0 +1,162 @@
+/**
+ * @fileoverview Prefer exact proptype definitions
+ */
+
+'use strict';
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
+const propsUtil = require('../util/props');
+const propWrapperUtil = require('../util/propWrapper');
+const variableUtil = require('../util/variable');
+const report = require('../util/report');
+const getText = require('../util/eslint').getText;
+
+// -----------------------------------------------------------------------------
+// Rule Definition
+// -----------------------------------------------------------------------------
+
+const messages = {
+  propTypes: 'Component propTypes should be exact by using {{exactPropWrappers}}.',
+  flow: 'Component flow props should be set with exact objects.',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Prefer exact proptype definitions',
+      category: 'Possible Errors',
+      recommended: false,
+      url: docsUrl('prefer-exact-props'),
+    },
+    messages,
+    schema: [],
+  },
+
+  create: Components.detect((context, components, utils) => {
+    const typeAliases = {};
+    const exactWrappers = propWrapperUtil.getExactPropWrapperFunctions(context);
+
+    function getPropTypesErrorMessage() {
+      const formattedWrappers = propWrapperUtil.formatPropWrapperFunctions(exactWrappers);
+      const message = exactWrappers.size > 1 ? `one of ${formattedWrappers}` : formattedWrappers;
+      return { exactPropWrappers: message };
+    }
+
+    function isNonExactObjectTypeAnnotation(node) {
+      return (
+        node
+        && node.type === 'ObjectTypeAnnotation'
+        && node.properties.length > 0
+        && !node.exact
+      );
+    }
+
+    function hasNonExactObjectTypeAnnotation(node) {
+      const typeAnnotation = node.typeAnnotation;
+      return (
+        typeAnnotation
+        && typeAnnotation.typeAnnotation
+        && isNonExactObjectTypeAnnotation(typeAnnotation.typeAnnotation)
+      );
+    }
+
+    function hasGenericTypeAnnotation(node) {
+      const typeAnnotation = node.typeAnnotation;
+      return (
+        typeAnnotation
+        && typeAnnotation.typeAnnotation
+        && typeAnnotation.typeAnnotation.type === 'GenericTypeAnnotation'
+      );
+    }
+
+    function isNonEmptyObjectExpression(node) {
+      return (
+        node
+        && node.type === 'ObjectExpression'
+        && node.properties.length > 0
+      );
+    }
+
+    function isNonExactPropWrapperFunction(node) {
+      return (
+        astUtil.isCallExpression(node)
+        && !propWrapperUtil.isExactPropWrapperFunction(context, getText(context, node.callee))
+      );
+    }
+
+    function reportPropTypesError(node) {
+      report(context, messages.propTypes, 'propTypes', {
+        node,
+        data: getPropTypesErrorMessage(),
+      });
+    }
+
+    function reportFlowError(node) {
+      report(context, messages.flow, 'flow', {
+        node,
+      });
+    }
+
+    return {
+      TypeAlias(node) {
+        // working around an issue with eslint@3 and babel-eslint not finding the TypeAlias in scope
+        typeAliases[node.id.name] = node;
+      },
+
+      'ClassProperty, PropertyDefinition'(node) {
+        if (!propsUtil.isPropTypesDeclaration(node)) {
+          return;
+        }
+
+        if (hasNonExactObjectTypeAnnotation(node)) {
+          reportFlowError(node);
+        } else if (exactWrappers.size > 0 && isNonEmptyObjectExpression(node.value)) {
+          reportPropTypesError(node);
+        } else if (exactWrappers.size > 0 && isNonExactPropWrapperFunction(node.value)) {
+          reportPropTypesError(node);
+        }
+      },
+
+      Identifier(node) {
+        if (!utils.getStatelessComponent(node.parent)) {
+          return;
+        }
+
+        if (hasNonExactObjectTypeAnnotation(node)) {
+          reportFlowError(node);
+        } else if (hasGenericTypeAnnotation(node)) {
+          const identifier = node.typeAnnotation.typeAnnotation.id.name;
+          const typeAlias = typeAliases[identifier];
+          const propsDefinition = typeAlias ? typeAlias.right : null;
+          if (isNonExactObjectTypeAnnotation(propsDefinition)) {
+            reportFlowError(node);
+          }
+        }
+      },
+
+      MemberExpression(node) {
+        if (!propsUtil.isPropTypesDeclaration(node) || exactWrappers.size === 0) {
+          return;
+        }
+
+        const right = node.parent.right;
+        if (isNonEmptyObjectExpression(right)) {
+          reportPropTypesError(node);
+        } else if (isNonExactPropWrapperFunction(right)) {
+          reportPropTypesError(node);
+        } else if (right.type === 'Identifier') {
+          const identifier = right.name;
+          const propsDefinition = variableUtil.findVariableByName(context, node, identifier);
+          if (isNonEmptyObjectExpression(propsDefinition)) {
+            reportPropTypesError(node);
+          } else if (isNonExactPropWrapperFunction(propsDefinition)) {
+            reportPropTypesError(node);
+          }
+        }
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/prefer-read-only-props.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=prefer-read-only-props.d.ts.map

node_modules/eslint-plugin-react/lib/rules/prefer-read-only-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-read-only-props.d.ts","sourceRoot":"","sources":["prefer-read-only-props.js"],"names":[],"mappings":"wBAiDW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/prefer-read-only-props.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Require component props to be typed as read-only.
+ * @author Luke Zapart
+ */
+
+'use strict';
+
+const flatMap = require('array.prototype.flatmap');
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+function isFlowPropertyType(node) {
+  return node.type === 'ObjectTypeProperty';
+}
+
+function isTypescriptPropertyType(node) {
+  return node.type === 'TSPropertySignature';
+}
+
+function isCovariant(node) {
+  return (node.variance && node.variance.kind === 'plus')
+    || (
+      node.parent
+      && node.parent.parent
+      && node.parent.parent.parent
+      && node.parent.parent.parent.id
+      && node.parent.parent.parent.id.name === '$ReadOnly'
+    );
+}
+
+function isReadonly(node) {
+  return (
+    node.typeAnnotation
+    && node.typeAnnotation.parent
+    && node.typeAnnotation.parent.readonly
+  );
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  readOnlyProp: 'Prop \'{{name}}\' should be read-only.',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce that props are read-only',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('prefer-read-only-props'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [],
+  },
+
+  create: Components.detect((context, components) => {
+    function reportReadOnlyProp(prop, propName, fixer) {
+      report(context, messages.readOnlyProp, 'readOnlyProp', {
+        node: prop.node,
+        data: {
+          name: propName,
+        },
+        fix: fixer,
+      });
+    }
+
+    return {
+      'Program:exit'() {
+        flatMap(
+          values(components.list()),
+          (component) => component.declaredPropTypes || []
+        ).forEach((declaredPropTypes) => {
+          Object.keys(declaredPropTypes).forEach((propName) => {
+            const prop = declaredPropTypes[propName];
+            if (!prop.node) {
+              return;
+            }
+
+            if (isFlowPropertyType(prop.node)) {
+              if (!isCovariant(prop.node)) {
+                reportReadOnlyProp(prop, propName, (fixer) => {
+                  if (!prop.node.variance) {
+                    // Insert covariance
+                    return fixer.insertTextBefore(prop.node, '+');
+                  }
+
+                  // Replace contravariance with covariance
+                  return fixer.replaceText(prop.node.variance, '+');
+                });
+              }
+
+              return;
+            }
+
+            if (isTypescriptPropertyType(prop.node)) {
+              if (!isReadonly(prop.node)) {
+                reportReadOnlyProp(prop, propName, (fixer) => (
+                  fixer.insertTextBefore(prop.node, 'readonly ')
+                ));
+              }
+            }
+          });
+        });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/prefer-stateless-function.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=prefer-stateless-function.d.ts.map

node_modules/eslint-plugin-react/lib/rules/prefer-stateless-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-stateless-function.d.ts","sourceRoot":"","sources":["prefer-stateless-function.js"],"names":[],"mappings":"wBA8BW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/prefer-stateless-function.js

@@ -0,0 +1,397 @@
+/**
+ * @fileoverview Enforce stateless components to be written as a pure function
+ * @author Yannick Croissant
+ * @author Alberto Rodríguez
+ * @copyright 2015 Alberto Rodríguez. All rights reserved.
+ */
+
+'use strict';
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const testReactVersion = require('../util/version').testReactVersion;
+const astUtil = require('../util/ast');
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getScope = eslintUtil.getScope;
+const getText = eslintUtil.getText;
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  componentShouldBePure: 'Component should be written as a pure function',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce stateless components to be written as a pure function',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('prefer-stateless-function'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        ignorePureComponents: {
+          default: false,
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components, utils) => {
+    const configuration = context.options[0] || {};
+    const ignorePureComponents = configuration.ignorePureComponents || false;
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    /**
+     * Checks whether a given array of statements is a single call of `super`.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode[]} body - An array of statements to check.
+     * @returns {boolean} `true` if the body is a single call of `super`.
+     */
+    function isSingleSuperCall(body) {
+      return (
+        body.length === 1
+        && body[0].type === 'ExpressionStatement'
+        && astUtil.isCallExpression(body[0].expression)
+        && body[0].expression.callee.type === 'Super'
+      );
+    }
+
+    /**
+     * Checks whether a given node is a pattern which doesn't have any side effects.
+     * Default parameters and Destructuring parameters can have side effects.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode} node - A pattern node.
+     * @returns {boolean} `true` if the node doesn't have any side effects.
+     */
+    function isSimple(node) {
+      return node.type === 'Identifier' || node.type === 'RestElement';
+    }
+
+    /**
+     * Checks whether a given array of expressions is `...arguments` or not.
+     * `super(...arguments)` passes all arguments through.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode[]} superArgs - An array of expressions to check.
+     * @returns {boolean} `true` if the superArgs is `...arguments`.
+     */
+    function isSpreadArguments(superArgs) {
+      return (
+        superArgs.length === 1
+        && superArgs[0].type === 'SpreadElement'
+        && superArgs[0].argument.type === 'Identifier'
+        && superArgs[0].argument.name === 'arguments'
+      );
+    }
+
+    /**
+     * Checks whether given 2 nodes are identifiers which have the same name or not.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode} ctorParam - A node to check.
+     * @param {ASTNode} superArg - A node to check.
+     * @returns {boolean} `true` if the nodes are identifiers which have the same
+     *      name.
+     */
+    function isValidIdentifierPair(ctorParam, superArg) {
+      return (
+        ctorParam.type === 'Identifier'
+        && superArg.type === 'Identifier'
+        && ctorParam.name === superArg.name
+      );
+    }
+
+    /**
+     * Checks whether given 2 nodes are a rest/spread pair which has the same values.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode} ctorParam - A node to check.
+     * @param {ASTNode} superArg - A node to check.
+     * @returns {boolean} `true` if the nodes are a rest/spread pair which has the
+     *      same values.
+     */
+    function isValidRestSpreadPair(ctorParam, superArg) {
+      return (
+        ctorParam.type === 'RestElement'
+        && superArg.type === 'SpreadElement'
+        && isValidIdentifierPair(ctorParam.argument, superArg.argument)
+      );
+    }
+
+    /**
+     * Checks whether given 2 nodes have the same value or not.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode} ctorParam - A node to check.
+     * @param {ASTNode} superArg - A node to check.
+     * @returns {boolean} `true` if the nodes have the same value or not.
+     */
+    function isValidPair(ctorParam, superArg) {
+      return (
+        isValidIdentifierPair(ctorParam, superArg)
+        || isValidRestSpreadPair(ctorParam, superArg)
+      );
+    }
+
+    /**
+     * Checks whether the parameters of a constructor and the arguments of `super()`
+     * have the same values or not.
+     * @see eslint no-useless-constructor rule
+     * @param {ASTNode[]} ctorParams - The parameters of a constructor to check.
+     * @param {ASTNode} superArgs - The arguments of `super()` to check.
+     * @returns {boolean} `true` if those have the same values.
+     */
+    function isPassingThrough(ctorParams, superArgs) {
+      if (ctorParams.length !== superArgs.length) {
+        return false;
+      }
+
+      for (let i = 0; i < ctorParams.length; ++i) {
+        if (!isValidPair(ctorParams[i], superArgs[i])) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /**
+     * Checks whether the constructor body is a redundant super call.
+     * @see eslint no-useless-constructor rule
+     * @param {Array} body - constructor body content.
+     * @param {Array} ctorParams - The params to check against super call.
+     * @returns {boolean} true if the constructor body is redundant
+     */
+    function isRedundantSuperCall(body, ctorParams) {
+      return (
+        isSingleSuperCall(body)
+        && ctorParams.every(isSimple)
+        && (
+          isSpreadArguments(body[0].expression.arguments)
+          || isPassingThrough(ctorParams, body[0].expression.arguments)
+        )
+      );
+    }
+
+    /**
+     * Check if a given AST node have any other properties the ones available in stateless components
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {boolean} True if the node has at least one other property, false if not.
+     */
+    function hasOtherProperties(node) {
+      const properties = astUtil.getComponentProperties(node);
+      return properties.some((property) => {
+        const name = astUtil.getPropertyName(property);
+        const isDisplayName = name === 'displayName';
+        const isPropTypes = name === 'propTypes' || ((name === 'props') && property.typeAnnotation);
+        const contextTypes = name === 'contextTypes';
+        const defaultProps = name === 'defaultProps';
+        const isUselessConstructor = property.kind === 'constructor'
+          && !!property.value.body
+          && isRedundantSuperCall(property.value.body.body, property.value.params);
+        const isRender = name === 'render';
+        return !isDisplayName && !isPropTypes && !contextTypes && !defaultProps && !isUselessConstructor && !isRender;
+      });
+    }
+
+    /**
+     * Mark component as pure as declared
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markSCUAsDeclared(node) {
+      components.set(node, {
+        hasSCU: true,
+      });
+    }
+
+    /**
+     * Mark childContextTypes as declared
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markChildContextTypesAsDeclared(node) {
+      components.set(node, {
+        hasChildContextTypes: true,
+      });
+    }
+
+    /**
+     * Mark a setState as used
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markThisAsUsed(node) {
+      components.set(node, {
+        useThis: true,
+      });
+    }
+
+    /**
+     * Mark a props or context as used
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markPropsOrContextAsUsed(node) {
+      components.set(node, {
+        usePropsOrContext: true,
+      });
+    }
+
+    /**
+     * Mark a ref as used
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markRefAsUsed(node) {
+      components.set(node, {
+        useRef: true,
+      });
+    }
+
+    /**
+     * Mark return as invalid
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markReturnAsInvalid(node) {
+      components.set(node, {
+        invalidReturn: true,
+      });
+    }
+
+    /**
+     * Mark a ClassDeclaration as having used decorators
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markDecoratorsAsUsed(node) {
+      components.set(node, {
+        useDecorators: true,
+      });
+    }
+
+    function visitClass(node) {
+      if (ignorePureComponents && componentUtil.isPureComponent(node, context)) {
+        markSCUAsDeclared(node);
+      }
+
+      if (node.decorators && node.decorators.length) {
+        markDecoratorsAsUsed(node);
+      }
+    }
+
+    return {
+      ClassDeclaration: visitClass,
+      ClassExpression: visitClass,
+
+      // Mark `this` destructuring as a usage of `this`
+      VariableDeclarator(node) {
+        // Ignore destructuring on other than `this`
+        if (!node.id || node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'ThisExpression') {
+          return;
+        }
+        // Ignore `props` and `context`
+        const useThis = node.id.properties.some((property) => {
+          const name = astUtil.getPropertyName(property);
+          return name !== 'props' && name !== 'context';
+        });
+        if (!useThis) {
+          markPropsOrContextAsUsed(node);
+          return;
+        }
+        markThisAsUsed(node);
+      },
+
+      // Mark `this` usage
+      MemberExpression(node) {
+        if (node.object.type !== 'ThisExpression') {
+          if (node.property && node.property.name === 'childContextTypes') {
+            const component = utils.getRelatedComponent(node);
+            if (!component) {
+              return;
+            }
+            markChildContextTypesAsDeclared(component.node);
+          }
+          return;
+        // Ignore calls to `this.props` and `this.context`
+        }
+        if (
+          (node.property.name || node.property.value) === 'props'
+          || (node.property.name || node.property.value) === 'context'
+        ) {
+          markPropsOrContextAsUsed(node);
+          return;
+        }
+        markThisAsUsed(node);
+      },
+
+      // Mark `ref` usage
+      JSXAttribute(node) {
+        const name = getText(context, node.name);
+        if (name !== 'ref') {
+          return;
+        }
+        markRefAsUsed(node);
+      },
+
+      // Mark `render` that do not return some JSX
+      ReturnStatement(node) {
+        let blockNode;
+        let scope = getScope(context, node);
+        while (scope) {
+          blockNode = scope.block && scope.block.parent;
+          if (blockNode && (blockNode.type === 'MethodDefinition' || blockNode.type === 'Property')) {
+            break;
+          }
+          scope = scope.upper;
+        }
+        const isRender = blockNode
+          && blockNode.key
+          && blockNode.key.name === 'render';
+        const allowNull = testReactVersion(context, '>= 15.0.0'); // Stateless components can return null since React 15
+        const isReturningJSX = utils.isReturningJSX(node, !allowNull);
+        const isReturningNull = node.argument && (node.argument.value === null || node.argument.value === false);
+        if (
+          !isRender
+          || (allowNull && (isReturningJSX || isReturningNull))
+          || (!allowNull && isReturningJSX)
+        ) {
+          return;
+        }
+        markReturnAsInvalid(node);
+      },
+
+      'Program:exit'() {
+        const list = components.list();
+        values(list)
+          .filter((component) => (
+            !hasOtherProperties(component.node)
+            && !component.useThis
+            && !component.useRef
+            && !component.invalidReturn
+            && !component.hasChildContextTypes
+            && !component.useDecorators
+            && !component.hasSCU
+            && (
+              componentUtil.isES5Component(component.node, context)
+              || componentUtil.isES6Component(component.node, context)
+            )
+          ))
+          .forEach((component) => {
+            report(context, messages.componentShouldBePure, 'componentShouldBePure', {
+              node: component.node,
+            });
+          });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/prop-types.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=prop-types.d.ts.map

node_modules/eslint-plugin-react/lib/rules/prop-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-types.d.ts","sourceRoot":"","sources":["prop-types.js"],"names":[],"mappings":"wBAwBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/prop-types.js

@@ -0,0 +1,225 @@
+/**
+ * @fileoverview Prevent missing props validation in a React component definition
+ * @author Yannick Croissant
+ */
+
+'use strict';
+
+// As for exceptions for props.children or props.className (and alike) look at
+// https://github.com/jsx-eslint/eslint-plugin-react/issues/7
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  missingPropType: '\'{{name}}\' is missing in props validation',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow missing props validation in a React component definition',
+      category: 'Best Practices',
+      recommended: true,
+      url: docsUrl('prop-types'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        customValidators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+        skipUndeclared: {
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const ignored = configuration.ignore || [];
+    const skipUndeclared = configuration.skipUndeclared || false;
+
+    /**
+     * Checks if the prop is ignored
+     * @param {string} name Name of the prop to check.
+     * @returns {boolean} True if the prop is ignored, false if not.
+     */
+    function isIgnored(name) {
+      return ignored.indexOf(name) !== -1;
+    }
+
+    /**
+     * Checks if the component must be validated
+     * @param {Object} component The component to process
+     * @returns {boolean} True if the component must be validated, false if not.
+     */
+    function mustBeValidated(component) {
+      const isSkippedByConfig = skipUndeclared && typeof component.declaredPropTypes === 'undefined';
+      return !!(
+        component
+        && component.usedPropTypes
+        && !component.ignorePropsValidation
+        && !isSkippedByConfig
+      );
+    }
+
+    /**
+     * Internal: Checks if the prop is declared
+     * @param {Object} declaredPropTypes Description of propTypes declared in the current component
+     * @param {string[]} keyList Dot separated name of the prop to check.
+     * @returns {boolean} True if the prop is declared, false if not.
+     */
+    function internalIsDeclaredInComponent(declaredPropTypes, keyList) {
+      for (let i = 0, j = keyList.length; i < j; i++) {
+        const key = keyList[i];
+        const propType = (
+          declaredPropTypes && (
+            // Check if this key is declared
+            (declaredPropTypes[key] // If not, check if this type accepts any key
+            || declaredPropTypes.__ANY_KEY__) // eslint-disable-line no-underscore-dangle
+          )
+        );
+
+        if (!propType) {
+          // If it's a computed property, we can't make any further analysis, but is valid
+          return key === '__COMPUTED_PROP__';
+        }
+        if (typeof propType === 'object' && !propType.type) {
+          return true;
+        }
+        // Consider every children as declared
+        if (propType.children === true || propType.containsUnresolvedSpread || propType.containsIndexers) {
+          return true;
+        }
+        if (propType.acceptedProperties) {
+          return key in propType.acceptedProperties;
+        }
+        if (propType.type === 'union') {
+          // If we fall in this case, we know there is at least one complex type in the union
+          if (i + 1 >= j) {
+            // this is the last key, accept everything
+            return true;
+          }
+          // non trivial, check all of them
+          const unionTypes = propType.children;
+          const unionPropType = {};
+          for (let k = 0, z = unionTypes.length; k < z; k++) {
+            unionPropType[key] = unionTypes[k];
+            const isValid = internalIsDeclaredInComponent(
+              unionPropType,
+              keyList.slice(i)
+            );
+            if (isValid) {
+              return true;
+            }
+          }
+
+          // every possible union were invalid
+          return false;
+        }
+        declaredPropTypes = propType.children;
+      }
+      return true;
+    }
+
+    /**
+     * Checks if the prop is declared
+     * @param {ASTNode} node The AST node being checked.
+     * @param {string[]} names List of names of the prop to check.
+     * @returns {boolean} True if the prop is declared, false if not.
+     */
+    function isDeclaredInComponent(node, names) {
+      while (node) {
+        const component = components.get(node);
+
+        const isDeclared = component && component.confidence >= 2
+          && internalIsDeclaredInComponent(component.declaredPropTypes || {}, names);
+
+        if (isDeclared) {
+          return true;
+        }
+
+        node = node.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Reports undeclared proptypes for a given component
+     * @param {Object} component The component to process
+     */
+    function reportUndeclaredPropTypes(component) {
+      const undeclareds = component.usedPropTypes.filter((propType) => (
+        propType.node
+        && !isIgnored(propType.allNames[0])
+        && !isDeclaredInComponent(component.node, propType.allNames)
+      ));
+      undeclareds.forEach((propType) => {
+        report(context, messages.missingPropType, 'missingPropType', {
+          node: propType.node,
+          data: {
+            name: propType.allNames.join('.').replace(/\.__COMPUTED_PROP__/g, '[]'),
+          },
+        });
+      });
+    }
+
+    /**
+     * @param {Object} component The current component to process
+     * @param {Array} list The all components to process
+     * @returns {boolean} True if the component is nested False if not.
+     */
+    function checkNestedComponent(component, list) {
+      const componentIsMemo = component.node.callee && component.node.callee.name === 'memo';
+      const argumentIsForwardRef = component.node.arguments && component.node.arguments[0].callee && component.node.arguments[0].callee.name === 'forwardRef';
+      if (componentIsMemo && argumentIsForwardRef) {
+        const forwardComponent = list.find(
+          (innerComponent) => (
+            innerComponent.node.range[0] === component.node.arguments[0].range[0]
+            && innerComponent.node.range[0] === component.node.arguments[0].range[0]
+          ));
+
+        const isValidated = mustBeValidated(forwardComponent);
+        const isIgnorePropsValidation = forwardComponent.ignorePropsValidation;
+
+        return isIgnorePropsValidation || isValidated;
+      }
+    }
+
+    return {
+      'Program:exit'() {
+        const list = components.list();
+        // Report undeclared proptypes for all classes
+        values(list)
+          .filter((component) => mustBeValidated(component))
+          .forEach((component) => {
+            if (checkNestedComponent(component, values(list))) return;
+            reportUndeclaredPropTypes(component);
+          });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/react-in-jsx-scope.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=react-in-jsx-scope.d.ts.map

node_modules/eslint-plugin-react/lib/rules/react-in-jsx-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-in-jsx-scope.d.ts","sourceRoot":"","sources":["react-in-jsx-scope.js"],"names":[],"mappings":"wBAoBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/react-in-jsx-scope.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Prevent missing React when using JSX
+ * @author Glen Mailer
+ */
+
+'use strict';
+
+const variableUtil = require('../util/variable');
+const pragmaUtil = require('../util/pragma');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// -----------------------------------------------------------------------------
+// Rule Definition
+// -----------------------------------------------------------------------------
+
+const messages = {
+  notInScope: '\'{{name}}\' must be in scope when using JSX',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow missing React when using JSX',
+      category: 'Possible Errors',
+      recommended: true,
+      url: docsUrl('react-in-jsx-scope'),
+    },
+
+    messages,
+
+    schema: [],
+  },
+
+  create(context) {
+    const pragma = pragmaUtil.getFromContext(context);
+
+    function checkIfReactIsInScope(node) {
+      if (variableUtil.getVariableFromContext(context, node, pragma)) {
+        return;
+      }
+      report(context, messages.notInScope, 'notInScope', {
+        node,
+        data: {
+          name: pragma,
+        },
+      });
+    }
+
+    return {
+      JSXOpeningElement: checkIfReactIsInScope,
+      JSXOpeningFragment: checkIfReactIsInScope,
+    };
+  },
+};

node_modules/eslint-plugin-react/lib/rules/require-default-props.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=require-default-props.d.ts.map

node_modules/eslint-plugin-react/lib/rules/require-default-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-default-props.d.ts","sourceRoot":"","sources":["require-default-props.js"],"names":[],"mappings":"wBAiCW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/require-default-props.js

@@ -0,0 +1,209 @@
+/**
+ * @fileOverview Enforce a defaultProps definition for every prop that is not a required prop.
+ * @author Vitor Balocco
+ */
+
+'use strict';
+
+const entries = require('object.entries');
+const values = require('object.values');
+const Components = require('../util/Components');
+const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  noDefaultWithRequired: 'propType "{{name}}" is required and should not have a defaultProps declaration.',
+  shouldHaveDefault: 'propType "{{name}}" is not required, but has no corresponding defaultProps declaration.',
+  noDefaultPropsWithFunction: 'Don’t use defaultProps with function components.',
+  shouldAssignObjectDefault: 'propType "{{name}}" is not required, but has no corresponding default argument value.',
+  destructureInSignature: 'Must destructure props in the function signature to initialize an optional prop.',
+};
+
+function isPropWithNoDefaulVal(prop) {
+  if (prop.type === 'RestElement' || prop.type === 'ExperimentalRestProperty') {
+    return false;
+  }
+  return prop.value.type !== 'AssignmentPattern';
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce a defaultProps definition for every prop that is not a required prop',
+      category: 'Best Practices',
+      url: docsUrl('require-default-props'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        forbidDefaultForRequired: {
+          type: 'boolean',
+        },
+        classes: {
+          enum: ['defaultProps', 'ignore'],
+        },
+        functions: {
+          enum: ['defaultArguments', 'defaultProps', 'ignore'],
+        },
+        /**
+         * @deprecated
+         */
+        ignoreFunctionalComponents: {
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const forbidDefaultForRequired = configuration.forbidDefaultForRequired || false;
+    const classes = configuration.classes || 'defaultProps';
+    /**
+     * @todo
+     * - Remove ignoreFunctionalComponents
+     * - Change default to 'defaultArguments'
+     */
+    const functions = configuration.ignoreFunctionalComponents
+      ? 'ignore'
+      : configuration.functions || 'defaultProps';
+
+    /**
+     * Reports all propTypes passed in that don't have a defaultProps counterpart.
+     * @param  {Object[]} propTypes    List of propTypes to check.
+     * @param  {Object}   defaultProps Object of defaultProps to check. Keys are the props names.
+     * @return {void}
+     */
+    function reportPropTypesWithoutDefault(propTypes, defaultProps) {
+      entries(propTypes).forEach((propType) => {
+        const propName = propType[0];
+        const prop = propType[1];
+
+        if (!prop.node) {
+          return;
+        }
+        if (prop.isRequired) {
+          if (forbidDefaultForRequired && defaultProps[propName]) {
+            report(context, messages.noDefaultWithRequired, 'noDefaultWithRequired', {
+              node: prop.node,
+              data: { name: propName },
+            });
+          }
+          return;
+        }
+
+        if (defaultProps[propName]) {
+          return;
+        }
+
+        report(context, messages.shouldHaveDefault, 'shouldHaveDefault', {
+          node: prop.node,
+          data: { name: propName },
+        });
+      });
+    }
+
+    /**
+     * If functions option is 'defaultArguments', reports defaultProps is used and all params that doesn't initialized.
+     * @param {Object} componentNode Node of component.
+     * @param {Object[]} declaredPropTypes List of propTypes to check `isRequired`.
+     * @param {Object} defaultProps Object of defaultProps to check used.
+     */
+    function reportFunctionComponent(componentNode, declaredPropTypes, defaultProps) {
+      if (defaultProps) {
+        report(context, messages.noDefaultPropsWithFunction, 'noDefaultPropsWithFunction', {
+          node: componentNode,
+        });
+      }
+
+      const props = componentNode.params[0];
+      const propTypes = declaredPropTypes;
+
+      if (!props) {
+        return;
+      }
+
+      if (props.type === 'Identifier') {
+        const hasOptionalProp = values(propTypes).some((propType) => !propType.isRequired);
+        if (hasOptionalProp) {
+          report(context, messages.destructureInSignature, 'destructureInSignature', {
+            node: props,
+          });
+        }
+      } else if (props.type === 'ObjectPattern') {
+        // Filter required props with default value and report error
+        props.properties.filter((prop) => {
+          const propName = prop && prop.key && prop.key.name;
+          const isPropRequired = propTypes[propName] && propTypes[propName].isRequired;
+          return propTypes[propName] && isPropRequired && !isPropWithNoDefaulVal(prop);
+        }).forEach((prop) => {
+          report(context, messages.noDefaultWithRequired, 'noDefaultWithRequired', {
+            node: prop,
+            data: { name: prop.key.name },
+          });
+        });
+
+        // Filter non required props with no default value and report error
+        props.properties.filter((prop) => {
+          const propName = prop && prop.key && prop.key.name;
+          const isPropRequired = propTypes[propName] && propTypes[propName].isRequired;
+          return propTypes[propName] && !isPropRequired && isPropWithNoDefaulVal(prop);
+        }).forEach((prop) => {
+          report(context, messages.shouldAssignObjectDefault, 'shouldAssignObjectDefault', {
+            node: prop,
+            data: { name: prop.key.name },
+          });
+        });
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+
+    return {
+      'Program:exit'() {
+        const list = components.list();
+
+        values(list).filter((component) => {
+          if (functions === 'ignore' && astUtil.isFunctionLike(component.node)) {
+            return false;
+          }
+          if (classes === 'ignore' && astUtil.isClass(component.node)) {
+            return false;
+          }
+
+          // If this defaultProps is "unresolved", then we should ignore this component and not report
+          // any errors for it, to avoid false-positives with e.g. external defaultProps declarations or spread operators.
+          if (component.defaultProps === 'unresolved') {
+            return false;
+          }
+          return component.declaredPropTypes !== undefined;
+        }).forEach((component) => {
+          if (functions === 'defaultArguments' && astUtil.isFunctionLike(component.node)) {
+            reportFunctionComponent(
+              component.node,
+              component.declaredPropTypes,
+              component.defaultProps
+            );
+          } else {
+            reportPropTypesWithoutDefault(
+              component.declaredPropTypes,
+              component.defaultProps || {}
+            );
+          }
+        });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/require-optimization.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=require-optimization.d.ts.map

node_modules/eslint-plugin-react/lib/rules/require-optimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-optimization.d.ts","sourceRoot":"","sources":["require-optimization.js"],"names":[],"mappings":"wBAmBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/require-optimization.js

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Enforce React components to have a shouldComponentUpdate method
+ * @author Evgueni Naverniouk
+ */
+
+'use strict';
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
+
+const messages = {
+  noShouldComponentUpdate: 'Component is not optimized. Please add a shouldComponentUpdate method.',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce React components to have a shouldComponentUpdate method',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('require-optimization'),
+    },
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        allowDecorators: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create: Components.detect((context, components) => {
+    const configuration = context.options[0] || {};
+    const allowDecorators = configuration.allowDecorators || [];
+
+    /**
+     * Checks to see if our component is decorated by PureRenderMixin via reactMixin
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {boolean} True if node is decorated with a PureRenderMixin, false if not.
+     */
+    function hasPureRenderDecorator(node) {
+      if (node.decorators && node.decorators.length) {
+        for (let i = 0, l = node.decorators.length; i < l; i++) {
+          if (
+            node.decorators[i].expression
+            && node.decorators[i].expression.callee
+            && node.decorators[i].expression.callee.object
+            && node.decorators[i].expression.callee.object.name === 'reactMixin'
+            && node.decorators[i].expression.callee.property
+            && node.decorators[i].expression.callee.property.name === 'decorate'
+            && node.decorators[i].expression.arguments
+            && node.decorators[i].expression.arguments.length
+            && node.decorators[i].expression.arguments[0].name === 'PureRenderMixin'
+          ) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Checks to see if our component is custom decorated
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {boolean} True if node is decorated name with a custom decorated, false if not.
+     */
+    function hasCustomDecorator(node) {
+      const allowLength = allowDecorators.length;
+
+      if (allowLength && node.decorators && node.decorators.length) {
+        for (let i = 0; i < allowLength; i++) {
+          for (let j = 0, l = node.decorators.length; j < l; j++) {
+            const expression = node.decorators[j].expression;
+            if (
+              expression
+              && expression.name === allowDecorators[i]
+            ) {
+              return true;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Checks if we are declaring a shouldComponentUpdate method
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {boolean} True if we are declaring a shouldComponentUpdate method, false if not.
+     */
+    function isSCUDeclared(node) {
+      return !!node && node.name === 'shouldComponentUpdate';
+    }
+
+    /**
+     * Checks if we are declaring a PureRenderMixin mixin
+     * @param {ASTNode} node The AST node being checked.
+     * @returns {boolean} True if we are declaring a PureRenderMixin method, false if not.
+     */
+    function isPureRenderDeclared(node) {
+      let hasPR = false;
+      if (node.value && node.value.elements) {
+        for (let i = 0, l = node.value.elements.length; i < l; i++) {
+          if (node.value.elements[i] && node.value.elements[i].name === 'PureRenderMixin') {
+            hasPR = true;
+            break;
+          }
+        }
+      }
+
+      return (
+        !!node
+        && node.key.name === 'mixins'
+        && hasPR
+      );
+    }
+
+    /**
+     * Mark shouldComponentUpdate as declared
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markSCUAsDeclared(node) {
+      components.set(node, {
+        hasSCU: true,
+      });
+    }
+
+    /**
+     * Reports missing optimization for a given component
+     * @param {Object} component The component to process
+     */
+    function reportMissingOptimization(component) {
+      report(context, messages.noShouldComponentUpdate, 'noShouldComponentUpdate', {
+        node: component.node,
+      });
+    }
+
+    /**
+     * Checks if we are declaring function in class
+     * @param {ASTNode} node
+     * @returns {boolean} True if we are declaring function in class, false if not.
+     */
+    function isFunctionInClass(node) {
+      let blockNode;
+      let scope = getScope(context, node);
+      while (scope) {
+        blockNode = scope.block;
+        if (blockNode && blockNode.type === 'ClassDeclaration') {
+          return true;
+        }
+        scope = scope.upper;
+      }
+
+      return false;
+    }
+
+    return {
+      ArrowFunctionExpression(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass(node)) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      ClassDeclaration(node) {
+        if (!(
+          hasPureRenderDecorator(node)
+          || hasCustomDecorator(node)
+          || componentUtil.isPureComponent(node, context)
+        )) {
+          return;
+        }
+        markSCUAsDeclared(node);
+      },
+
+      FunctionDeclaration(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass(node)) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      FunctionExpression(node) {
+        // Skip if the function is declared in the class
+        if (isFunctionInClass(node)) {
+          return;
+        }
+        // Stateless Functional Components cannot be optimized (yet)
+        markSCUAsDeclared(node);
+      },
+
+      MethodDefinition(node) {
+        if (!isSCUDeclared(node.key)) {
+          return;
+        }
+        markSCUAsDeclared(node);
+      },
+
+      ObjectExpression(node) {
+        // Search for the shouldComponentUpdate declaration
+        const found = node.properties.some((property) => (
+          property.key
+          && (isSCUDeclared(property.key) || isPureRenderDeclared(property))
+        ));
+        if (found) {
+          markSCUAsDeclared(node);
+        }
+      },
+
+      'Program:exit'() {
+        // Report missing shouldComponentUpdate for all components
+        values(components.list())
+          .filter((component) => !component.hasSCU)
+          .forEach((component) => {
+            reportMissingOptimization(component);
+          });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/require-render-return.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=require-render-return.d.ts.map

node_modules/eslint-plugin-react/lib/rules/require-render-return.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-render-return.d.ts","sourceRoot":"","sources":["require-render-return.js"],"names":[],"mappings":"wBAwBW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/require-render-return.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview Enforce ES5 or ES6 class for returning value in render function.
+ * @author Mark Orel
+ */
+
+'use strict';
+
+const values = require('object.values');
+
+const Components = require('../util/Components');
+const astUtil = require('../util/ast');
+const componentUtil = require('../util/componentUtil');
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+const getAncestors = require('../util/eslint').getAncestors;
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  noRenderReturn: 'Your render method should have a return statement',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce ES5 or ES6 class for returning value in render function',
+      category: 'Possible Errors',
+      recommended: true,
+      url: docsUrl('require-render-return'),
+    },
+
+    messages,
+
+    schema: [],
+  },
+
+  create: Components.detect((context, components) => {
+    /**
+     * Mark a return statement as present
+     * @param {ASTNode} node The AST node being checked.
+     */
+    function markReturnStatementPresent(node) {
+      components.set(node, {
+        hasReturnStatement: true,
+      });
+    }
+
+    /**
+     * Find render method in a given AST node
+     * @param {ASTNode} node The component to find render method.
+     * @returns {ASTNode} Method node if found, undefined if not.
+     */
+    function findRenderMethod(node) {
+      const properties = astUtil.getComponentProperties(node);
+      return properties
+        .filter((property) => astUtil.getPropertyName(property) === 'render' && property.value)
+        .find((property) => astUtil.isFunctionLikeExpression(property.value));
+    }
+
+    return {
+      ReturnStatement(node) {
+        const ancestors = getAncestors(context, node).reverse();
+        let depth = 0;
+        ancestors.forEach((ancestor) => {
+          if (/Function(Expression|Declaration)$/.test(ancestor.type)) {
+            depth += 1;
+          }
+          if (
+            /(MethodDefinition|Property|ClassProperty|PropertyDefinition)$/.test(ancestor.type)
+            && astUtil.getPropertyName(ancestor) === 'render'
+            && depth <= 1
+          ) {
+            markReturnStatementPresent(node);
+          }
+        });
+      },
+
+      ArrowFunctionExpression(node) {
+        if (node.expression === false || astUtil.getPropertyName(node.parent) !== 'render') {
+          return;
+        }
+        markReturnStatementPresent(node);
+      },
+
+      'Program:exit'() {
+        values(components.list())
+          .filter((component) => (
+            findRenderMethod(component.node)
+            && !component.hasReturnStatement
+            && (
+              componentUtil.isES5Component(component.node, context)
+              || componentUtil.isES6Component(component.node, context)
+            )
+          ))
+          .forEach((component) => {
+            report(context, messages.noRenderReturn, 'noRenderReturn', {
+              node: findRenderMethod(component.node),
+            });
+          });
+      },
+    };
+  }),
+};

node_modules/eslint-plugin-react/lib/rules/self-closing-comp.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=self-closing-comp.d.ts.map

node_modules/eslint-plugin-react/lib/rules/self-closing-comp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-closing-comp.d.ts","sourceRoot":"","sources":["self-closing-comp.js"],"names":[],"mappings":"wBA4CW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}

node_modules/eslint-plugin-react/lib/rules/self-closing-comp.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Prevent extra closing tags for components without children
+ * @author Yannick Croissant
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const jsxUtil = require('../util/jsx');
+const report = require('../util/report');
+
+const optionDefaults = { component: true, html: true };
+
+function isComponent(node) {
+  return (
+    node.name
+    && (node.name.type === 'JSXIdentifier' || node.name.type === 'JSXMemberExpression')
+    && !jsxUtil.isDOMComponent(node)
+  );
+}
+
+function childrenIsEmpty(node) {
+  return node.parent.children.length === 0;
+}
+
+function childrenIsMultilineSpaces(node) {
+  const childrens = node.parent.children;
+
+  return (
+    childrens.length === 1
+    && (childrens[0].type === 'Literal' || childrens[0].type === 'JSXText')
+    && childrens[0].value.indexOf('\n') !== -1
+    && childrens[0].value.replace(/(?!\xA0)\s/g, '') === ''
+  );
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  notSelfClosing: 'Empty components are self-closing',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow extra closing tags for components without children',
+      category: 'Stylistic Issues',
+      recommended: false,
+      url: docsUrl('self-closing-comp'),
+    },
+    fixable: 'code',
+
+    messages,
+
+    schema: [{
+      type: 'object',
+      properties: {
+        component: {
+          default: optionDefaults.component,
+          type: 'boolean',
+        },
+        html: {
+          default: optionDefaults.html,
+          type: 'boolean',
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create(context) {
+    function isShouldBeSelfClosed(node) {
+      const configuration = Object.assign({}, optionDefaults, context.options[0]);
+      return (
+        (configuration.component && isComponent(node))
+        || (configuration.html && jsxUtil.isDOMComponent(node))
+      ) && !node.selfClosing && (childrenIsEmpty(node) || childrenIsMultilineSpaces(node));
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        if (!isShouldBeSelfClosed(node)) {
+          return;
+        }
+        report(context, messages.notSelfClosing, 'notSelfClosing', {
+          node,
+          fix(fixer) {
+            // Represents the last character of the JSXOpeningElement, the '>' character
+            const openingElementEnding = node.range[1] - 1;
+            // Represents the last character of the JSXClosingElement, the '>' character
+            const closingElementEnding = node.parent.closingElement.range[1];
+
+            // Replace />.*<\/.*>/ with '/>'
+            const range = [openingElementEnding, closingElementEnding];
+            return fixer.replaceTextRange(range, ' />');
+          },
+        });
+      },
+    };
+  },
+};

node_modules/eslint-plugin-react/lib/rules/sort-comp.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import('eslint').Rule.RuleModule;
+export = _exports;
+//# sourceMappingURL=sort-comp.d.ts.map

node_modules/eslint-plugin-react/lib/rules/sort-comp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-comp.d.ts","sourceRoot":"","sources":["sort-comp.js"],"names":[],"mappings":"wBAwFW,OAAO,QAAQ,EAAE,IAAI,CAAC,UAAU"}