@eslint-react/var 2.0.0-next.0 → 2.0.0-next.2

package/dist/index.js

@@ -1,46 +1,24 @@
-'use strict';
-
-var eff = require('@eslint-react/eff');
-var scopeManager = require('@typescript-eslint/scope-manager');
-var types = require('@typescript-eslint/types');
-var ASTUtils = require('@typescript-eslint/utils/ast-utils');
-var AST = require('@eslint-react/ast');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var ASTUtils__namespace = /*#__PURE__*/_interopNamespace(ASTUtils);
-var AST__namespace = /*#__PURE__*/_interopNamespace(AST);
+import { dual, _ } from '@eslint-react/eff';
+import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import * as ASTUtils from '@typescript-eslint/utils/ast-utils';
+import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
+import * as AST from '@eslint-react/ast';
 
 // src/var-collect.ts
 function getVariableInitNode(variable, at) {
-  if (variable == null) return eff._;
+  if (variable == null) return _;
   const def = variable.defs.at(at);
-  if (def == null) return eff._;
+  if (def == null) return _;
   switch (true) {
-    case (def.type === scopeManager.DefinitionType.FunctionName && def.node.type === types.AST_NODE_TYPES.FunctionDeclaration):
+    case (def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration):
       return def.node;
-    case (def.type === scopeManager.DefinitionType.ClassName && def.node.type === types.AST_NODE_TYPES.ClassDeclaration):
+    case (def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration):
       return def.node;
     case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
       return def.node.init;
     default:
-      return eff._;
+      return _;
   }
 }
 
