@eslint-react/jsx 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -4779,350 +4779,14 @@ function isNil(x){
   return x === undefined || x === null
 }
 
-/**
- * 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$1 = (input)=>typeof input === "string";
-const t$1 = Symbol.for("@ts-pattern/matcher"), e$1 = Symbol.for("@ts-pattern/isVariadic"), n$1 = "@ts-pattern/anonymous-select-key", r$1 = (t)=>Boolean(t && "object" == typeof t), i$1 = (e)=>e && !!e[t$1], s$1 = (n, o, c)=>{
-    if (i$1(n)) {
-        const e = n[t$1](), { matched: r, selections: i } = e.match(o);
-        return r && i && Object.keys(i).forEach((t)=>c(t, i[t])), r;
-    }
-    if (r$1(n)) {
-        if (!r$1(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$1(o) && o[e$1] ? 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$1(t, e[n], c)) && r.every((t, e)=>s$1(t, n[e], c)) && (0 === a.length || s$1(a[0], i, c));
-            }
-            return n.length === o.length && n.every((t, e)=>s$1(t, o[e], c));
-        }
-        return Object.keys(n).every((e)=>{
-            const r = n[e];
-            return (e in o || i$1(a = r) && "optional" === a[t$1]().matcherType) && s$1(r, o[e], c);
-            var a;
-        });
-    }
-    return Object.is(o, n);
-}, o$1 = (e)=>{
-    var n, s, a;
-    return r$1(e) ? i$1(e) ? null != (n = null == (s = (a = e[t$1]()).getSelectionKeys) ? void 0 : s.call(a)) ? n : [] : Array.isArray(e) ? c$1(e, o$1) : c$1(Object.values(e), o$1) : [];
-}, c$1 = (t, e)=>t.reduce((t, n)=>t.concat(e(n)), []);
-function u$1(t) {
-    return Object.assign(t, {
-        optional: ()=>l$1(t),
-        and: (e)=>m$1(t, e),
-        or: (e)=>y$1(t, e),
-        select: (e)=>void 0 === e ? p$1(t) : p$1(e, t)
-    });
-}
-function l$1(e) {
-    return u$1({
-        [t$1]: ()=>({
-                match: (t)=>{
-                    let n = {};
-                    const r = (t, e)=>{
-                        n[t] = e;
-                    };
-                    return void 0 === t ? (o$1(e).forEach((t)=>r(t, void 0)), {
-                        matched: !0,
-                        selections: n
-                    }) : {
-                        matched: s$1(e, t, r),
-                        selections: n
-                    };
-                },
-                getSelectionKeys: ()=>o$1(e),
-                matcherType: "optional"
-            })
-    });
-}
-function m$1(...e) {
-    return u$1({
-        [t$1]: ()=>({
-                match: (t)=>{
-                    let n = {};
-                    const r = (t, e)=>{
-                        n[t] = e;
-                    };
-                    return {
-                        matched: e.every((e)=>s$1(e, t, r)),
-                        selections: n
-                    };
-                },
-                getSelectionKeys: ()=>c$1(e, o$1),
-                matcherType: "and"
-            })
-    });
-}
-function y$1(...e) {
-    return u$1({
-        [t$1]: ()=>({
-                match: (t)=>{
-                    let n = {};
-                    const r = (t, e)=>{
-                        n[t] = e;
-                    };
-                    return c$1(e, o$1).forEach((t)=>r(t, void 0)), {
-                        matched: e.some((e)=>s$1(e, t, r)),
-                        selections: n
-                    };
-                },
-                getSelectionKeys: ()=>c$1(e, o$1),
-                matcherType: "or"
-            })
-    });
-}
-function d$1(e) {
-    return {
-        [t$1]: ()=>({
-                match: (t)=>({
-                        matched: Boolean(e(t))
-                    })
-            })
-    };
-}
-function p$1(...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$1({
-        [t$1]: ()=>({
-                match: (t)=>{
-                    let e = {
-                        [null != r ? r : n$1]: t
-                    };
-                    return {
-                        matched: void 0 === i || s$1(i, t, (t, n)=>{
-                            e[t] = n;
-                        }),
-                        selections: e
-                    };
-                },
-                getSelectionKeys: ()=>[
-                        null != r ? r : n$1
-                    ].concat(void 0 === i ? [] : o$1(i))
-            })
-    });
-}
-function v$1(t) {
-    return "number" == typeof t;
-}
-function b$1(t) {
-    return "string" == typeof t;
-}
-function w$1(t) {
-    return "bigint" == typeof t;
-}
-u$1(d$1(function(t) {
-    return !0;
-}));
-const j$1 = (t)=>Object.assign(u$1(t), {
-        startsWith: (e)=>{
-            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.startsWith(n)))));
-            var n;
-        },
-        endsWith: (e)=>{
-            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.endsWith(n)))));
-            var n;
-        },
-        minLength: (e)=>j$1(m$1(t, ((t)=>d$1((e)=>b$1(e) && e.length >= t))(e))),
-        maxLength: (e)=>j$1(m$1(t, ((t)=>d$1((e)=>b$1(e) && e.length <= t))(e))),
-        includes: (e)=>{
-            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.includes(n)))));
-            var n;
-        },
-        regex: (e)=>{
-            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && Boolean(t.match(n))))));
-            var n;
-        }
-    });
-j$1(d$1(b$1));
-const K$1 = (t)=>Object.assign(u$1(t), {
-        between: (e, n)=>K$1(m$1(t, ((t, e)=>d$1((n)=>v$1(n) && t <= n && e >= n))(e, n))),
-        lt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e < t))(e))),
-        gt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e > t))(e))),
-        lte: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e <= t))(e))),
-        gte: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e >= t))(e))),
-        int: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && Number.isInteger(t)))),
-        finite: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && Number.isFinite(t)))),
-        positive: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t > 0))),
-        negative: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t < 0)))
-    });
-K$1(d$1(v$1));
-const x$1 = (t)=>Object.assign(u$1(t), {
-        between: (e, n)=>x$1(m$1(t, ((t, e)=>d$1((n)=>w$1(n) && t <= n && e >= n))(e, n))),
-        lt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e < t))(e))),
-        gt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e > t))(e))),
-        lte: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e <= t))(e))),
-        gte: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e >= t))(e))),
-        positive: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t > 0))),
-        negative: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t < 0)))
-    });
-x$1(d$1(w$1));
-u$1(d$1(function(t) {
-    return "boolean" == typeof t;
-}));
-u$1(d$1(function(t) {
-    return "symbol" == typeof t;
-}));
-u$1(d$1(function(t) {
-    return null == t;
-}));
-const NodeType = AST_NODE_TYPES;
-const is = ASTUtils.isNodeOfType;
-const isOneOf = ASTUtils.isNodeOfTypes;
-isOneOf([
-    NodeType.ArrowFunctionExpression,
-    NodeType.FunctionDeclaration,
-    NodeType.FunctionExpression
-]);
-isOneOf([
-    NodeType.ArrowFunctionExpression,
-    NodeType.FunctionDeclaration,
-    NodeType.FunctionExpression,
-    NodeType.TSCallSignatureDeclaration,
-    NodeType.TSConstructSignatureDeclaration,
-    NodeType.TSDeclareFunction,
-    NodeType.TSEmptyBodyFunctionExpression,
-    NodeType.TSFunctionType,
-    NodeType.TSMethodSignature
-]);
-isOneOf([
-    NodeType.ClassDeclaration,
-    NodeType.ClassExpression
-]);
-isOneOf([
-    NodeType.DoWhileStatement,
-    NodeType.ForInStatement,
-    NodeType.ForOfStatement,
-    NodeType.ForStatement,
-    NodeType.WhileStatement
-]);
-isOneOf([
-    NodeType.TSArrayType,
-    NodeType.TSTupleType
-]);
-isOneOf([
-    NodeType.PropertyDefinition,
-    NodeType.TSIndexSignature,
-    NodeType.TSParameterProperty,
-    NodeType.TSPropertySignature
-]);
-is(NodeType.JSXElement);
-is(NodeType.JSXFragment);
-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
-]);
-isOneOf([
-    NodeType.ArrayPattern,
-    NodeType.AssignmentPattern,
-    NodeType.ObjectPattern,
-    NodeType.RestElement
-]);
-isOneOf([
-    NodeType.TSInterfaceDeclaration,
-    NodeType.TSTypeAliasDeclaration
-]);
-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
-]);
-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 = effectData_esm.taggedEnum();
-Construction.None();
-[
-    NodeType.JSXElement,
-    NodeType.ArrayExpression,
-    NodeType.ObjectExpression,
-    NodeType.FunctionExpression,
-    NodeType.ArrowFunctionExpression,
-    NodeType.ClassExpression,
-    NodeType.NewExpression,
-    NodeType.CallExpression
-];
 /**
  * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
- */ /**
+ */
+
+/**
  * @type {VisitorKeys}
- */ const KEYS = {
+ */
+const KEYS = {
     ArrayExpression: [
         "elements"
     ],
@@ -5419,187 +5083,232 @@ Construction.None();
         "argument"
     ]
 };
