@eslint-react/jsx 0.8.6-beta.1 → 0.8.6-beta.5

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

@@ -0,0 +1,870 @@
+import { Data, O as O$1, uniqueBy, MutRef, F } from '@eslint-react/tools';
+import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
+import { isNil, type } from 'rambda';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import { ASTUtils } from '@typescript-eslint/utils';
+import * as eslintUtils from '@eslint-community/eslint-utils';
+import { toLowerCase, delimiterCase, replace } from 'string-ts';
+
+/**
+ * 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
+]);
+
+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);
+}
+
+// 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;
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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;
+}
+
+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));
+}
+
+/**
+ * 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, " "));
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Get all unary operators in a nested unary expression.
+ * @param node The node to get the operators from.
+ * @returns All unary operators in a nested unary expression.
+ */ function getNestedUnaryOperators(node) {
+    const { operator } = node;
+    const { argument } = node;
+    if (argument.type === NodeType.UnaryExpression) {
+        return [
+            operator,
+            ...getNestedUnaryOperators(argument)
+        ];
+    }
+    return [
+        operator
+    ];
+}
+
+/**
+ * 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);
+    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, getNestedUnaryOperators, 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 };