@eslint-react/jsx 0.8.9-beta.2 → 0.8.9

package/node_modules/@eslint-react/ast/dist/index.mjs

@@ -1,852 +0,0 @@
-import { Data, O as O$1, uniqueBy, MutRef, F } from '@eslint-react/tools';
-import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
-import { type, isNil } from 'rambda';
-import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { ASTUtils } from '@typescript-eslint/utils';
-import { toLowerCase, delimiterCase, replace } from 'string-ts';
-import * as eslintUtils from '@eslint-community/eslint-utils';
-
-/**
- * Tests if a value is a `function`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isFunction } from 'effect/Predicate'
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- * assert.deepStrictEqual(isFunction("function"), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction$2 = input => typeof input === "function";
-
-/**
- * @since 2.0.0
- */
-/**
- * Tests if a value is a `string`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isString } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isString("a"), true)
- *
- * assert.deepStrictEqual(isString(1), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isString = input => typeof input === "string";
-/**
- * Tests if a value is a `function`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isFunction } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- *
- * assert.deepStrictEqual(isFunction("function"), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction$1 = isFunction$2;
-const isRecordOrArray = input => typeof input === "object" && input !== null;
-/**
- * Tests if a value is an `object`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isObject } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isObject({}), true)
- * assert.deepStrictEqual(isObject([]), true)
- *
- * assert.deepStrictEqual(isObject(null), false)
- * assert.deepStrictEqual(isObject(undefined), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isObject = input => isRecordOrArray(input) || isFunction$1(input);
-/**
- * A guard that succeeds when the input is `null` or `undefined`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isNullable } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isNullable(null), true)
- * assert.deepStrictEqual(isNullable(undefined), true)
- *
- * assert.deepStrictEqual(isNullable({}), false)
- * assert.deepStrictEqual(isNullable([]), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isNullable = input => input === null || input === undefined;
-
-const t=Symbol.for("@ts-pattern/matcher"),e=Symbol.for("@ts-pattern/isVariadic"),n="@ts-pattern/anonymous-select-key",r=t=>Boolean(t&&"object"==typeof t),i=e=>e&&!!e[t],s=(n,o,c)=>{if(i(n)){const e=n[t](),{matched:r,selections:i}=e.match(o);return r&&i&&Object.keys(i).forEach(t=>c(t,i[t])),r}if(r(n)){if(!r(o))return !1;if(Array.isArray(n)){if(!Array.isArray(o))return !1;let t=[],r=[],a=[];for(const s of n.keys()){const o=n[s];i(o)&&o[e]?a.push(o):a.length?r.push(o):t.push(o);}if(a.length){if(a.length>1)throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");if(o.length<t.length+r.length)return !1;const e=o.slice(0,t.length),n=0===r.length?[]:o.slice(-r.length),i=o.slice(t.length,0===r.length?Infinity:-r.length);return t.every((t,n)=>s(t,e[n],c))&&r.every((t,e)=>s(t,n[e],c))&&(0===a.length||s(a[0],i,c))}return n.length===o.length&&n.every((t,e)=>s(t,o[e],c))}return Object.keys(n).every(e=>{const r=n[e];return (e in o||i(a=r)&&"optional"===a[t]().matcherType)&&s(r,o[e],c);var a;})}return Object.is(o,n)},o=e=>{var n,s,a;return r(e)?i(e)?null!=(n=null==(s=(a=e[t]()).getSelectionKeys)?void 0:s.call(a))?n:[]:Array.isArray(e)?c(e,o):c(Object.values(e),o):[]},c=(t,e)=>t.reduce((t,n)=>t.concat(e(n)),[]);function a(...t){if(1===t.length){const[e]=t;return t=>s(e,t,()=>{})}if(2===t.length){const[e,n]=t;return s(e,n,()=>{})}throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`)}function u(t){return Object.assign(t,{optional:()=>l(t),and:e=>m(t,e),or:e=>y(t,e),select:e=>void 0===e?p(t):p(e,t)})}function h(t){return Object.assign((t=>Object.assign(t,{*[Symbol.iterator](){yield Object.assign(t,{[e]:!0});}}))(t),{optional:()=>h(l(t)),select:e=>h(void 0===e?p(t):p(e,t))})}function l(e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return void 0===t?(o(e).forEach(t=>r(t,void 0)),{matched:!0,selections:n}):{matched:s(e,t,r),selections:n}},getSelectionKeys:()=>o(e),matcherType:"optional"})})}const f=(t,e)=>{for(const n of t)if(!e(n))return !1;return !0},g=(t,e)=>{for(const[n,r]of t.entries())if(!e(r,n))return !1;return !0};function m(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return {matched:e.every(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"and"})})}function y(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return c(e,o).forEach(t=>r(t,void 0)),{matched:e.some(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"or"})})}function d(e){return {[t]:()=>({match:t=>({matched:Boolean(e(t))})})}}function p(...e){const r="string"==typeof e[0]?e[0]:void 0,i=2===e.length?e[1]:"string"==typeof e[0]?void 0:e[0];return u({[t]:()=>({match:t=>{let e={[null!=r?r:n]:t};return {matched:void 0===i||s(i,t,(t,n)=>{e[t]=n;}),selections:e}},getSelectionKeys:()=>[null!=r?r:n].concat(void 0===i?[]:o(i))})})}function v(t){return "number"==typeof t}function b(t){return "string"==typeof t}function w(t){return "bigint"==typeof t}const S=u(d(function(t){return !0})),O=S,j=t=>Object.assign(u(t),{startsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.startsWith(n)))));var n;},endsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.endsWith(n)))));var n;},minLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length>=t))(e))),maxLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length<=t))(e))),includes:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.includes(n)))));var n;},regex:e=>{return j(m(t,(n=e,d(t=>b(t)&&Boolean(t.match(n))))));var n;}}),E=j(d(b)),K=t=>Object.assign(u(t),{between:(e,n)=>K(m(t,((t,e)=>d(n=>v(n)&&t<=n&&e>=n))(e,n))),lt:e=>K(m(t,(t=>d(e=>v(e)&&e<t))(e))),gt:e=>K(m(t,(t=>d(e=>v(e)&&e>t))(e))),lte:e=>K(m(t,(t=>d(e=>v(e)&&e<=t))(e))),gte:e=>K(m(t,(t=>d(e=>v(e)&&e>=t))(e))),int:()=>K(m(t,d(t=>v(t)&&Number.isInteger(t)))),finite:()=>K(m(t,d(t=>v(t)&&Number.isFinite(t)))),positive:()=>K(m(t,d(t=>v(t)&&t>0))),negative:()=>K(m(t,d(t=>v(t)&&t<0)))}),A=K(d(v)),x=t=>Object.assign(u(t),{between:(e,n)=>x(m(t,((t,e)=>d(n=>w(n)&&t<=n&&e>=n))(e,n))),lt:e=>x(m(t,(t=>d(e=>w(e)&&e<t))(e))),gt:e=>x(m(t,(t=>d(e=>w(e)&&e>t))(e))),lte:e=>x(m(t,(t=>d(e=>w(e)&&e<=t))(e))),gte:e=>x(m(t,(t=>d(e=>w(e)&&e>=t))(e))),positive:()=>x(m(t,d(t=>w(t)&&t>0))),negative:()=>x(m(t,d(t=>w(t)&&t<0)))}),P=x(d(w)),T=u(d(function(t){return "boolean"==typeof t})),k=u(d(function(t){return "symbol"==typeof t})),B=u(d(function(t){return null==t}));var _={__proto__:null,matcher:t,optional:l,array:function(...e){return h({[t]:()=>({match:t=>{if(!Array.isArray(t))return {matched:!1};if(0===e.length)return {matched:!0};const n=e[0];let r={};if(0===t.length)return o(n).forEach(t=>{r[t]=[];}),{matched:!0,selections:r};const i=(t,e)=>{r[t]=(r[t]||[]).concat([e]);};return {matched:t.every(t=>s(n,t,i)),selections:r}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},set:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Set))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};if(0===e.length)return {matched:!0};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);},i=e[0];return {matched:f(t,t=>s(i,t,r)),selections:n}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},map:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Map))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);};if(0===e.length)return {matched:!0};var i;if(1===e.length)throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null==(i=e[0])?void 0:i.toString()}`);const[o,c]=e;return {matched:g(t,(t,e)=>{const n=s(o,e,r),i=s(c,t,r);return n&&i}),selections:n}},getSelectionKeys:()=>0===e.length?[]:[...o(e[0]),...o(e[1])]})})},intersection:m,union:y,not:function(e){return u({[t]:()=>({match:t=>({matched:!s(e,t,()=>{})}),getSelectionKeys:()=>[],matcherType:"not"})})},when:d,select:p,any:S,_:O,string:E,number:A,bigint:P,boolean:T,symbol:k,nullish:B,instanceOf:function(t){return u(d(function(t){return e=>e instanceof t}(t)))},shape:function(t){return u(d(a(t)))}};const W={matched:!1,value:void 0};function N(t){return new $(t,W)}class ${constructor(t,e){this.input=void 0,this.state=void 0,this.input=t,this.state=e;}with(...t){if(this.state.matched)return this;const e=t[t.length-1],r=[t[0]];let i;3===t.length&&"function"==typeof t[1]?(r.push(t[0]),i=t[1]):t.length>2&&r.push(...t.slice(1,t.length-1));let o=!1,c={};const a=(t,e)=>{o=!0,c[t]=e;},u=!r.some(t=>s(t,this.input,a))||i&&!Boolean(i(this.input))?W:{matched:!0,value:e(o?n in c?c[n]:c:this.input,this.input)};return new $(this.input,u)}when(t,e){if(this.state.matched)return this;const n=Boolean(t(this.input));return new $(this.input,n?{matched:!0,value:e(this.input,this.input)}:W)}otherwise(t){return this.state.matched?this.state.value:t(this.input)}exhaustive(){return this.run()}run(){if(this.state.matched)return this.state.value;let t;try{t=JSON.stringify(this.input);}catch(e){t=this.input;}throw new Error(`Pattern matching error: no pattern matches value ${t}`)}returnType(){return this}}
-
-const NodeType = AST_NODE_TYPES;
-const is = ASTUtils.isNodeOfType;
-const isOneOf = ASTUtils.isNodeOfTypes;
-const isFunction = isOneOf([
-    NodeType.ArrowFunctionExpression,
-    NodeType.FunctionDeclaration,
-    NodeType.FunctionExpression
-]);
-const isFunctionType = isOneOf([
-    NodeType.ArrowFunctionExpression,
-    NodeType.FunctionDeclaration,
-    NodeType.FunctionExpression,
-    NodeType.TSCallSignatureDeclaration,
-    NodeType.TSConstructSignatureDeclaration,
-    NodeType.TSDeclareFunction,
-    NodeType.TSEmptyBodyFunctionExpression,
-    NodeType.TSFunctionType,
-    NodeType.TSMethodSignature
-]);
-const isClass = isOneOf([
-    NodeType.ClassDeclaration,
-    NodeType.ClassExpression
-]);
-const isLoop = isOneOf([
-    NodeType.DoWhileStatement,
-    NodeType.ForInStatement,
-    NodeType.ForOfStatement,
-    NodeType.ForStatement,
-    NodeType.WhileStatement
-]);
-const isArrayTupleType = isOneOf([
-    NodeType.TSArrayType,
-    NodeType.TSTupleType
-]);
-const isProperty = isOneOf([
-    NodeType.PropertyDefinition,
-    NodeType.TSIndexSignature,
-    NodeType.TSParameterProperty,
-    NodeType.TSPropertySignature
-]);
-const isJSXElement = is(NodeType.JSXElement);
-const isJSXFragment = is(NodeType.JSXFragment);
-const isJSX = isOneOf([
-    NodeType.JSXAttribute,
-    NodeType.JSXSpreadChild,
-    NodeType.JSXClosingElement,
-    NodeType.JSXClosingFragment,
-    NodeType.JSXElement,
-    NodeType.JSXEmptyExpression,
-    NodeType.JSXExpressionContainer,
-    NodeType.JSXFragment,
-    NodeType.JSXIdentifier,
-    NodeType.JSXMemberExpression,
-    NodeType.JSXNamespacedName,
-    NodeType.JSXOpeningElement,
-    NodeType.JSXOpeningFragment,
-    NodeType.JSXSpreadAttribute,
-    NodeType.JSXSpreadChild,
-    NodeType.JSXText
-]);
-const isJSXTagNameExpression = isOneOf([
-    NodeType.JSXIdentifier,
-    NodeType.JSXMemberExpression,
-    NodeType.JSXNamespacedName
-]);
-const isDestructuringPattern = isOneOf([
-    NodeType.ArrayPattern,
-    NodeType.AssignmentPattern,
-    NodeType.ObjectPattern,
-    NodeType.RestElement
-]);
-const isTypeDeclaration = isOneOf([
-    NodeType.TSInterfaceDeclaration,
-    NodeType.TSTypeAliasDeclaration
-]);
-const isLeftHandSideExpression = isOneOf([
-    NodeType.ArrayExpression,
-    NodeType.ArrayPattern,
-    NodeType.ArrowFunctionExpression,
-    NodeType.CallExpression,
-    NodeType.ClassExpression,
-    NodeType.FunctionExpression,
-    NodeType.Identifier,
-    NodeType.JSXElement,
-    NodeType.JSXFragment,
-    NodeType.Literal,
-    NodeType.TemplateLiteral,
-    NodeType.MemberExpression,
-    NodeType.MetaProperty,
-    NodeType.ObjectExpression,
-    NodeType.ObjectPattern,
-    NodeType.SequenceExpression,
-    NodeType.Super,
-    NodeType.TaggedTemplateExpression,
-    NodeType.ThisExpression
-]);
-const isLeftHandSideExpressionType = isOneOf([
-    NodeType.ArrayExpression,
-    NodeType.ArrayPattern,
-    NodeType.ArrowFunctionExpression,
-    NodeType.CallExpression,
-    NodeType.ClassExpression,
-    NodeType.FunctionExpression,
-    NodeType.Identifier,
-    NodeType.JSXElement,
-    NodeType.JSXFragment,
-    NodeType.Literal,
-    NodeType.TemplateLiteral,
-    NodeType.MemberExpression,
-    NodeType.MetaProperty,
-    NodeType.ObjectExpression,
-    NodeType.ObjectPattern,
-    NodeType.SequenceExpression,
-    NodeType.Super,
-    NodeType.TaggedTemplateExpression,
-    NodeType.ThisExpression,
-    NodeType.TSAsExpression,
-    NodeType.TSNonNullExpression,
-    NodeType.TSTypeAssertion
-]);
-
-/**
- * Returns human readable node type for given AST node
- * @param node AST node
- * @returns Human readable node type
- */ function readableNodeType(node) {
-    if (node.type === NodeType.Literal) {
-        if ("regex" in node) {
-            return "RegExp literal";
-        }
-        return `${type(node.value)} literal`;
-    }
-    if (isJSX(node)) {
-        return `JSX ${toLowerCase(delimiterCase(replace(node.type, "JSX", ""), " "))}`;
-    }
-    return toLowerCase(delimiterCase(node.type, " "));
-}
-
-const Construction = Data.taggedEnum();
-const None = Construction.None();
-/**
- * Get a function that detects the construction of a given node.
- * @param context The rule context
- * @returns A function that detects the construction of a given node
- */ function constructionDetector(context) {
-    /**
-   * Detect if a node is a constructed value.
-   * @param node The AST node to detect the construction of
-   * @param scope The scope of the node
-   * @returns The construction of the node
-   */ // eslint-disable-next-line sonarjs/cognitive-complexity
-    const detect = (node, scope = context.getScope())=>{
-        return N(node).when(is(NodeType.ArrayExpression), (node)=>Construction.Array({
-                node,
-                usage: O$1.none()
-            })).when(is(NodeType.ObjectExpression), (node)=>Construction.ObjectExpression({
-                node,
-                usage: O$1.none()
-            })).when(is(NodeType.ClassExpression), (node)=>Construction.ClassExpression({
-                node,
-                usage: O$1.none()
-            })).when(is(NodeType.JSXElement), (node)=>Construction.JSXElement({
-                node,
-                usage: O$1.none()
-            })).when(is(NodeType.JSXFragment), (node)=>Construction.JSXFragment({
-                node,
-                usage: O$1.none()
-            })).when(is(NodeType.NewExpression), (node)=>Construction.NewExpression({
-                node,
-                usage: O$1.none()
-            })).when(isOneOf([
-            NodeType.FunctionExpression,
-            NodeType.ArrowFunctionExpression
-        ]), (node)=>{
-            return Construction.FunctionExpression({
-                node,
-                usage: O$1.none()
-            });
-        }).when(is(NodeType.MemberExpression), (node)=>{
-            if (!("object" in node)) {
-                return None;
-            }
-            const object = detect(node.object);
-            if (object._tag === "None") {
-                return object;
-            }
-            return {
-                ...object,
-                usage: O$1.some(node.object)
-            };
-        }).when(is(NodeType.AssignmentExpression), (node)=>{
-            if (!("right" in node)) {
-                return None;
-            }
-            const right = detect(node.right);
-            if (right._tag === "None") {
-                return right;
-            }
-            return Construction.AssignmentExpression({
-                node: right.node,
-                usage: O$1.some(node)
-            });
-        }).when(is(NodeType.LogicalExpression), (node)=>{
-            if (!("left" in node && "right" in node)) {
-                return None;
-            }
-            const left = detect(node.left);
-            if (left._tag === "None") {
-                return None;
-            }
-            return detect(node.right);
-        }).when(is(NodeType.ConditionalExpression), (node)=>{
-            if (!("consequent" in node && "alternate" in node && !isNil(node.alternate))) {
-                return None;
-            }
-            const consequent = detect(node.consequent);
-            if (consequent._tag === "None") {
-                return None;
-            }
-            return detect(node.alternate);
-        }).when(is(NodeType.Identifier), (node)=>{
-            if (!("name" in node && isString(node.name))) {
-                return None;
-            }
-            const maybeLatestDef = O$1.fromNullable(scope.set.get(node.name)?.defs.at(-1));
-            if (O$1.isNone(maybeLatestDef)) {
-                return None;
-            }
-            const latestDef = maybeLatestDef.value;
-            if (latestDef.type !== DefinitionType.Variable && latestDef.type !== DefinitionType.FunctionName) {
-                return None;
-            }
-            if (latestDef.node.type === NodeType.FunctionDeclaration) {
-                return Construction.FunctionDeclaration({
-                    node: latestDef.node,
-                    usage: O$1.some(node)
-                });
-            }
-            if (!("init" in latestDef.node) || latestDef.node.init === null) {
-                return None;
-            }
-            return detect(latestDef.node.init);
-        }).when(is(NodeType.Literal), (node)=>{
-            if ("regex" in node) {
-                return Construction.RegExpLiteral({
-                    node,
-                    usage: O$1.none()
-                });
-            }
-            return None;
-        }).when(isOneOf([
-            NodeType.TSAsExpression,
-            NodeType.TSTypeAssertion
-        ]), ()=>{
-            if (!("expression" in node) || !isObject(node.expression)) {
-                return None;
-            }
-            return detect(node.expression);
-        }).otherwise(()=>None);
-    };
-    return detect;
-}
-
-const unstableAssignmentPatternTypes = [
-    NodeType.JSXElement,
-    NodeType.ArrayExpression,
-    NodeType.ObjectExpression,
-    NodeType.FunctionExpression,
-    NodeType.ArrowFunctionExpression,
-    NodeType.ClassExpression,
-    NodeType.NewExpression,
-    NodeType.CallExpression
-];
-/**
- * Check if the given node is an unstable assignment pattern (will change between assignments)
- * @param node The AST node to check
- * @param node.right The right side of the assignment
- */ function isUnstableAssignmentPattern(node) {
-    const { right } = node;
-    if (right.type === NodeType.Literal) {
-        return "regex" in right;
-    }
-    return isOneOf(unstableAssignmentPatternTypes)(right);
-}
-
-/**
- * Determines whether node equals to another node
- * @param a node to compare
- * @param b node to compare
- * @returns `true` if node equal
- * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
- */ function isNodeEqual(a, b) {
-    if (a.type !== b.type) {
-        return false;
-    }
-    if (a.type === NodeType.ThisExpression && b.type === NodeType.ThisExpression) {
-        return true;
-    }
-    if (a.type === NodeType.Literal && b.type === NodeType.Literal) {
-        return a.value === b.value;
-    }
-    if (a.type === NodeType.Identifier && b.type === NodeType.Identifier) {
-        return a.name === b.name;
-    }
-    if (a.type === NodeType.MemberExpression && b.type === NodeType.MemberExpression) {
-        return isNodeEqual(a.property, b.property) && isNodeEqual(a.object, b.object);
-    }
-    return false;
-}
-
-// Ported from: https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/utils/src/ast-utils/eslint-utils/astUtilities.ts
-/**
- * Get the proper location of a given function node to report.
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation}
- */ const getFunctionHeadLocation = eslintUtils.getFunctionHeadLocation;
-/**
- * Get the name and kind of a given function node.
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind}
- */ const getFunctionNameWithKind = eslintUtils.getFunctionNameWithKind;
-/**
- * Get the property name of a given property node.
- * If the node is a computed property, this tries to compute the property name by the getStringIfConstant function.
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname}
- * @returns The property name of the node. If the property name is not constant then it returns `null`.
- */ const getPropertyName = eslintUtils.getPropertyName;
-/**
- * Get the value of a given node if it can decide the value statically.
- * If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the
- * given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have
- * not been modified.
- * For example, it considers `Symbol.iterator`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static.
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue}
- * @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the
- * static value of the node, it returns `null`.
- */ const getStaticValue = eslintUtils.getStaticValue;
-/**
- * Get the string value of a given node.
- * This function is a tiny wrapper of the getStaticValue function.
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant}
- */ const getStringIfConstant = eslintUtils.getStringIfConstant;
-/**
- * Check whether a given node has any side effect or not.
- * The side effect means that it may modify a certain variable or object member. This function considers the node which
- * contains the following types as the node which has side effects:
- * - `AssignmentExpression`
- * - `AwaitExpression`
- * - `CallExpression`
- * - `ImportExpression`
- * - `NewExpression`
- * - `UnaryExpression([operator = "delete"])`
- * - `UpdateExpression`
- * - `YieldExpression`
- * - When `options.considerGetters` is `true`:
- * - `MemberExpression`
- * - When `options.considerImplicitTypeConversion` is `true`:
- * - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])`
- * - `MemberExpression([computed = true])`
- * - `MethodDefinition([computed = true])`
- * - `Property([computed = true])`
- * - `UnaryExpression([operator = "-" | "+" | "!" | "~"])`
- * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect}
- */ const hasSideEffect = eslintUtils.hasSideEffect;
-const isParenthesized = eslintUtils.isParenthesized;
-
-/**
- * Checks if the given node is a function expression or arrow function expression of a object method.
- * @param node The node to check.
- * @returns `true` if the node is a function expression or arrow function expression of a object method, `false` otherwise.
- */ const isFunctionOfObjectMethod = a({
-    type: _.union([
-        NodeType.FunctionExpression,
-        NodeType.ArrowFunctionExpression
-    ]),
-    parent: {
-        type: NodeType.Property,
-        parent: {
-            type: NodeType.ObjectExpression
-        }
-    }
-});
-/**
- * Checks if the given node is a function expression or arrow function expression of a class method.
- * @param node The node to check.
- * @returns `true` if the node is a function expression or arrow function expression of a class method, `false` otherwise.
- */ const isFunctionOfClassMethod = a({
-    type: _.union([
-        NodeType.FunctionExpression,
-        NodeType.ArrowFunctionExpression
-    ]),
-    parent: {
-        type: NodeType.MethodDefinition,
-        parent: {
-            type: NodeType.ClassBody
-        }
-    }
-});
-/**
- * Checks if the given node is a function expression or arrow function expression of a class property.
- * @param node The node to check.
- * @returns `true` if the node is a function expression or arrow function expression of a class property, `false` otherwise.
- */ const isFunctionOfClassProperty = a({
-    type: _.union([
-        NodeType.FunctionExpression,
-        NodeType.ArrowFunctionExpression
-    ]),
-    parent: {
-        type: NodeType.Property,
-        parent: {
-            type: NodeType.ClassBody
-        }
-    }
-});
-
-/**
- * Checks if a node is an identifier with a given name
- * @param node The AST node
- * @param name The name
- * @returns `true if the node is an identifier with the given name
- */ function isIdentifierWithName(node, name) {
-    return node.type === NodeType.Identifier && node.name === name;
-}
-/**
- * Checks if a node is an identifier with one of names
- * @param node The AST node
- * @param name The name
- * @returns `true` if the node is an identifier with one of names
- */ function isIdentifierWithOneOfNames(node, name) {
-    return node.type === NodeType.Identifier && name.includes(node.name);
-}
-/**
- * Gets FunctionDeclaration's identifier or FunctionExpression's parent identifier if it exists
- * @param node The AST node to check
- * @returns function identifier or null
- */ function getFunctionIdentifier(node) {
-    if (node.id) {
-        return node.id;
-    }
-    if (isOneOf([
-        NodeType.ArrowFunctionExpression,
-        NodeType.FunctionExpression
-    ])(node)) {
-        return "id" in node.parent && node.parent.id?.type === NodeType.Identifier ? node.parent.id : null;
-    }
-    return null;
-}
-/**
- * Gets class identifier from ClassDeclaration or ClassExpression
- * @param node The AST node to check
- * @returns class identifier or null
- */ function getClassIdentifier(node) {
-    return N(node).with({
-        type: NodeType.ClassDeclaration
-    }, (x)=>x.id).with({
-        type: NodeType.ClassExpression,
-        parent: {
-            id: {
-                type: NodeType.Identifier
-            },
-            type: NodeType.VariableDeclarator
-        }
-    }, (x)=>x.parent.id).otherwise(()=>null);
-}
-/**
- * Gets nested identifiers in a node
- * @param node The AST node
- * @returns The nested identifiers
- */ function getNestedIdentifiers(node) {
-    const identifiers = [];
-    if (node.type === NodeType.Identifier) {
-        identifiers.push(node);
-    }
-    if ("arguments" in node) {
-        node.arguments.forEach((x)=>{
-            identifiers.push(...getNestedIdentifiers(x));
-        });
-    }
-    if ("elements" in node) {
-        node.elements.forEach((x)=>{
-            if (x !== null) {
-                identifiers.push(...getNestedIdentifiers(x));
-            }
-        });
-    }
-    if ("properties" in node) {
-        node.properties.forEach((x)=>{
-            identifiers.push(...getNestedIdentifiers(x));
-        });
-    }
-    if ("expressions" in node) {
-        node.expressions.forEach((x)=>{
-            identifiers.push(...getNestedIdentifiers(x));
-        });
-    }
-    if (node.type === NodeType.Property) {
-        identifiers.push(...getNestedIdentifiers(node.value));
-    }
-    if (node.type === NodeType.SpreadElement) {
-        identifiers.push(...getNestedIdentifiers(node.argument));
-    }
-    if (node.type === NodeType.MemberExpression) {
-        identifiers.push(...getNestedIdentifiers(node.object));
-    }
-    if (node.type === NodeType.UnaryExpression) {
-        identifiers.push(...getNestedIdentifiers(node.argument));
-    }
-    if (node.type === NodeType.ChainExpression) {
-        identifiers.push(...getNestedIdentifiers(node.expression));
-    }
-    if (node.type === NodeType.TSNonNullExpression) {
-        identifiers.push(...getNestedIdentifiers(node.expression));
-    }
-    return identifiers;
-}
-
-function isRegExpLiteral(node) {
-    return node.type === NodeType.Literal && "regex" in node;
-}
-function isStringLiteral(node) {
-    return node?.type === NodeType.Literal && isString(node.value);
-}
-
-/**
- * Check if a node is multiline
- * @param node The AST node to check
- * @returns  `true` if the node is multiline
- */ function isMultiLine(node) {
-    return node.loc.start.line !== node.loc.end.line;
-}
-function unsafeIsToStringCall(node) {
-    return a({
-        type: NodeType.CallExpression,
-        callee: {
-            type: NodeType.MemberExpression,
-            property: {
-                type: NodeType.Identifier,
-                name: "toString"
-            }
-        }
-    }, node);
-}
-function unsafeIsStringCall(node) {
-    return a({
-        type: NodeType.CallExpression,
-        callee: {
-            type: NodeType.Identifier,
-            name: "String"
-        }
-    }, node);
-}
-/**
- * Unsafe check whether given node or its parent is directly inside `Array.from` call
- * @param node The AST node to check
- * @returns `true` if node is directly inside `Array.from` call, `false` if not
- */ function unsafeIsArrayFromCall(node) {
-    return a({
-        type: NodeType.CallExpression,
-        callee: {
-            type: NodeType.MemberExpression,
-            property: {
-                name: "from"
-            }
-        }
-    }, node);
-}
-/**
- * Unsafe check whether given node or its parent is directly inside `map` call
- * ```jsx
- * _ = <div>{items.map(item => <li />)}</div>
- * `                   ^^^^^^^^^^^^^^       `
- * ```
- * @param node The AST node to check
- * @returns `true` if node is directly inside `map` call, `false` if not
- */ function unsafeIsMapCall(node) {
-    return a({
-        callee: {
-            type: NodeType.MemberExpression,
-            property: {
-                name: "map"
-            }
-        }
-    }, node);
-}
-
-function isPropertyOfObjectExpression(node) {
-    return node.parent?.type === NodeType.Property;
-}
-function isPropertyWithIdentifierKey(node, key) {
-    return node.type === NodeType.Property && isIdentifierWithName(node.key, key);
-}
-function findPropertyWithIdentifierKey(properties, key) {
-    return properties.find((x)=>isPropertyWithIdentifierKey(x, key));
-}
-
-/**
- * Gets nested return statements in a node
- * @param node The AST node
- * @returns The nested return statements
- */ function getNestedReturnStatements(node) {
-    const returnStatements = [];
-    if (node.type === NodeType.ReturnStatement) {
-        returnStatements.push(node);
-    }
-    if ("body" in node && !isNil(node.body)) {
-        Array.isArray(node.body) ? node.body.forEach((x)=>{
-            returnStatements.push(...getNestedReturnStatements(x));
-        }) : returnStatements.push(...getNestedReturnStatements(node.body));
-    }
-    if ("consequent" in node) {
-        Array.isArray(node.consequent) ? node.consequent.forEach((x)=>{
-            returnStatements.push(...getNestedReturnStatements(x));
-        }) : returnStatements.push(...getNestedReturnStatements(node.consequent));
-    }
-    if ("alternate" in node && node.alternate !== null) {
-        Array.isArray(node.alternate) ? node.alternate.forEach((x)=>{
-            returnStatements.push(...getNestedReturnStatements(x));
-        }) : returnStatements.push(...getNestedReturnStatements(node.alternate));
-    }
-    if ("cases" in node) {
-        node.cases.forEach((x)=>{
-            returnStatements.push(...getNestedReturnStatements(x));
-        });
-    }
-    if ("block" in node) {
-        returnStatements.push(...getNestedReturnStatements(node.block));
-    }
-    if ("handler" in node && node.handler !== null) {
-        returnStatements.push(...getNestedReturnStatements(node.handler));
-    }
-    if ("finalizer" in node && node.finalizer !== null) {
-        returnStatements.push(...getNestedReturnStatements(node.finalizer));
-    }
-    if ("expression" in node && node.expression !== true && node.expression !== false) {
-        returnStatements.push(...getNestedReturnStatements(node.expression));
-    }
-    if ("test" in node && node.test !== null) {
-        returnStatements.push(...getNestedReturnStatements(node.test));
-    }
-    return returnStatements;
-}
-
-/**
- * Traverses up the AST tree until the predicate returns `true` or the root node is reached
- * @param node The AST node to start traversing from
- * @param predicate The predicate to check each node
- * @returns The first node that matches the predicate or `null` if no node matches
- */ function traverseUp(node, predicate) {
-    const { parent } = node;
-    if (!parent || parent.type === NodeType.Program) {
-        return null;
-    }
-    return predicate(parent) ? parent : traverseUp(parent, predicate);
-}
-/**
- * Traverses up the AST tree until the predicate returns `true` or the root node is reached
- * @template T
- * @param node The AST node to start traversing from
- * @param predicate The predicate to check each node. **must be a type guard**
- * @returns The first node that matches the predicate or `null` if no node matches
- */ function traverseUpGuard(node, predicate) {
-    const { parent } = node;
-    if (!parent || parent.type === NodeType.Program) {
-        return null;
-    }
-    return predicate(parent) ? parent : traverseUpGuard(parent, predicate);
-}
-
-function isDeclaredInNode({ functionNode, reference, scopeManager }) {
-    const scope = scopeManager.acquire(functionNode);
-    return !!scope?.set.has(reference.identifier.name);
-}
-function getExternalRefs(params) {
-    const { node, scopeManager, sourceCode } = params;
-    const scope = scopeManager.acquire(node);
-    if (!scope) {
-        return [];
-    }
-    const references = scope.references.filter((x)=>x.isRead() && !scope.set.has(x.identifier.name)).map((x)=>{
-        const referenceNode = traverseUpGuard(x.identifier, isOneOf([
-            NodeType.MemberExpression,
-            NodeType.Identifier
-        ]));
-        if (!referenceNode) {
-            return null;
-        }
-        return {
-            node: referenceNode,
-            text: sourceCode.getText(referenceNode),
-            variable: x
-        };
-    }).filter((x)=>x !== null);
-    const localRefIds = new Set([
-        ...scope.set.values()
-    ].map((x)=>sourceCode.getText(x.identifiers[0])));
-    const externalRefs = references.filter((x)=>isNil(x.variable.resolved) || !localRefIds.has(x.text));
-    return uniqueBy(externalRefs, (x)=>x.text).map((x)=>x.variable);
-}
-
-/**
- * Find a variable through a list of variables by name
- * @param name The name of the variable to find
- */ function findVariableByName(name) {
-    /**
-   * @param variables The variables to search through
-   */ return (variables)=>{
-        return O$1.fromNullable(variables.find((variable)=>variable.name === name));
-    };
-}
-/**
- * Get all variables from the given scope up to the global scope
- * @param startScope The scope to start from
- */ function getVariablesUpToGlobal(startScope) {
-    const scopeRef = MutRef.make(startScope);
-    const variablesRef = MutRef.make(MutRef.get(scopeRef).variables);
-    // eslint-disable-next-line functional/no-loop-statements
-    while(MutRef.get(scopeRef).type !== ScopeType.global){
-        MutRef.set(scopeRef, MutRef.get(scopeRef).upper);
-        MutRef.update(variablesRef, (variables)=>variables.concat(MutRef.get(scopeRef).variables));
-    }
-    return MutRef.get(variablesRef).reverse();
-}
-/**
- * Find a variable through a list of variables by name, starting from the given scope and going up to the global scope
- * @param name The name of the variable to find
- * @param startScope The scope to start from
- */ function findVariableByNameUpToGlobal(name, startScope) {
-    return findVariableByName(name)(getVariablesUpToGlobal(startScope));
-}
-function resolveDefinitionInit(def) {
-    if ("init" in def.node && !isNullable(def.node.init)) {
-        return O$1.some(def.node.init);
-    }
-    // TODO: support other types of definitions
-    return O$1.none();
-}
-/**
- * Get the init node of the nth definition of a variable
- * @param at The index number of def in defs
- * @returns A function that takes a variable and returns the init node of the nth definition of that variable
- */ function getVariableInit(at) {
-    return (variable)=>{
-        return F.pipe(O$1.some(variable), O$1.flatMapNullable((v)=>v.defs.at(at)), O$1.flatMap(resolveDefinitionInit));
-    };
-}
-function isInitExpression(node) {
-    return node.type !== NodeType.VariableDeclaration;
-}
-function getVariableInitExpression(at) {
-    return (variable)=>{
-        return F.pipe(O$1.some(variable), O$1.flatMapNullable((v)=>v.defs.at(at)), O$1.flatMap(resolveDefinitionInit), O$1.filter(isInitExpression));
-    };
-}
-
-export { Construction, NodeType, constructionDetector, findPropertyWithIdentifierKey, findVariableByName, findVariableByNameUpToGlobal, getClassIdentifier, getExternalRefs, getFunctionHeadLocation, getFunctionIdentifier, getFunctionNameWithKind, getNestedIdentifiers, getNestedReturnStatements, getPropertyName, getStaticValue, getStringIfConstant, getVariableInit, getVariableInitExpression, getVariablesUpToGlobal, hasSideEffect, is, isArrayTupleType, isClass, isDeclaredInNode, isDestructuringPattern, isFunction, isFunctionOfClassMethod, isFunctionOfClassProperty, isFunctionOfObjectMethod, isFunctionType, isIdentifierWithName, isIdentifierWithOneOfNames, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLeftHandSideExpression, isLeftHandSideExpressionType, isLoop, isMultiLine, isNodeEqual, isOneOf, isParenthesized, isProperty, isPropertyOfObjectExpression, isPropertyWithIdentifierKey, isRegExpLiteral, isStringLiteral, isTypeDeclaration, isUnstableAssignmentPattern, readableNodeType, resolveDefinitionInit, traverseUp, traverseUpGuard, unsafeIsArrayFromCall, unsafeIsMapCall, unsafeIsStringCall, unsafeIsToStringCall, unstableAssignmentPatternTypes };