+
 // Types.
 const NODE_TYPES = Object.keys(KEYS);
+
 // Freeze the keys.
-for (const type of NODE_TYPES){
+for (const type of NODE_TYPES) {
     Object.freeze(KEYS[type]);
 }
 Object.freeze(KEYS);
+
 /**
  * @author Toru Nagashima <https://github.com/mysticatea>
  * See LICENSE file in root directory for full license.
- */ /**
+ */
+
+/**
  * @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
- */ // List to ignore keys.
+ */
+
+// List to ignore keys.
 const KEY_BLACKLIST = new Set([
     "parent",
     "leadingComments",
     "trailingComments"
 ]);
+
 /**
  * Check whether a given key should be used or not.
  * @param {string} key The key to check.
  * @returns {boolean} `true` if the key should be used.
- */ function filterKey(key) {
+ */
+function filterKey(key) {
     return !KEY_BLACKLIST.has(key) && key[0] !== "_";
 }
+
 /**
  * Get visitor keys of a given node.
  * @param {object} node The AST node to get keys.
  * @returns {readonly string[]} Visitor keys of the node.
- */ function getKeys(node) {
+ */
+function getKeys(node) {
     return Object.keys(node).filter(filterKey);
 }
+
 /**
  * Get the innermost scope which contains a given location.
  * @param {Scope} initialScope The initial scope to search.
  * @param {Node} node The location to search.
  * @returns {Scope} The innermost scope.
- */ function getInnermostScope(initialScope, node) {
+ */
+function getInnermostScope(initialScope, node) {
     const location = node.range[0];
+
     let scope = initialScope;
     let found = false;
     do {
         found = false;
-        for (const childScope of scope.childScopes){
+        for (const childScope of scope.childScopes) {
             const range = childScope.block.range;
+
             if (range[0] <= location && location < range[1]) {
                 scope = childScope;
                 found = true;
-                break;
+                break
             }
         }
-    }while (found)
-    return scope;
+    } while (found)
+
+    return scope
 }
+
 /**
  * Find the variable of a given name.
  * @param {Scope} initialScope The scope to start finding.
  * @param {string|Node} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.
  * @returns {Variable|null} The found variable or null.
- */ function findVariable(initialScope, nameOrNode) {
+ */
+function findVariable(initialScope, nameOrNode) {
     let name = "";
     let scope = initialScope;
+
     if (typeof nameOrNode === "string") {
         name = nameOrNode;
     } else {
         name = nameOrNode.name;
         scope = getInnermostScope(scope, nameOrNode);
     }
-    while(scope != null){
+
+    while (scope != null) {
         const variable = scope.set.get(name);
         if (variable != null) {
-            return variable;
+            return variable
         }
         scope = scope.upper;
     }
-    return null;
+
+    return null
 }
+
 /**
  * Negate the result of `this` calling.
  * @param {Token} token The token to check.
  * @returns {boolean} `true` if the result of `this(token)` is `false`.
- */ function negate0(token) {
+ */
+function negate0(token) {
     return !this(token) //eslint-disable-line no-invalid-this
-    ;
 }
+
 /**
  * Creates the negate function of the given function.
  * @param {function(Token):boolean} f - The function to negate.
  * @returns {function(Token):boolean} Negated function.
- */ function negate(f) {
-    return negate0.bind(f);
+ */
+function negate(f) {
+    return negate0.bind(f)
 }
+
 /**
  * Checks if the given token is a PunctuatorToken with the given value
  * @param {Token} token - The token to check.
  * @param {string} value - The value to check.
  * @returns {boolean} `true` if the token is a PunctuatorToken with the given value.
- */ function isPunctuatorTokenWithValue(token, value) {
-    return token.type === "Punctuator" && token.value === value;
+ */
+function isPunctuatorTokenWithValue(token, value) {
+    return token.type === "Punctuator" && token.value === value
 }
+
 /**
  * Checks if the given token is an arrow token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is an arrow token.
- */ function isArrowToken(token) {
-    return isPunctuatorTokenWithValue(token, "=>");
+ */
+function isArrowToken(token) {
+    return isPunctuatorTokenWithValue(token, "=>")
 }
+
 /**
  * Checks if the given token is a comma token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a comma token.
- */ function isCommaToken(token) {
-    return isPunctuatorTokenWithValue(token, ",");
+ */
+function isCommaToken(token) {
+    return isPunctuatorTokenWithValue(token, ",")
 }
+
 /**
  * Checks if the given token is a semicolon token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a semicolon token.
- */ function isSemicolonToken(token) {
-    return isPunctuatorTokenWithValue(token, ";");
+ */
+function isSemicolonToken(token) {
+    return isPunctuatorTokenWithValue(token, ";")
 }
+
 /**
  * Checks if the given token is a colon token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a colon token.
- */ function isColonToken(token) {
-    return isPunctuatorTokenWithValue(token, ":");
+ */
+function isColonToken(token) {
+    return isPunctuatorTokenWithValue(token, ":")
 }
+
 /**
  * Checks if the given token is an opening parenthesis token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is an opening parenthesis token.
- */ function isOpeningParenToken(token) {
-    return isPunctuatorTokenWithValue(token, "(");
+ */
+function isOpeningParenToken(token) {
+    return isPunctuatorTokenWithValue(token, "(")
 }
+
 /**
  * Checks if the given token is a closing parenthesis token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a closing parenthesis token.
- */ function isClosingParenToken(token) {
-    return isPunctuatorTokenWithValue(token, ")");
+ */
+function isClosingParenToken(token) {
+    return isPunctuatorTokenWithValue(token, ")")
 }
+
 /**
  * Checks if the given token is an opening square bracket token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is an opening square bracket token.
- */ function isOpeningBracketToken(token) {
-    return isPunctuatorTokenWithValue(token, "[");
+ */
+function isOpeningBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "[")
 }
+
 /**
  * Checks if the given token is a closing square bracket token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a closing square bracket token.
- */ function isClosingBracketToken(token) {
-    return isPunctuatorTokenWithValue(token, "]");
+ */
+function isClosingBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "]")
 }
+
 /**
  * Checks if the given token is an opening brace token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is an opening brace token.
- */ function isOpeningBraceToken(token) {
-    return isPunctuatorTokenWithValue(token, "{");
+ */
+function isOpeningBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "{")
 }
+
 /**
  * Checks if the given token is a closing brace token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a closing brace token.
- */ function isClosingBraceToken(token) {
-    return isPunctuatorTokenWithValue(token, "}");
+ */
+function isClosingBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "}")
 }
+
 /**
  * Checks if the given token is a comment token or not.
  * @param {Token} token - The token to check.
  * @returns {boolean} `true` if the token is a comment token.
- */ function isCommentToken(token) {
-    return [
-        "Block",
-        "Line",
-        "Shebang"
-    ].includes(token.type);
+ */
+function isCommentToken(token) {
+    return ["Block", "Line", "Shebang"].includes(token.type)
 }
+
 negate(isArrowToken);
 negate(isCommaToken);
 negate(isSemicolonToken);
@@ -5611,163 +5320,180 @@ negate(isClosingBracketToken);
 negate(isOpeningBraceToken);
 negate(isClosingBraceToken);
 negate(isCommentToken);
-/* globals globalThis, global, self, window */ const globalObject = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
-const builtinNames = Object.freeze(new Set([
-    "Array",
-    "ArrayBuffer",
-    "BigInt",
-    "BigInt64Array",
-    "BigUint64Array",
-    "Boolean",
-    "DataView",
-    "Date",
-    "decodeURI",
-    "decodeURIComponent",
-    "encodeURI",
-    "encodeURIComponent",
-    "escape",
-    "Float32Array",
-    "Float64Array",
-    "Function",
-    "Infinity",
-    "Int16Array",
-    "Int32Array",
-    "Int8Array",
-    "isFinite",
-    "isNaN",
-    "isPrototypeOf",
-    "JSON",
-    "Map",
-    "Math",
-    "NaN",
-    "Number",
-    "Object",
-    "parseFloat",
-    "parseInt",
-    "Promise",
-    "Proxy",
-    "Reflect",
-    "RegExp",
-    "Set",
-    "String",
-    "Symbol",
-    "Uint16Array",
-    "Uint32Array",
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "undefined",
-    "unescape",
-    "WeakMap",
-    "WeakSet"
-]));
-const callAllowed = new Set([
-    Array.isArray,
-    Array.of,
-    Array.prototype.at,
-    Array.prototype.concat,
-    Array.prototype.entries,
-    Array.prototype.every,
-    Array.prototype.filter,
-    Array.prototype.find,
-    Array.prototype.findIndex,
-    Array.prototype.flat,
-    Array.prototype.includes,
-    Array.prototype.indexOf,
-    Array.prototype.join,
-    Array.prototype.keys,
-    Array.prototype.lastIndexOf,
-    Array.prototype.slice,
-    Array.prototype.some,
-    Array.prototype.toString,
-    Array.prototype.values,
-    typeof BigInt === "function" ? BigInt : undefined,
-    Boolean,
-    Date,
-    Date.parse,
-    decodeURI,
-    decodeURIComponent,
-    encodeURI,
-    encodeURIComponent,
-    escape,
-    isFinite,
-    isNaN,
-    isPrototypeOf,
-    Map,
-    Map.prototype.entries,
-    Map.prototype.get,
-    Map.prototype.has,
-    Map.prototype.keys,
-    Map.prototype.values,
-    ...Object.getOwnPropertyNames(Math).filter((k)=>k !== "random").map((k)=>Math[k]).filter((f)=>typeof f === "function"),
-    Number,
-    Number.isFinite,
-    Number.isNaN,
-    Number.parseFloat,
-    Number.parseInt,
-    Number.prototype.toExponential,
-    Number.prototype.toFixed,
-    Number.prototype.toPrecision,
-    Number.prototype.toString,
-    Object,
-    Object.entries,
-    Object.is,
-    Object.isExtensible,
-    Object.isFrozen,
-    Object.isSealed,
-    Object.keys,
-    Object.values,
-    parseFloat,
-    parseInt,
-    RegExp,
-    Set,
-    Set.prototype.entries,
-    Set.prototype.has,
-    Set.prototype.keys,
-    Set.prototype.values,
-    String,
-    String.fromCharCode,
-    String.fromCodePoint,
-    String.raw,
-    String.prototype.at,
-    String.prototype.charAt,
-    String.prototype.charCodeAt,
-    String.prototype.codePointAt,
-    String.prototype.concat,
-    String.prototype.endsWith,
-    String.prototype.includes,
-    String.prototype.indexOf,
-    String.prototype.lastIndexOf,
-    String.prototype.normalize,
-    String.prototype.padEnd,
-    String.prototype.padStart,
-    String.prototype.slice,
-    String.prototype.startsWith,
-    String.prototype.substr,
-    String.prototype.substring,
-    String.prototype.toLowerCase,
-    String.prototype.toString,
-    String.prototype.toUpperCase,
-    String.prototype.trim,
-    String.prototype.trimEnd,
-    String.prototype.trimLeft,
-    String.prototype.trimRight,
-    String.prototype.trimStart,
-    Symbol.for,
-    Symbol.keyFor,
-    unescape
-].filter((f)=>typeof f === "function"));
+
+/* globals globalThis, global, self, window */
+
+const globalObject =
+    typeof globalThis !== "undefined"
+        ? globalThis
+        : typeof self !== "undefined"
+        ? self
+        : typeof window !== "undefined"
+        ? window
+        : typeof global !== "undefined"
+        ? global
+        : {};
+
+const builtinNames = Object.freeze(
+    new Set([
+        "Array",
+        "ArrayBuffer",
+        "BigInt",
+        "BigInt64Array",
+        "BigUint64Array",
+        "Boolean",
+        "DataView",
+        "Date",
+        "decodeURI",
+        "decodeURIComponent",
+        "encodeURI",
+        "encodeURIComponent",
+        "escape",
+        "Float32Array",
+        "Float64Array",
+        "Function",
+        "Infinity",
+        "Int16Array",
+        "Int32Array",
+        "Int8Array",
+        "isFinite",
+        "isNaN",
+        "isPrototypeOf",
+        "JSON",
+        "Map",
+        "Math",
+        "NaN",
+        "Number",
+        "Object",
+        "parseFloat",
+        "parseInt",
+        "Promise",
+        "Proxy",
+        "Reflect",
+        "RegExp",
+        "Set",
+        "String",
+        "Symbol",
+        "Uint16Array",
+        "Uint32Array",
+        "Uint8Array",
+        "Uint8ClampedArray",
+        "undefined",
+        "unescape",
+        "WeakMap",
+        "WeakSet",
+    ]),
+);
+const callAllowed = new Set(
+    [
+        Array.isArray,
+        Array.of,
+        Array.prototype.at,
+        Array.prototype.concat,
+        Array.prototype.entries,
+        Array.prototype.every,
+        Array.prototype.filter,
+        Array.prototype.find,
+        Array.prototype.findIndex,
+        Array.prototype.flat,
+        Array.prototype.includes,
+        Array.prototype.indexOf,
+        Array.prototype.join,
+        Array.prototype.keys,
+        Array.prototype.lastIndexOf,
+        Array.prototype.slice,
+        Array.prototype.some,
+        Array.prototype.toString,
+        Array.prototype.values,
+        typeof BigInt === "function" ? BigInt : undefined,
+        Boolean,
+        Date,
+        Date.parse,
+        decodeURI,
+        decodeURIComponent,
+        encodeURI,
+        encodeURIComponent,
+        escape,
+        isFinite,
+        isNaN,
+        isPrototypeOf,
+        Map,
+        Map.prototype.entries,
+        Map.prototype.get,
+        Map.prototype.has,
+        Map.prototype.keys,
+        Map.prototype.values,
+        ...Object.getOwnPropertyNames(Math)
+            .filter((k) => k !== "random")
+            .map((k) => Math[k])
+            .filter((f) => typeof f === "function"),
+        Number,
+        Number.isFinite,
+        Number.isNaN,
+        Number.parseFloat,
+        Number.parseInt,
+        Number.prototype.toExponential,
+        Number.prototype.toFixed,
+        Number.prototype.toPrecision,
+        Number.prototype.toString,
+        Object,
+        Object.entries,
+        Object.is,
+        Object.isExtensible,
+        Object.isFrozen,
+        Object.isSealed,
+        Object.keys,
+        Object.values,
+        parseFloat,
+        parseInt,
+        RegExp,
+        Set,
+        Set.prototype.entries,
+        Set.prototype.has,
+        Set.prototype.keys,
+        Set.prototype.values,
+        String,
+        String.fromCharCode,
+        String.fromCodePoint,
+        String.raw,
+        String.prototype.at,
+        String.prototype.charAt,
+        String.prototype.charCodeAt,
+        String.prototype.codePointAt,
+        String.prototype.concat,
+        String.prototype.endsWith,
+        String.prototype.includes,
+        String.prototype.indexOf,
+        String.prototype.lastIndexOf,
+        String.prototype.normalize,
+        String.prototype.padEnd,
+        String.prototype.padStart,
+        String.prototype.slice,
+        String.prototype.startsWith,
+        String.prototype.substr,
+        String.prototype.substring,
+        String.prototype.toLowerCase,
+        String.prototype.toString,
+        String.prototype.toUpperCase,
+        String.prototype.trim,
+        String.prototype.trimEnd,
+        String.prototype.trimLeft,
+        String.prototype.trimRight,
+        String.prototype.trimStart,
+        Symbol.for,
+        Symbol.keyFor,
+        unescape,
+    ].filter((f) => typeof f === "function"),
+);
 const callPassThrough = new Set([
     Object.freeze,
     Object.preventExtensions,
-    Object.seal
+    Object.seal,
 ]);
-/** @type {ReadonlyArray<readonly [Function, ReadonlySet<string>]>} */ const getterAllowed = [
-    [
-        Map,
-        new Set([
-            "size"
-        ])
-    ],
+
+/** @type {ReadonlyArray<readonly [Function, ReadonlySet<string>]>} */
+const getterAllowed = [
+    [Map, new Set(["size"])],
     [
         RegExp,
         new Set([
@@ -5779,218 +5505,190 @@ const callPassThrough = new Set([
             "multiline",
             "source",
             "sticky",
-            "unicode"
-        ])
+            "unicode",
+        ]),
     ],
-    [
-        Set,
-        new Set([
-            "size"
-        ])
-    ]
+    [Set, new Set(["size"])],
 ];
+
 /**
  * Get the property descriptor.
  * @param {object} object The object to get.
  * @param {string|number|symbol} name The property name to get.
- */ function getPropertyDescriptor(object, name) {
+ */
+function getPropertyDescriptor(object, name) {
     let x = object;
-    while((typeof x === "object" || typeof x === "function") && x !== null){
+    while ((typeof x === "object" || typeof x === "function") && x !== null) {
         const d = Object.getOwnPropertyDescriptor(x, name);
         if (d) {
-            return d;
+            return d
         }
         x = Object.getPrototypeOf(x);
     }
-    return null;
+    return null
 }
+
 /**
  * Check if a property is getter or not.
  * @param {object} object The object to check.
  * @param {string|number|symbol} name The property name to check.
- */ function isGetter(object, name) {
+ */
+function isGetter(object, name) {
     const d = getPropertyDescriptor(object, name);
-    return d != null && d.get != null;
+    return d != null && d.get != null
 }
+
 /**
  * Get the element values of a given node list.
  * @param {Node[]} nodeList The node list to get values.
  * @param {Scope|undefined} initialScope The initial scope to find variables.
  * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.
- */ function getElementValues(nodeList, initialScope) {
+ */
+function getElementValues(nodeList, initialScope) {
     const valueList = [];
-    for(let i = 0; i < nodeList.length; ++i){
+
+    for (let i = 0; i < nodeList.length; ++i) {
         const elementNode = nodeList[i];
+
         if (elementNode == null) {
             valueList.length = i + 1;
         } else if (elementNode.type === "SpreadElement") {
             const argument = getStaticValueR(elementNode.argument, initialScope);
             if (argument == null) {
-                return null;
+                return null
             }
             valueList.push(...argument.value);
         } else {
             const element = getStaticValueR(elementNode, initialScope);
             if (element == null) {
-                return null;
+                return null
             }
             valueList.push(element.value);
         }
     }
-    return valueList;
+
+    return valueList
 }
+
 /**
  * Returns whether the given variable is never written to after initialization.
  * @param {import("eslint").Scope.Variable} variable
  * @returns {boolean}
- */ function isEffectivelyConst(variable) {
+ */
+function isEffectivelyConst(variable) {
     const refs = variable.references;
-    const inits = refs.filter((r)=>r.init).length;
-    const reads = refs.filter((r)=>r.isReadOnly()).length;
+
+    const inits = refs.filter((r) => r.init).length;
+    const reads = refs.filter((r) => r.isReadOnly()).length;
     if (inits === 1 && reads + inits === refs.length) {
         // there is only one init and all other references only read
-        return true;
+        return true
     }
-    return false;
+    return false
 }
+
 const operations = Object.freeze({
-    ArrayExpression (node, initialScope) {
+    ArrayExpression(node, initialScope) {
         const elements = getElementValues(node.elements, initialScope);
-        return elements != null ? {
-            value: elements
-        } : null;
+        return elements != null ? { value: elements } : null
     },
-    AssignmentExpression (node, initialScope) {
+
+    AssignmentExpression(node, initialScope) {
         if (node.operator === "=") {
-            return getStaticValueR(node.right, initialScope);
+            return getStaticValueR(node.right, initialScope)
         }
-        return null;
+        return null
     },
+
     //eslint-disable-next-line complexity
-    BinaryExpression (node, initialScope) {
+    BinaryExpression(node, initialScope) {
         if (node.operator === "in" || node.operator === "instanceof") {
             // Not supported.
-            return null;
+            return null
         }
+
         const left = getStaticValueR(node.left, initialScope);
         const right = getStaticValueR(node.right, initialScope);
         if (left != null && right != null) {
-            switch(node.operator){
+            switch (node.operator) {
                 case "==":
-                    return {
-                        value: left.value == right.value
-                    } //eslint-disable-line eqeqeq
-                    ;
+                    return { value: left.value == right.value } //eslint-disable-line eqeqeq
                 case "!=":
-                    return {
-                        value: left.value != right.value
-                    } //eslint-disable-line eqeqeq
-                    ;
+                    return { value: left.value != right.value } //eslint-disable-line eqeqeq
                 case "===":
-                    return {
-                        value: left.value === right.value
-                    };
+                    return { value: left.value === right.value }
                 case "!==":
-                    return {
-                        value: left.value !== right.value
-                    };
+                    return { value: left.value !== right.value }
                 case "<":
-                    return {
-                        value: left.value < right.value
-                    };
+                    return { value: left.value < right.value }
                 case "<=":
-                    return {
-                        value: left.value <= right.value
-                    };
+                    return { value: left.value <= right.value }
                 case ">":
-                    return {
-                        value: left.value > right.value
-                    };
+                    return { value: left.value > right.value }
                 case ">=":
-                    return {
-                        value: left.value >= right.value
-                    };
+                    return { value: left.value >= right.value }
                 case "<<":
-                    return {
-                        value: left.value << right.value
-                    };
+                    return { value: left.value << right.value }
                 case ">>":
-                    return {
-                        value: left.value >> right.value
-                    };
+                    return { value: left.value >> right.value }
                 case ">>>":
-                    return {
-                        value: left.value >>> right.value
-                    };
+                    return { value: left.value >>> right.value }
                 case "+":
-                    return {
-                        value: left.value + right.value
-                    };
+                    return { value: left.value + right.value }
                 case "-":
-                    return {
-                        value: left.value - right.value
-                    };
+                    return { value: left.value - right.value }
                 case "*":
-                    return {
-                        value: left.value * right.value
-                    };
+                    return { value: left.value * right.value }
                 case "/":
-                    return {
-                        value: left.value / right.value
-                    };
+                    return { value: left.value / right.value }
                 case "%":
-                    return {
-                        value: left.value % right.value
-                    };
+                    return { value: left.value % right.value }
                 case "**":
-                    return {
-                        value: left.value ** right.value
-                    };
+                    return { value: left.value ** right.value }
                 case "|":
-                    return {
-                        value: left.value | right.value
-                    };
+                    return { value: left.value | right.value }
                 case "^":
-                    return {
-                        value: left.value ^ right.value
-                    };
+                    return { value: left.value ^ right.value }
                 case "&":
-                    return {
-                        value: left.value & right.value
-                    };
+                    return { value: left.value & right.value }
+
+                // no default
             }
         }
-        return null;
+
+        return null
     },
-    CallExpression (node, initialScope) {
+
+    CallExpression(node, initialScope) {
         const calleeNode = node.callee;
         const args = getElementValues(node.arguments, initialScope);
+
         if (args != null) {
             if (calleeNode.type === "MemberExpression") {
                 if (calleeNode.property.type === "PrivateIdentifier") {
-                    return null;
+                    return null
                 }
                 const object = getStaticValueR(calleeNode.object, initialScope);
                 if (object != null) {
-                    if (object.value == null && (object.optional || node.optional)) {
-                        return {
-                            value: undefined,
-                            optional: true
-                        };
+                    if (
+                        object.value == null &&
+                        (object.optional || node.optional)
+                    ) {
+                        return { value: undefined, optional: true }
                     }
-                    const property = getStaticPropertyNameValue(calleeNode, initialScope);
+                    const property = getStaticPropertyNameValue(
+                        calleeNode,
+                        initialScope,
+                    );
+
                     if (property != null) {
                         const receiver = object.value;
                         const methodName = property.value;
                         if (callAllowed.has(receiver[methodName])) {
-                            return {
-                                value: receiver[methodName](...args)
-                            };
+                            return { value: receiver[methodName](...args) }
                         }
                         if (callPassThrough.has(receiver[methodName])) {
-                            return {
-                                value: args[0]
-                            };
+                            return { value: args[0] }
                         }
                     }
                 }
@@ -5998,409 +5696,815 @@ const operations = Object.freeze({
                 const callee = getStaticValueR(calleeNode, initialScope);
                 if (callee != null) {
                     if (callee.value == null && node.optional) {
-                        return {
-                            value: undefined,
-                            optional: true
-                        };
+                        return { value: undefined, optional: true }
                     }
                     const func = callee.value;
                     if (callAllowed.has(func)) {
-                        return {
-                            value: func(...args)
-                        };
+                        return { value: func(...args) }
                     }
                     if (callPassThrough.has(func)) {
-                        return {
-                            value: args[0]
-                        };
+                        return { value: args[0] }
                     }
                 }
             }
         }
-        return null;
+
+        return null
     },
-    ConditionalExpression (node, initialScope) {
+
+    ConditionalExpression(node, initialScope) {
         const test = getStaticValueR(node.test, initialScope);
         if (test != null) {
-            return test.value ? getStaticValueR(node.consequent, initialScope) : getStaticValueR(node.alternate, initialScope);
+            return test.value
+                ? getStaticValueR(node.consequent, initialScope)
+                : getStaticValueR(node.alternate, initialScope)
         }
-        return null;
+        return null
     },
-    ExpressionStatement (node, initialScope) {
-        return getStaticValueR(node.expression, initialScope);
+
+    ExpressionStatement(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
     },
-    Identifier (node, initialScope) {
+
+    Identifier(node, initialScope) {
         if (initialScope != null) {
             const variable = findVariable(initialScope, node);
+
             // Built-in globals.
-            if (variable != null && variable.defs.length === 0 && builtinNames.has(variable.name) && variable.name in globalObject) {
-                return {
-                    value: globalObject[variable.name]
-                };
+            if (
+                variable != null &&
+                variable.defs.length === 0 &&
+                builtinNames.has(variable.name) &&
+                variable.name in globalObject
+            ) {
+                return { value: globalObject[variable.name] }
             }
+
             // Constants.
             if (variable != null && variable.defs.length === 1) {
                 const def = variable.defs[0];
-                if (def.parent && def.type === "Variable" && (def.parent.kind === "const" || isEffectivelyConst(variable)) && // TODO(mysticatea): don't support destructuring here.
-                def.node.id.type === "Identifier") {
-                    return getStaticValueR(def.node.init, initialScope);
+                if (
+                    def.parent &&
+                    def.type === "Variable" &&
+                    (def.parent.kind === "const" ||
+                        isEffectivelyConst(variable)) &&
+                    // TODO(mysticatea): don't support destructuring here.
+                    def.node.id.type === "Identifier"
+                ) {
+                    return getStaticValueR(def.node.init, initialScope)
                 }
             }
         }
-        return null;
+        return null
     },
-    Literal (node) {
+
+    Literal(node) {
         //istanbul ignore if : this is implementation-specific behavior.
         if ((node.regex != null || node.bigint != null) && node.value == null) {
             // It was a RegExp/BigInt literal, but Node.js didn't support it.
-            return null;
+            return null
         }
-        return {
-            value: node.value
-        };
+        return { value: node.value }
     },
-    LogicalExpression (node, initialScope) {
+
+    LogicalExpression(node, initialScope) {
         const left = getStaticValueR(node.left, initialScope);
         if (left != null) {
-            if (node.operator === "||" && Boolean(left.value) === true || node.operator === "&&" && Boolean(left.value) === false || node.operator === "??" && left.value != null) {
-                return left;
+            if (
+                (node.operator === "||" && Boolean(left.value) === true) ||
+                (node.operator === "&&" && Boolean(left.value) === false) ||
+                (node.operator === "??" && left.value != null)
+            ) {
+                return left
             }
+
             const right = getStaticValueR(node.right, initialScope);
             if (right != null) {
-                return right;
+                return right
             }
         }
-        return null;
+
+        return null
     },
-    MemberExpression (node, initialScope) {
+
+    MemberExpression(node, initialScope) {
         if (node.property.type === "PrivateIdentifier") {
-            return null;
+            return null
         }
         const object = getStaticValueR(node.object, initialScope);
         if (object != null) {
             if (object.value == null && (object.optional || node.optional)) {
-                return {
-                    value: undefined,
-                    optional: true
-                };
+                return { value: undefined, optional: true }
             }
             const property = getStaticPropertyNameValue(node, initialScope);
+
             if (property != null) {
                 if (!isGetter(object.value, property.value)) {
-                    return {
-                        value: object.value[property.value]
-                    };
+                    return { value: object.value[property.value] }
                 }
-                for (const [classFn, allowed] of getterAllowed){
-                    if (object.value instanceof classFn && allowed.has(property.value)) {
-                        return {
-                            value: object.value[property.value]
-                        };
+
+                for (const [classFn, allowed] of getterAllowed) {
+                    if (
+                        object.value instanceof classFn &&
+                        allowed.has(property.value)
+                    ) {
+                        return { value: object.value[property.value] }
                     }
                 }
             }
         }
-        return null;
+        return null
     },
-    ChainExpression (node, initialScope) {
+
+    ChainExpression(node, initialScope) {
         const expression = getStaticValueR(node.expression, initialScope);
         if (expression != null) {
-            return {
-                value: expression.value
-            };
+            return { value: expression.value }
         }
-        return null;
+        return null
     },
-    NewExpression (node, initialScope) {
+
+    NewExpression(node, initialScope) {
         const callee = getStaticValueR(node.callee, initialScope);
         const args = getElementValues(node.arguments, initialScope);
+
         if (callee != null && args != null) {
             const Func = callee.value;
             if (callAllowed.has(Func)) {
-                return {
-                    value: new Func(...args)
-                };
+                return { value: new Func(...args) }
             }
         }
-        return null;
+
+        return null
     },
-    ObjectExpression (node, initialScope) {
+
+    ObjectExpression(node, initialScope) {
         const object = {};
-        for (const propertyNode of node.properties){
+
+        for (const propertyNode of node.properties) {
             if (propertyNode.type === "Property") {
                 if (propertyNode.kind !== "init") {
-                    return null;
+                    return null
                 }
-                const key = getStaticPropertyNameValue(propertyNode, initialScope);
+                const key = getStaticPropertyNameValue(
+                    propertyNode,
+                    initialScope,
+                );
                 const value = getStaticValueR(propertyNode.value, initialScope);
                 if (key == null || value == null) {
-                    return null;
+                    return null
                 }
                 object[key.value] = value.value;
-            } else if (propertyNode.type === "SpreadElement" || propertyNode.type === "ExperimentalSpreadProperty") {
-                const argument = getStaticValueR(propertyNode.argument, initialScope);
+            } else if (
+                propertyNode.type === "SpreadElement" ||
+                propertyNode.type === "ExperimentalSpreadProperty"
+            ) {
+                const argument = getStaticValueR(
+                    propertyNode.argument,
+                    initialScope,
+                );
                 if (argument == null) {
-                    return null;
+                    return null
                 }
                 Object.assign(object, argument.value);
             } else {
-                return null;
+                return null
             }
         }
-        return {
-            value: object
-        };
+
+        return { value: object }
     },
-    SequenceExpression (node, initialScope) {
+
+    SequenceExpression(node, initialScope) {
         const last = node.expressions[node.expressions.length - 1];
-        return getStaticValueR(last, initialScope);
+        return getStaticValueR(last, initialScope)
     },
-    TaggedTemplateExpression (node, initialScope) {
+
+    TaggedTemplateExpression(node, initialScope) {
         const tag = getStaticValueR(node.tag, initialScope);
-        const expressions = getElementValues(node.quasi.expressions, initialScope);
+        const expressions = getElementValues(
+            node.quasi.expressions,
+            initialScope,
+        );
+
         if (tag != null && expressions != null) {
             const func = tag.value;
-            const strings = node.quasi.quasis.map((q)=>q.value.cooked);
-            strings.raw = node.quasi.quasis.map((q)=>q.value.raw);
+            const strings = node.quasi.quasis.map((q) => q.value.cooked);
+            strings.raw = node.quasi.quasis.map((q) => q.value.raw);
+
             if (func === String.raw) {
-                return {
-                    value: func(strings, ...expressions)
-                };
+                return { value: func(strings, ...expressions) }
             }
         }
-        return null;
+
+        return null
     },
-    TemplateLiteral (node, initialScope) {
+
+    TemplateLiteral(node, initialScope) {
         const expressions = getElementValues(node.expressions, initialScope);
         if (expressions != null) {
             let value = node.quasis[0].value.cooked;
-            for(let i = 0; i < expressions.length; ++i){
+            for (let i = 0; i < expressions.length; ++i) {
                 value += expressions[i];
                 value += node.quasis[i + 1].value.cooked;
             }
-            return {
-                value
-            };
+            return { value }
         }
-        return null;
+        return null
     },
-    UnaryExpression (node, initialScope) {
+
+    UnaryExpression(node, initialScope) {
         if (node.operator === "delete") {
             // Not supported.
-            return null;
+            return null
         }
         if (node.operator === "void") {
-            return {
-                value: undefined
-            };
+            return { value: undefined }
         }
+
         const arg = getStaticValueR(node.argument, initialScope);
         if (arg != null) {
-            switch(node.operator){
+            switch (node.operator) {
                 case "-":
-                    return {
-                        value: -arg.value
-                    };
+                    return { value: -arg.value }
                 case "+":
-                    return {
-                        value: +arg.value
-                    } //eslint-disable-line no-implicit-coercion
-                    ;
+                    return { value: +arg.value } //eslint-disable-line no-implicit-coercion
                 case "!":
-                    return {
-                        value: !arg.value
-                    };
+                    return { value: !arg.value }
                 case "~":
-                    return {
-                        value: ~arg.value
-                    };
+                    return { value: ~arg.value }
                 case "typeof":
-                    return {
-                        value: typeof arg.value
-                    };
+                    return { value: typeof arg.value }
+
+                // no default
             }
         }
-        return null;
-    }
+
+        return null
+    },
 });
+
 /**
  * Get the value of a given node if it's a static value.
  * @param {Node} node The node to get.
  * @param {Scope|undefined} initialScope The scope to start finding variable.
  * @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the node, or `null`.
- */ function getStaticValueR(node, initialScope) {
+ */
+function getStaticValueR(node, initialScope) {
     if (node != null && Object.hasOwnProperty.call(operations, node.type)) {
-        return operations[node.type](node, initialScope);
+        return operations[node.type](node, initialScope)
     }
-    return null;
+    return null
 }
+
 /**
  * Get the static value of property name from a MemberExpression node or a Property node.
  * @param {Node} node The node to get.
  * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.
  * @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the property name of the node, or `null`.
- */ function getStaticPropertyNameValue(node, initialScope) {
+ */
+function getStaticPropertyNameValue(node, initialScope) {
     const nameNode = node.type === "Property" ? node.key : node.property;
+
     if (node.computed) {
-        return getStaticValueR(nameNode, initialScope);
+        return getStaticValueR(nameNode, initialScope)
     }
+
     if (nameNode.type === "Identifier") {
-        return {
-            value: nameNode.name
-        };
+        return { value: nameNode.name }
     }
+
     if (nameNode.type === "Literal") {
         if (nameNode.bigint) {
-            return {
-                value: nameNode.bigint
-            };
+            return { value: nameNode.bigint }
         }
-        return {
-            value: String(nameNode.value)
-        };
+        return { value: String(nameNode.value) }
+    }
+
+    return null
+}
+
+/**
+ * Get the value of a given node if it's a static value.
+ * @param {Node} node The node to get.
+ * @param {Scope} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.
+ * @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the node, or `null`.
+ */
+function getStaticValue$1(node, initialScope = null) {
+    try {
+        return getStaticValueR(node, initialScope)
+    } catch (_error) {
+        return null
+    }
+}
+
+const typeConversionBinaryOps = Object.freeze(
+    new Set([
+        "==",
+        "!=",
+        "<",
+        "<=",
+        ">",
+        ">=",
+        "<<",
+        ">>",
+        ">>>",
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "|",
+        "^",
+        "&",
+        "in",
+    ]),
+);
+const typeConversionUnaryOps = Object.freeze(new Set(["-", "+", "!", "~"]));
+
+/**
+ * Check whether the given value is an ASTNode or not.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is an ASTNode.
+ */
+function isNode(x) {
+    return x !== null && typeof x === "object" && typeof x.type === "string"
+}
+
+Object.freeze(
+    Object.assign(Object.create(null), {
+        $visit(node, options, visitorKeys) {
+            const { type } = node;
+
+            if (typeof this[type] === "function") {
+                return this[type](node, options, visitorKeys)
+            }
+
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+
+        $visitChildren(node, options, visitorKeys) {
+            const { type } = node;
+
+            for (const key of visitorKeys[type] || getKeys(node)) {
+                const value = node[key];
+
+                if (Array.isArray(value)) {
+                    for (const element of value) {
+                        if (
+                            isNode(element) &&
+                            this.$visit(element, options, visitorKeys)
+                        ) {
+                            return true
+                        }
+                    }
+                } else if (
+                    isNode(value) &&
+                    this.$visit(value, options, visitorKeys)
+                ) {
+                    return true
+                }
+            }
+
+            return false
+        },
+
+        ArrowFunctionExpression() {
+            return false
+        },
+        AssignmentExpression() {
+            return true
+        },
+        AwaitExpression() {
+            return true
+        },
+        BinaryExpression(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                typeConversionBinaryOps.has(node.operator) &&
+                (node.left.type !== "Literal" || node.right.type !== "Literal")
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        CallExpression() {
+            return true
+        },
+        FunctionExpression() {
+            return false
+        },
+        ImportExpression() {
+            return true
+        },
+        MemberExpression(node, options, visitorKeys) {
+            if (options.considerGetters) {
+                return true
+            }
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.property.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        MethodDefinition(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        NewExpression() {
+            return true
+        },
+        Property(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        PropertyDefinition(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        UnaryExpression(node, options, visitorKeys) {
+            if (node.operator === "delete") {
+                return true
+            }
+            if (
+                options.considerImplicitTypeConversion &&
+                typeConversionUnaryOps.has(node.operator) &&
+                node.argument.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        UpdateExpression() {
+            return true
+        },
+        YieldExpression() {
+            return true
+        },
+    }),
+);
+Function.call.bind(Object.hasOwnProperty);
+
+/**
+ * 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$1 = (input)=>typeof input === "string";
+const t$1 = Symbol.for("@ts-pattern/matcher"), e$1 = Symbol.for("@ts-pattern/isVariadic"), n$1 = "@ts-pattern/anonymous-select-key", r$1 = (t)=>Boolean(t && "object" == typeof t), i$1 = (e)=>e && !!e[t$1], s$1 = (n, o, c)=>{
+    if (i$1(n)) {
+        const e = n[t$1](), { matched: r, selections: i } = e.match(o);
+        return r && i && Object.keys(i).forEach((t)=>c(t, i[t])), r;
+    }
+    if (r$1(n)) {
+        if (!r$1(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$1(o) && o[e$1] ? 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$1(t, e[n], c)) && r.every((t, e)=>s$1(t, n[e], c)) && (0 === a.length || s$1(a[0], i, c));
+            }
+            return n.length === o.length && n.every((t, e)=>s$1(t, o[e], c));
+        }
+        return Object.keys(n).every((e)=>{
+            const r = n[e];
+            return (e in o || i$1(a = r) && "optional" === a[t$1]().matcherType) && s$1(r, o[e], c);
+            var a;
+        });
     }
-    return null;
+    return Object.is(o, n);
+}, o$1 = (e)=>{
+    var n, s, a;
+    return r$1(e) ? i$1(e) ? null != (n = null == (s = (a = e[t$1]()).getSelectionKeys) ? void 0 : s.call(a)) ? n : [] : Array.isArray(e) ? c$1(e, o$1) : c$1(Object.values(e), o$1) : [];
+}, c$1 = (t, e)=>t.reduce((t, n)=>t.concat(e(n)), []);
+function u$1(t) {
+    return Object.assign(t, {
+        optional: ()=>l$1(t),
+        and: (e)=>m$1(t, e),
+        or: (e)=>y$1(t, e),
+        select: (e)=>void 0 === e ? p$1(t) : p$1(e, t)
+    });
+}
+function l$1(e) {
+    return u$1({
+        [t$1]: ()=>({
+                match: (t)=>{
+                    let n = {};
+                    const r = (t, e)=>{
+                        n[t] = e;
+                    };
+                    return void 0 === t ? (o$1(e).forEach((t)=>r(t, void 0)), {
+                        matched: !0,
+                        selections: n
+                    }) : {
+                        matched: s$1(e, t, r),
+                        selections: n
+                    };
+                },
+                getSelectionKeys: ()=>o$1(e),
+                matcherType: "optional"
+            })
+    });
+}
+function m$1(...e) {
+    return u$1({
+        [t$1]: ()=>({
+                match: (t)=>{
+                    let n = {};
+                    const r = (t, e)=>{
+                        n[t] = e;
+                    };
+                    return {
+                        matched: e.every((e)=>s$1(e, t, r)),
+                        selections: n
+                    };
+                },
+                getSelectionKeys: ()=>c$1(e, o$1),
+                matcherType: "and"
+            })
+    });
+}
+function y$1(...e) {
+    return u$1({
+        [t$1]: ()=>({
+                match: (t)=>{
+                    let n = {};
+                    const r = (t, e)=>{
+                        n[t] = e;
+                    };
+                    return c$1(e, o$1).forEach((t)=>r(t, void 0)), {
+                        matched: e.some((e)=>s$1(e, t, r)),
+                        selections: n
+                    };
+                },
+                getSelectionKeys: ()=>c$1(e, o$1),
+                matcherType: "or"
+            })
+    });
+}
+function d$1(e) {
+    return {
+        [t$1]: ()=>({
+                match: (t)=>({
+                        matched: Boolean(e(t))
+                    })
+            })
+    };
+}
+function p$1(...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$1({
+        [t$1]: ()=>({
+                match: (t)=>{
+                    let e = {
+                        [null != r ? r : n$1]: t
+                    };
+                    return {
+                        matched: void 0 === i || s$1(i, t, (t, n)=>{
+                            e[t] = n;
+                        }),
+                        selections: e
+                    };
+                },
+                getSelectionKeys: ()=>[
+                        null != r ? r : n$1
+                    ].concat(void 0 === i ? [] : o$1(i))
+            })
+    });
 }
-/**
- * Get the value of a given node if it's a static value.
- * @param {Node} node The node to get.
- * @param {Scope} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.
- * @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the node, or `null`.
- */ function getStaticValue$1(node, initialScope = null) {
-    try {
-        return getStaticValueR(node, initialScope);
-    } catch (_error) {
-        return null;
-    }
+function v$1(t) {
+    return "number" == typeof t;
 }
-const typeConversionBinaryOps = Object.freeze(new Set([
-    "==",
-    "!=",
-    "<",
-    "<=",
-    ">",
-    ">=",
-    "<<",
-    ">>",
-    ">>>",
-    "+",
-    "-",
-    "*",
-    "/",
-    "%",
-    "|",
-    "^",
-    "&",
-    "in"
-]));
-const typeConversionUnaryOps = Object.freeze(new Set([
-    "-",
-    "+",
-    "!",
-    "~"
-]));
-/**
- * Check whether the given value is an ASTNode or not.
- * @param {any} x The value to check.
- * @returns {boolean} `true` if the value is an ASTNode.
- */ function isNode(x) {
-    return x !== null && typeof x === "object" && typeof x.type === "string";
+function b$1(t) {
+    return "string" == typeof t;
 }
-Object.freeze(Object.assign(Object.create(null), {
-    $visit (node, options, visitorKeys) {
-        const { type } = node;
-        if (typeof this[type] === "function") {
-            return this[type](node, options, visitorKeys);
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    $visitChildren (node, options, visitorKeys) {
-        const { type } = node;
-        for (const key of visitorKeys[type] || getKeys(node)){
-            const value = node[key];
-            if (Array.isArray(value)) {
-                for (const element of value){
-                    if (isNode(element) && this.$visit(element, options, visitorKeys)) {
-                        return true;
-                    }
-                }
-            } else if (isNode(value) && this.$visit(value, options, visitorKeys)) {
-                return true;
-            }
-        }
-        return false;
-    },
-    ArrowFunctionExpression () {
-        return false;
-    },
-    AssignmentExpression () {
-        return true;
-    },
-    AwaitExpression () {
-        return true;
-    },
-    BinaryExpression (node, options, visitorKeys) {
-        if (options.considerImplicitTypeConversion && typeConversionBinaryOps.has(node.operator) && (node.left.type !== "Literal" || node.right.type !== "Literal")) {
-            return true;
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    CallExpression () {
-        return true;
-    },
-    FunctionExpression () {
-        return false;
-    },
-    ImportExpression () {
-        return true;
-    },
-    MemberExpression (node, options, visitorKeys) {
-        if (options.considerGetters) {
-            return true;
-        }
-        if (options.considerImplicitTypeConversion && node.computed && node.property.type !== "Literal") {
-            return true;
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    MethodDefinition (node, options, visitorKeys) {
-        if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") {
-            return true;
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    NewExpression () {
-        return true;
-    },
-    Property (node, options, visitorKeys) {
-        if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") {
-            return true;
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    PropertyDefinition (node, options, visitorKeys) {
-        if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") {
-            return true;
-        }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    UnaryExpression (node, options, visitorKeys) {
-        if (node.operator === "delete") {
-            return true;
-        }
-        if (options.considerImplicitTypeConversion && typeConversionUnaryOps.has(node.operator) && node.argument.type !== "Literal") {
-            return true;
+function w$1(t) {
+    return "bigint" == typeof t;
+}
+u$1(d$1(function(t) {
+    return !0;
+}));
+const j$1 = (t)=>Object.assign(u$1(t), {
+        startsWith: (e)=>{
+            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.startsWith(n)))));
+            var n;
+        },
+        endsWith: (e)=>{
+            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.endsWith(n)))));
+            var n;
+        },
+        minLength: (e)=>j$1(m$1(t, ((t)=>d$1((e)=>b$1(e) && e.length >= t))(e))),
+        maxLength: (e)=>j$1(m$1(t, ((t)=>d$1((e)=>b$1(e) && e.length <= t))(e))),
+        includes: (e)=>{
+            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.includes(n)))));
+            var n;
+        },
+        regex: (e)=>{
+            return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && Boolean(t.match(n))))));
+            var n;
         }
-        return this.$visitChildren(node, options, visitorKeys);
-    },
-    UpdateExpression () {
-        return true;
-    },
-    YieldExpression () {
-        return true;
-    }
+    });
+j$1(d$1(b$1));
+const K$1 = (t)=>Object.assign(u$1(t), {
+        between: (e, n)=>K$1(m$1(t, ((t, e)=>d$1((n)=>v$1(n) && t <= n && e >= n))(e, n))),
+        lt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e < t))(e))),
+        gt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e > t))(e))),
+        lte: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e <= t))(e))),
+        gte: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e >= t))(e))),
+        int: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && Number.isInteger(t)))),
+        finite: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && Number.isFinite(t)))),
+        positive: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t > 0))),
+        negative: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t < 0)))
+    });
+K$1(d$1(v$1));
+const x$1 = (t)=>Object.assign(u$1(t), {
+        between: (e, n)=>x$1(m$1(t, ((t, e)=>d$1((n)=>w$1(n) && t <= n && e >= n))(e, n))),
+        lt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e < t))(e))),
+        gt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e > t))(e))),
+        lte: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e <= t))(e))),
+        gte: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e >= t))(e))),
+        positive: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t > 0))),
+        negative: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t < 0)))
+    });
+x$1(d$1(w$1));
+u$1(d$1(function(t) {
+    return "boolean" == typeof t;
 }));
-Function.call.bind(Object.hasOwnProperty);
+u$1(d$1(function(t) {
+    return "symbol" == typeof t;
+}));
+u$1(d$1(function(t) {
+    return null == t;
+}));
+const NodeType = AST_NODE_TYPES;
+const is = ASTUtils.isNodeOfType;
+const isOneOf = ASTUtils.isNodeOfTypes;
+isOneOf([
+    NodeType.ArrowFunctionExpression,
+    NodeType.FunctionDeclaration,
+    NodeType.FunctionExpression
+]);
+isOneOf([
+    NodeType.ArrowFunctionExpression,
+    NodeType.FunctionDeclaration,
+    NodeType.FunctionExpression,
+    NodeType.TSCallSignatureDeclaration,
+    NodeType.TSConstructSignatureDeclaration,
+    NodeType.TSDeclareFunction,
+    NodeType.TSEmptyBodyFunctionExpression,
+    NodeType.TSFunctionType,
+    NodeType.TSMethodSignature
+]);
+isOneOf([
+    NodeType.ClassDeclaration,
+    NodeType.ClassExpression
+]);
+isOneOf([
+    NodeType.DoWhileStatement,
+    NodeType.ForInStatement,
+    NodeType.ForOfStatement,
+    NodeType.ForStatement,
+    NodeType.WhileStatement
+]);
+isOneOf([
+    NodeType.TSArrayType,
+    NodeType.TSTupleType
+]);
+isOneOf([
+    NodeType.PropertyDefinition,
+    NodeType.TSIndexSignature,
+    NodeType.TSParameterProperty,
+    NodeType.TSPropertySignature
+]);
+is(NodeType.JSXElement);
+is(NodeType.JSXFragment);
+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
+]);
+isOneOf([
+    NodeType.ArrayPattern,
+    NodeType.AssignmentPattern,
+    NodeType.ObjectPattern,
+    NodeType.RestElement
+]);
+isOneOf([
+    NodeType.TSInterfaceDeclaration,
+    NodeType.TSTypeAliasDeclaration
+]);
+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
+]);
+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 = effectData_esm.taggedEnum();
+Construction.None();
+[
+    NodeType.JSXElement,
+    NodeType.ArrayExpression,
+    NodeType.ObjectExpression,
+    NodeType.FunctionExpression,
+    NodeType.ArrowFunctionExpression,
+    NodeType.ClassExpression,
+    NodeType.NewExpression,
+    NodeType.CallExpression
+];
 /**
  * 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