@@ -48,28 +26,28 @@ function getVariableInitNode(variable, at) {
 function getVariables(initialScope) {
   let scope = initialScope;
   const variables = [...scope.variables];
-  while (scope.type !== scopeManager.ScopeType.global) {
+  while (scope.type !== ScopeType.global) {
     scope = scope.upper;
     variables.push(...scope.variables);
   }
   return variables.reverse();
 }
-var findVariable2 = eff.dual(2, (nameOrNode, initialScope) => {
-  if (nameOrNode == null) return eff._;
-  return ASTUtils__namespace.findVariable(initialScope, nameOrNode) ?? eff._;
+var findVariable2 = dual(2, (nameOrNode, initialScope) => {
+  if (nameOrNode == null) return _;
+  return ASTUtils.findVariable(initialScope, nameOrNode) ?? _;
 });
 function findPropertyInProperties(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
   return properties.findLast((prop) => {
-    if (prop.type === types.AST_NODE_TYPES.Property) {
+    if (prop.type === AST_NODE_TYPES.Property) {
       return "name" in prop.key && prop.key.name === name;
     }
-    if (prop.type === types.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === AST_NODE_TYPES.SpreadElement) {
       switch (prop.argument.type) {
-        case types.AST_NODE_TYPES.Identifier: {
+        case AST_NODE_TYPES.Identifier: {
           if (seen.has(prop.argument.name)) return false;
           const variable = findVariable2(prop.argument.name, initialScope);
           const variableNode = getVariableInitNode(variable, 0);
-          if (variableNode?.type === types.AST_NODE_TYPES.ObjectExpression) {
+          if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
             seen.add(prop.argument.name);
             return findPropertyInProperties(
               name,
@@ -80,7 +58,7 @@ function findPropertyInProperties(name, properties, initialScope, seen = /* @__P
           }
           return false;
         }
-        case types.AST_NODE_TYPES.ObjectExpression: {
+        case AST_NODE_TYPES.ObjectExpression: {
           return findPropertyInProperties(
             name,
             prop.argument.properties,
@@ -100,78 +78,78 @@ var ConstructionDetectionHint = {
   StrictCallExpression: 1n << 0n
 };
 function getConstruction(node, initialScope, hint = ConstructionDetectionHint.None) {
-  if (node == null) return eff._;
+  if (node == null) return _;
   switch (node.type) {
-    case types.AST_NODE_TYPES.JSXElement:
-    case types.AST_NODE_TYPES.JSXFragment:
+    case AST_NODE_TYPES.JSXElement:
+    case AST_NODE_TYPES.JSXFragment:
       return { kind: "JSXElement", node };
-    case types.AST_NODE_TYPES.ArrayExpression:
+    case AST_NODE_TYPES.ArrayExpression:
       return { kind: "ArrayExpression", node };
-    case types.AST_NODE_TYPES.ObjectExpression:
+    case AST_NODE_TYPES.ObjectExpression:
       return { kind: "ObjectExpression", node };
-    case types.AST_NODE_TYPES.ClassExpression:
+    case AST_NODE_TYPES.ClassExpression:
       return { kind: "ClassExpression", node };
-    case types.AST_NODE_TYPES.NewExpression:
+    case AST_NODE_TYPES.NewExpression:
       return { kind: "NewExpression", node };
-    case types.AST_NODE_TYPES.FunctionExpression:
-    case types.AST_NODE_TYPES.ArrowFunctionExpression:
+    case AST_NODE_TYPES.FunctionExpression:
+    case AST_NODE_TYPES.ArrowFunctionExpression:
       return { kind: "FunctionExpression", node };
-    case types.AST_NODE_TYPES.CallExpression: {
+    case AST_NODE_TYPES.CallExpression: {
       if (hint & ConstructionDetectionHint.StrictCallExpression) {
         return { kind: "CallExpression", node };
       }
-      return eff._;
+      return _;
     }
-    case types.AST_NODE_TYPES.MemberExpression: {
-      if (!("object" in node)) return eff._;
+    case AST_NODE_TYPES.MemberExpression: {
+      if (!("object" in node)) return _;
       return getConstruction(node.object, initialScope, hint);
     }
-    case types.AST_NODE_TYPES.AssignmentExpression:
-    case types.AST_NODE_TYPES.AssignmentPattern: {
-      if (!("right" in node)) return eff._;
+    case AST_NODE_TYPES.AssignmentExpression:
+    case AST_NODE_TYPES.AssignmentPattern: {
+      if (!("right" in node)) return _;
       return getConstruction(node.right, initialScope, hint);
     }
-    case types.AST_NODE_TYPES.LogicalExpression: {
+    case AST_NODE_TYPES.LogicalExpression: {
       const lvc = getConstruction(node.left, initialScope, hint);
-      if (lvc == null) return eff._;
+      if (lvc == null) return _;
       return getConstruction(node.right, initialScope, hint);
     }
-    case types.AST_NODE_TYPES.ConditionalExpression: {
+    case AST_NODE_TYPES.ConditionalExpression: {
       const cvc = getConstruction(node.consequent, initialScope, hint);
-      if (cvc == null) return eff._;
+      if (cvc == null) return _;
       return getConstruction(node.alternate, initialScope, hint);
     }
-    case types.AST_NODE_TYPES.Identifier: {
+    case AST_NODE_TYPES.Identifier: {
       if (!("name" in node) || typeof node.name !== "string") {
-        return eff._;
+        return _;
       }
       const variable = initialScope.set.get(node.name);
       const variableNode = getVariableInitNode(variable, -1);
       return getConstruction(variableNode, initialScope, hint);
     }
-    case types.AST_NODE_TYPES.Literal: {
+    case AST_NODE_TYPES.Literal: {
       if ("regex" in node) {
         return { kind: "RegExpLiteral", node };
       }
-      return eff._;
+      return _;
     }
     default: {
       if (!("expression" in node) || typeof node.expression !== "object") {
-        return eff._;
+        return _;
       }
       return getConstruction(node.expression, initialScope, hint);
     }
   }
 }
 function getVariableDeclaratorId(node, prev) {
-  if (node == null) return eff._;
+  if (node == null) return _;
   switch (true) {
-    case (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init === prev):
+    case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
       return node.id;
-    case (node.type === types.AST_NODE_TYPES.AssignmentExpression && node.right === prev):
+    case (node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev):
       return node.left;
-    case (node.type === types.AST_NODE_TYPES.BlockStatement || node.type === types.AST_NODE_TYPES.Program || node.parent === node):
-      return eff._;
+    case (node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node):
+      return _;
     default:
       return getVariableDeclaratorId(node.parent, node);
   }
@@ -190,14 +168,14 @@ function toStaticValue(lazyValue) {
   if (kind !== "lazy") {
     return lazyValue;
   }
-  const staticValue = initialScope == null ? ASTUtils.getStaticValue(node) : ASTUtils.getStaticValue(node, initialScope);
+  const staticValue = initialScope == null ? getStaticValue(node) : getStaticValue(node, initialScope);
   return staticValue == null ? { kind: "none", node, initialScope } : { kind: "some", node, initialScope, value: staticValue.value };
 }
 var thisBlockTypes = [
-  types.AST_NODE_TYPES.FunctionDeclaration,
-  types.AST_NODE_TYPES.FunctionExpression,
-  types.AST_NODE_TYPES.ClassBody,
-  types.AST_NODE_TYPES.Program
+  AST_NODE_TYPES.FunctionDeclaration,
+  AST_NODE_TYPES.FunctionExpression,
+  AST_NODE_TYPES.ClassBody,
+  AST_NODE_TYPES.Program
 ];
 function isNodeValueEqual(a, b, initialScopes) {
   const [aScope, bScope] = initialScopes;
@@ -205,13 +183,13 @@ function isNodeValueEqual(a, b, initialScopes) {
     case a === b: {
       return true;
     }
-    case (a.type === types.AST_NODE_TYPES.Literal && b.type === types.AST_NODE_TYPES.Literal): {
+    case (a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal): {
       return a.value === b.value;
     }
-    case (a.type === types.AST_NODE_TYPES.TemplateElement && b.type === types.AST_NODE_TYPES.TemplateElement): {
+    case (a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement): {
       return a.value.cooked === b.value.cooked;
     }
-    case (a.type === types.AST_NODE_TYPES.Identifier && b.type === types.AST_NODE_TYPES.Identifier): {
+    case (a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier): {
       const aVar = findVariable2(a, aScope);
       const bVar = findVariable2(b, bScope);
       const aVarNode = getVariableInitNodeLoose(aVar, 0);
@@ -223,17 +201,17 @@ function isNodeValueEqual(a, b, initialScopes) {
       const aDefParentParent = aDef?.parent?.parent;
       const bDefParentParent = bDef?.parent?.parent;
       switch (true) {
-        case (aVarNodeParent?.type === types.AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === types.AST_NODE_TYPES.CallExpression && AST__namespace.isFunction(aVarNode) && AST__namespace.isFunction(bVarNode)): {
-          if (!AST__namespace.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
+        case (aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && AST.isFunction(aVarNode) && AST.isFunction(bVarNode)): {
+          if (!AST.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
             return false;
           }
           const aParams = aVarNode.params;
           const bParams = bVarNode.params;
-          const aPos = aParams.findIndex((x) => AST__namespace.isNodeEqual(x, a));
-          const bPos = bParams.findIndex((x) => AST__namespace.isNodeEqual(x, b));
+          const aPos = aParams.findIndex((x) => AST.isNodeEqual(x, a));
+          const bPos = bParams.findIndex((x) => AST.isNodeEqual(x, b));
           return aPos !== -1 && bPos !== -1 && aPos === bPos;
         }
-        case (aDefParentParent?.type === types.AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === types.AST_NODE_TYPES.ForOfStatement): {
+        case (aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement): {
           const aLeft = aDefParentParent.left;
           const bLeft = bDefParentParent.left;
           if (aLeft.type !== bLeft.type) {
@@ -241,22 +219,22 @@ function isNodeValueEqual(a, b, initialScopes) {
           }
           const aRight = aDefParentParent.right;
           const bRight = bDefParentParent.right;
-          return AST__namespace.isNodeEqual(aRight, bRight);
+          return AST.isNodeEqual(aRight, bRight);
         }
         default: {
           return aVar != null && bVar != null && aVar === bVar;
         }
       }
     }
-    case (a.type === types.AST_NODE_TYPES.MemberExpression && b.type === types.AST_NODE_TYPES.MemberExpression): {
-      return AST__namespace.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
+    case (a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression): {
+      return AST.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
     }
-    case (a.type === types.AST_NODE_TYPES.ThisExpression && b.type === types.AST_NODE_TYPES.ThisExpression): {
+    case (a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression): {
       if (aScope.block === bScope.block) {
         return true;
       }
-      const aFunction = AST__namespace.findParentNode(a, AST__namespace.isOneOf(thisBlockTypes));
-      const bFunction = AST__namespace.findParentNode(b, AST__namespace.isOneOf(thisBlockTypes));
+      const aFunction = AST.findParentNode(a, AST.isOneOf(thisBlockTypes));
+      const bFunction = AST.findParentNode(b, AST.isOneOf(thisBlockTypes));
       return aFunction === bFunction;
     }
     default: {
@@ -267,21 +245,12 @@ function isNodeValueEqual(a, b, initialScopes) {
   }
 }
 function getVariableInitNodeLoose(variable, at) {
-  if (variable == null) return eff._;
+  if (variable == null) return _;
   const node = getVariableInitNode(variable, at);
   if (node != null) return node;
   const def = variable.defs.at(at);
-  if (def?.type === scopeManager.DefinitionType.Parameter && AST__namespace.isFunction(def.node)) return def.node;
-  return eff._;
+  if (def?.type === DefinitionType.Parameter && AST.isFunction(def.node)) return def.node;
+  return _;
 }
 
-exports.ConstructionDetectionHint = ConstructionDetectionHint;
-exports.findPropertyInProperties = findPropertyInProperties;
-exports.findVariable = findVariable2;
-exports.getChidScopes = getChidScopes;
-exports.getConstruction = getConstruction;
-exports.getVariableDeclaratorId = getVariableDeclaratorId;
-exports.getVariableInitNode = getVariableInitNode;
-exports.getVariables = getVariables;
-exports.isNodeValueEqual = isNodeValueEqual;
-exports.toStaticValue = toStaticValue;
+export { ConstructionDetectionHint, findPropertyInProperties, findVariable2 as findVariable, getChidScopes, getConstruction, getVariableDeclaratorId, getVariableInitNode, getVariables, isNodeValueEqual, toStaticValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "2.0.0-next.0",
+  "version": "2.0.0-next.2",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -14,22 +14,14 @@
   "license": "MIT",
   "author": "Rel1cx<rel1cx@proton.me>",
   "sideEffects": false,
+  "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "./package.json"
@@ -40,8 +32,8 @@
     "@typescript-eslint/utils": "^8.30.1",
     "string-ts": "^2.2.1",
     "ts-pattern": "^5.7.0",
-    "@eslint-react/eff": "2.0.0-next.0",
-    "@eslint-react/ast": "2.0.0-next.0"
+    "@eslint-react/ast": "2.0.0-next.2",
+    "@eslint-react/eff": "2.0.0-next.2"
   },
   "devDependencies": {
     "tsup": "^8.4.0",

package/dist/index.d.mts

@@ -1,102 +0,0 @@
-import { Scope, Variable } from '@typescript-eslint/scope-manager';
-import { TSESTree } from '@typescript-eslint/types';
-import { _ } from '@eslint-react/eff';
-
-/**
- * Get all variables from the given scope up to the global scope
- * @param initialScope The scope to start from
- * @returns All variables from the given scope up to the global scope
- */
-declare function getVariables(initialScope: Scope): Variable[];
-declare const findVariable: {
-    (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | _) => Variable | _;
-    (nameOrNode: string | TSESTree.Identifier | _, initialScope: Scope): Variable | _;
-};
-declare function findPropertyInProperties(name: string, properties: (TSESTree.Property | TSESTree.RestElement | TSESTree.SpreadElement)[], initialScope: Scope, seen?: Set<string>): (typeof properties)[number] | _;
-
-declare const ConstructionDetectionHint: {
-    None: bigint;
-    StrictCallExpression: bigint;
-};
-type Construction = {
-    kind: "ArrayExpression";
-    node: TSESTree.ArrayExpression;
-} | {
-    kind: "CallExpression";
-    node: TSESTree.CallExpression;
-} | {
-    kind: "ClassExpression";
-    node: TSESTree.ClassExpression;
-} | {
-    kind: "FunctionDeclaration";
-    node: TSESTree.FunctionDeclaration;
-} | {
-    kind: "FunctionExpression";
-    node: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
-} | {
-    kind: "JSXElement";
-    node: TSESTree.JSXElement | TSESTree.JSXFragment;
-} | {
-    kind: "NewExpression";
-    node: TSESTree.NewExpression;
-} | {
-    kind: "ObjectExpression";
-    node: TSESTree.ObjectExpression;
-} | {
-    kind: "RegExpLiteral";
-    node: TSESTree.RegExpLiteral;
-};
-/**
- * Detects the construction type of a given node.
- * @param node The node to check.
- * @param initialScope  The initial scope to check for variable declarations.
- * @param hint Optional hint to control the detection behavior.
- * @returns The construction type of the node, or `_` if not found.
- */
-declare function getConstruction(node: TSESTree.Node | _, initialScope: Scope, hint?: bigint): Construction | _;
-
-declare function getVariableDeclaratorId(node: TSESTree.Node | _, prev?: TSESTree.Node): TSESTree.BindingName | TSESTree.Expression | _;
-
-declare function getVariableInitNode(variable: Variable | _, at: number): _ | TSESTree.ClassDeclaration | TSESTree.ClassDeclarationWithName | TSESTree.ClassDeclarationWithOptionalName | TSESTree.Expression | TSESTree.FunctionDeclaration | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName;
-
-declare function getChidScopes(scope: Scope): readonly Scope[];
-
-type LazyValue = {
-    kind: "lazy";
-    node: TSESTree.Node;
-    initialScope: Scope | _;
-} | {
-    kind: "none";
-    node: TSESTree.Node;
-    initialScope: Scope | _;
-} | {
-    kind: "some";
-    node: TSESTree.Node;
-    value: unknown;
-    initialScope: Scope | _;
-};
-declare function toStaticValue(lazyValue: LazyValue): {
-    readonly kind: "none";
-    readonly node: TSESTree.Node;
-    readonly initialScope: Scope | undefined;
-    readonly value?: never;
-} | {
-    readonly kind: "some";
-    readonly node: TSESTree.Node;
-    readonly initialScope: Scope | undefined;
-    readonly value: unknown;
-};
-
-/**
- * Determines whether node value equals to another node value
- * @param a node to compare
- * @param b node to compare
- * @param initialScopes initial scopes of the two nodes
- * @returns `true` if node value equal
- */
-declare function isNodeValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [
-    aScope: Scope,
-    bScope: Scope
-]): boolean;
-
-export { type Construction, ConstructionDetectionHint, type LazyValue, findPropertyInProperties, findVariable, getChidScopes, getConstruction, getVariableDeclaratorId, getVariableInitNode, getVariables, isNodeValueEqual, toStaticValue };

package/dist/index.mjs

@@ -1,256 +0,0 @@
-import { dual, _ } from '@eslint-react/eff';
-import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
-import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import * as ASTUtils from '@typescript-eslint/utils/ast-utils';
-import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
-import * as AST from '@eslint-react/ast';
-
-// src/var-collect.ts
-function getVariableInitNode(variable, at) {
-  if (variable == null) return _;
-  const def = variable.defs.at(at);
-  if (def == null) return _;
-  switch (true) {
-    case (def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration):
-      return def.node;
-    case (def.type === DefinitionType.ClassName && def.node.type === AST_NODE_TYPES.ClassDeclaration):
-      return def.node;
-    case ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)):
-      return def.node.init;
-    default:
-      return _;
-  }
-}
-
-// src/var-collect.ts
-function getVariables(initialScope) {
-  let scope = initialScope;
-  const variables = [...scope.variables];
-  while (scope.type !== ScopeType.global) {
-    scope = scope.upper;
-    variables.push(...scope.variables);
-  }
-  return variables.reverse();
-}
-var findVariable2 = dual(2, (nameOrNode, initialScope) => {
-  if (nameOrNode == null) return _;
-  return ASTUtils.findVariable(initialScope, nameOrNode) ?? _;
-});
-function findPropertyInProperties(name, properties, initialScope, seen = /* @__PURE__ */ new Set()) {
-  return properties.findLast((prop) => {
-    if (prop.type === AST_NODE_TYPES.Property) {
-      return "name" in prop.key && prop.key.name === name;
-    }
-    if (prop.type === AST_NODE_TYPES.SpreadElement) {
-      switch (prop.argument.type) {
-        case AST_NODE_TYPES.Identifier: {
-          if (seen.has(prop.argument.name)) return false;
-          const variable = findVariable2(prop.argument.name, initialScope);
-          const variableNode = getVariableInitNode(variable, 0);
-          if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
-            seen.add(prop.argument.name);
-            return findPropertyInProperties(
-              name,
-              variableNode.properties,
-              initialScope,
-              seen
-            ) != null;
-          }
-          return false;
-        }
-        case AST_NODE_TYPES.ObjectExpression: {
-          return findPropertyInProperties(
-            name,
-            prop.argument.properties,
-            initialScope,
-            seen
-          ) != null;
-        }
-        default:
-          return false;
-      }
-    }
-    return false;
-  });
-}
-var ConstructionDetectionHint = {
-  None: 0n,
-  StrictCallExpression: 1n << 0n
-};
-function getConstruction(node, initialScope, hint = ConstructionDetectionHint.None) {
-  if (node == null) return _;
-  switch (node.type) {
-    case AST_NODE_TYPES.JSXElement:
-    case AST_NODE_TYPES.JSXFragment:
-      return { kind: "JSXElement", node };
-    case AST_NODE_TYPES.ArrayExpression:
-      return { kind: "ArrayExpression", node };
-    case AST_NODE_TYPES.ObjectExpression:
-      return { kind: "ObjectExpression", node };
-    case AST_NODE_TYPES.ClassExpression:
-      return { kind: "ClassExpression", node };
-    case AST_NODE_TYPES.NewExpression:
-      return { kind: "NewExpression", node };
-    case AST_NODE_TYPES.FunctionExpression:
-    case AST_NODE_TYPES.ArrowFunctionExpression:
-      return { kind: "FunctionExpression", node };
-    case AST_NODE_TYPES.CallExpression: {
-      if (hint & ConstructionDetectionHint.StrictCallExpression) {
-        return { kind: "CallExpression", node };
-      }
-      return _;
-    }
-    case AST_NODE_TYPES.MemberExpression: {
-      if (!("object" in node)) return _;
-      return getConstruction(node.object, initialScope, hint);
-    }
-    case AST_NODE_TYPES.AssignmentExpression:
-    case AST_NODE_TYPES.AssignmentPattern: {
-      if (!("right" in node)) return _;
-      return getConstruction(node.right, initialScope, hint);
-    }
-    case AST_NODE_TYPES.LogicalExpression: {
-      const lvc = getConstruction(node.left, initialScope, hint);
-      if (lvc == null) return _;
-      return getConstruction(node.right, initialScope, hint);
-    }
-    case AST_NODE_TYPES.ConditionalExpression: {
-      const cvc = getConstruction(node.consequent, initialScope, hint);
-      if (cvc == null) return _;
-      return getConstruction(node.alternate, initialScope, hint);
-    }
-    case AST_NODE_TYPES.Identifier: {
-      if (!("name" in node) || typeof node.name !== "string") {
-        return _;
-      }
-      const variable = initialScope.set.get(node.name);
-      const variableNode = getVariableInitNode(variable, -1);
-      return getConstruction(variableNode, initialScope, hint);
-    }
-    case AST_NODE_TYPES.Literal: {
-      if ("regex" in node) {
-        return { kind: "RegExpLiteral", node };
-      }
-      return _;
-    }
-    default: {
-      if (!("expression" in node) || typeof node.expression !== "object") {
-        return _;
-      }
-      return getConstruction(node.expression, initialScope, hint);
-    }
-  }
-}
-function getVariableDeclaratorId(node, prev) {
-  if (node == null) return _;
-  switch (true) {
-    case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
-      return node.id;
-    case (node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev):
-      return node.left;
-    case (node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node):
-      return _;
-    default:
-      return getVariableDeclaratorId(node.parent, node);
-  }
-}
-
-// src/var-scope.ts
-function getChidScopes(scope) {
-  const scopes = [scope];
-  for (const childScope of scope.childScopes) {
-    scopes.push(...getChidScopes(childScope));
-  }
-  return scopes;
-}
-function toStaticValue(lazyValue) {
-  const { kind, node, initialScope } = lazyValue;
-  if (kind !== "lazy") {
-    return lazyValue;
-  }
-  const staticValue = initialScope == null ? getStaticValue(node) : getStaticValue(node, initialScope);
-  return staticValue == null ? { kind: "none", node, initialScope } : { kind: "some", node, initialScope, value: staticValue.value };
-}
-var thisBlockTypes = [
-  AST_NODE_TYPES.FunctionDeclaration,
-  AST_NODE_TYPES.FunctionExpression,
-  AST_NODE_TYPES.ClassBody,
-  AST_NODE_TYPES.Program
-];
-function isNodeValueEqual(a, b, initialScopes) {
-  const [aScope, bScope] = initialScopes;
-  switch (true) {
-    case a === b: {
-      return true;
-    }
-    case (a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal): {
-      return a.value === b.value;
-    }
-    case (a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement): {
-      return a.value.cooked === b.value.cooked;
-    }
-    case (a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier): {
-      const aVar = findVariable2(a, aScope);
-      const bVar = findVariable2(b, bScope);
-      const aVarNode = getVariableInitNodeLoose(aVar, 0);
-      const bVarNode = getVariableInitNodeLoose(bVar, 0);
-      const aVarNodeParent = aVarNode?.parent;
-      const bVarNodeParent = bVarNode?.parent;
-      const aDef = aVar?.defs.at(0);
-      const bDef = bVar?.defs.at(0);
-      const aDefParentParent = aDef?.parent?.parent;
-      const bDefParentParent = bDef?.parent?.parent;
-      switch (true) {
-        case (aVarNodeParent?.type === AST_NODE_TYPES.CallExpression && bVarNodeParent?.type === AST_NODE_TYPES.CallExpression && AST.isFunction(aVarNode) && AST.isFunction(bVarNode)): {
-          if (!AST.isNodeEqual(aVarNodeParent.callee, bVarNodeParent.callee)) {
-            return false;
-          }
-          const aParams = aVarNode.params;
-          const bParams = bVarNode.params;
-          const aPos = aParams.findIndex((x) => AST.isNodeEqual(x, a));
-          const bPos = bParams.findIndex((x) => AST.isNodeEqual(x, b));
-          return aPos !== -1 && bPos !== -1 && aPos === bPos;
-        }
-        case (aDefParentParent?.type === AST_NODE_TYPES.ForOfStatement && bDefParentParent?.type === AST_NODE_TYPES.ForOfStatement): {
-          const aLeft = aDefParentParent.left;
-          const bLeft = bDefParentParent.left;
-          if (aLeft.type !== bLeft.type) {
-            return false;
-          }
-          const aRight = aDefParentParent.right;
-          const bRight = bDefParentParent.right;
-          return AST.isNodeEqual(aRight, bRight);
-        }
-        default: {
-          return aVar != null && bVar != null && aVar === bVar;
-        }
-      }
-    }
-    case (a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression): {
-      return AST.isNodeEqual(a.property, b.property) && isNodeValueEqual(a.object, b.object, initialScopes);
-    }
-    case (a.type === AST_NODE_TYPES.ThisExpression && b.type === AST_NODE_TYPES.ThisExpression): {
-      if (aScope.block === bScope.block) {
-        return true;
-      }
-      const aFunction = AST.findParentNode(a, AST.isOneOf(thisBlockTypes));
-      const bFunction = AST.findParentNode(b, AST.isOneOf(thisBlockTypes));
-      return aFunction === bFunction;
-    }
-    default: {
-      const aStatic = toStaticValue({ kind: "lazy", node: a, initialScope: aScope });
-      const bStatic = toStaticValue({ kind: "lazy", node: b, initialScope: bScope });
-      return aStatic.kind !== "none" && bStatic.kind !== "none" && aStatic.value === bStatic.value;
-    }
-  }
-}
-function getVariableInitNodeLoose(variable, at) {
-  if (variable == null) return _;
-  const node = getVariableInitNode(variable, at);
-  if (node != null) return node;
-  const def = variable.defs.at(at);
-  if (def?.type === DefinitionType.Parameter && AST.isFunction(def.node)) return def.node;
-  return _;
-}
-
-export { ConstructionDetectionHint, findPropertyInProperties, findVariable2 as findVariable, getChidScopes, getConstruction, getVariableDeclaratorId, getVariableInitNode, getVariables, isNodeValueEqual, toStaticValue };