Add files using upload-large-folder tool

.gitattributes

@@ -3520,3 +3520,4 @@ novas/novacore-zephyr/claude-code-router/ui/node_modules/@rollup/rollup-linux-x6
 novas/novacore-zephyr/claude-code-router/ui/node_modules/@rollup/rollup-linux-x64-gnu/rollup.linux-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
 novas/novacore-zephyr/claude-code-router/ui/node_modules/@tailwindcss/oxide-linux-x64-gnu/tailwindcss-oxide.linux-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
 novas/novacore-zephyr/claude-code-router/ui/node_modules/@tailwindcss/oxide-linux-x64-musl/tailwindcss-oxide.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
+novas/novacore-zephyr/claude-code-router/ui/node_modules/@esbuild/linux-x64/bin/esbuild filter=lfs diff=lfs merge=lfs -text

novas/novacore-zephyr/claude-code-router/ui/node_modules/@esbuild/linux-x64/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is the Linux 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.

novas/novacore-zephyr/claude-code-router/ui/node_modules/@esbuild/linux-x64/bin/esbuild

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1804240da84ec9976ae33333f256ae9cf731a9d656dad8f83d2ba31098b50547
+size 10297496

novas/novacore-zephyr/claude-code-router/ui/node_modules/@esbuild/linux-x64/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@esbuild/linux-x64",
+  "version": "0.25.8",
+  "description": "The Linux 64-bit binary for esbuild, a JavaScript bundler.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "license": "MIT",
+  "preferUnplugged": true,
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/README.md

@@ -0,0 +1,37 @@
+# @eslint-community/eslint-utils
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/eslint-utils.svg)](https://www.npmjs.com/package/@eslint-community/eslint-utils)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/eslint-utils.svg)](http://www.npmtrends.com/@eslint-community/eslint-utils)
+[![Build Status](https://github.com/eslint-community/eslint-utils/workflows/CI/badge.svg)](https://github.com/eslint-community/eslint-utils/actions)
+[![Coverage Status](https://codecov.io/gh/eslint-community/eslint-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/eslint-utils)
+
+## 🏁 Goal
+
+This package provides utility functions and classes for make ESLint custom rules.
+
+For examples:
+
+-   [`getStaticValue`](https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue) evaluates static value on AST.
+-   [`ReferenceTracker`](https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class) checks the members of modules/globals as handling assignments and destructuring.
+
+## 📖 Usage
+
+See [documentation](https://eslint-community.github.io/eslint-utils).
+
+## 📰 Changelog
+
+See [releases](https://github.com/eslint-community/eslint-utils/releases).
+
+## ❤️ Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+-   `npm run test-coverage` runs tests and measures coverage.
+-   `npm run clean` removes the coverage result of `npm run test-coverage` command.
+-   `npm run coverage` shows the coverage result of the last `npm run test-coverage` command.
+-   `npm run lint` runs ESLint.
+-   `npm run watch` runs tests on each file change.

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/index.d.mts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/index.d.ts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/index.js

@@ -0,0 +1,2494 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var eslintVisitorKeys = require('eslint-visitor-keys');
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+
+/**
+ * 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) {
+    const location = /** @type {[number, number]} */ (node.range)[0];
+
+    let scope = initialScope;
+    let found = false;
+    do {
+        found = false;
+        for (const childScope of scope.childScopes) {
+            const range = /** @type {[number, number]} */ (
+                childScope.block.range
+            );
+
+            if (range[0] <= location && location < range[1]) {
+                scope = childScope;
+                found = true;
+                break
+            }
+        }
+    } while (found)
+
+    return scope
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("eslint").Scope.Variable} Variable */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Find the variable of a given name.
+ * @param {Scope} initialScope The scope to start finding.
+ * @param {string|Identifier} 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) {
+    let name = "";
+    /** @type {Scope|null} */
+    let scope = initialScope;
+
+    if (typeof nameOrNode === "string") {
+        name = nameOrNode;
+    } else {
+        name = nameOrNode.name;
+        scope = getInnermostScope(scope, nameOrNode);
+    }
+
+    while (scope != null) {
+        const variable = scope.set.get(name);
+        if (variable != null) {
+            return variable
+        }
+        scope = scope.upper;
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("estree").Comment} Comment */
+/** @typedef {import("./types.mjs").ArrowToken} ArrowToken */
+/** @typedef {import("./types.mjs").CommaToken} CommaToken */
+/** @typedef {import("./types.mjs").SemicolonToken} SemicolonToken */
+/** @typedef {import("./types.mjs").ColonToken} ColonToken */
+/** @typedef {import("./types.mjs").OpeningParenToken} OpeningParenToken */
+/** @typedef {import("./types.mjs").ClosingParenToken} ClosingParenToken */
+/** @typedef {import("./types.mjs").OpeningBracketToken} OpeningBracketToken */
+/** @typedef {import("./types.mjs").ClosingBracketToken} ClosingBracketToken */
+/** @typedef {import("./types.mjs").OpeningBraceToken} OpeningBraceToken */
+/** @typedef {import("./types.mjs").ClosingBraceToken} ClosingBraceToken */
+/**
+ * @template {string} Value
+ * @typedef {import("./types.mjs").PunctuatorToken<Value>} PunctuatorToken
+ */
+
+/** @typedef {Comment | Token} CommentOrToken */
+
+/**
+ * Creates the negate function of the given function.
+ * @param {function(CommentOrToken):boolean} f - The function to negate.
+ * @returns {function(CommentOrToken):boolean} Negated function.
+ */
+function negate(f) {
+    return (token) => !f(token)
+}
+
+/**
+ * Checks if the given token is a PunctuatorToken with the given value
+ * @template {string} Value
+ * @param {CommentOrToken} token - The token to check.
+ * @param {Value} value - The value to check.
+ * @returns {token is PunctuatorToken<Value>} `true` if the token is a PunctuatorToken with the given value.
+ */
+function isPunctuatorTokenWithValue(token, value) {
+    return token.type === "Punctuator" && token.value === value
+}
+
+/**
+ * Checks if the given token is an arrow token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ArrowToken} `true` if the token is an arrow token.
+ */
+function isArrowToken(token) {
+    return isPunctuatorTokenWithValue(token, "=>")
+}
+
+/**
+ * Checks if the given token is a comma token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is CommaToken} `true` if the token is a comma token.
+ */
+function isCommaToken(token) {
+    return isPunctuatorTokenWithValue(token, ",")
+}
+
+/**
+ * Checks if the given token is a semicolon token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is SemicolonToken} `true` if the token is a semicolon token.
+ */
+function isSemicolonToken(token) {
+    return isPunctuatorTokenWithValue(token, ";")
+}
+
+/**
+ * Checks if the given token is a colon token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ColonToken} `true` if the token is a colon token.
+ */
+function isColonToken(token) {
+    return isPunctuatorTokenWithValue(token, ":")
+}
+
+/**
+ * Checks if the given token is an opening parenthesis token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token.
+ */
+function isOpeningParenToken(token) {
+    return isPunctuatorTokenWithValue(token, "(")
+}
+
+/**
+ * Checks if the given token is a closing parenthesis token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token.
+ */
+function isClosingParenToken(token) {
+    return isPunctuatorTokenWithValue(token, ")")
+}
+
+/**
+ * Checks if the given token is an opening square bracket token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token.
+ */
+function isOpeningBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "[")
+}
+
+/**
+ * Checks if the given token is a closing square bracket token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token.
+ */
+function isClosingBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "]")
+}
+
+/**
+ * Checks if the given token is an opening brace token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token.
+ */
+function isOpeningBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "{")
+}
+
+/**
+ * Checks if the given token is a closing brace token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token.
+ */
+function isClosingBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "}")
+}
+
+/**
+ * Checks if the given token is a comment token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is Comment} `true` if the token is a comment token.
+ */
+function isCommentToken(token) {
+    return ["Block", "Line", "Shebang"].includes(token.type)
+}
+
+const isNotArrowToken = negate(isArrowToken);
+const isNotCommaToken = negate(isCommaToken);
+const isNotSemicolonToken = negate(isSemicolonToken);
+const isNotColonToken = negate(isColonToken);
+const isNotOpeningParenToken = negate(isOpeningParenToken);
+const isNotClosingParenToken = negate(isClosingParenToken);
+const isNotOpeningBracketToken = negate(isOpeningBracketToken);
+const isNotClosingBracketToken = negate(isClosingBracketToken);
+const isNotOpeningBraceToken = negate(isOpeningBraceToken);
+const isNotClosingBraceToken = negate(isClosingBraceToken);
+const isNotCommentToken = negate(isCommentToken);
+
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("estree").Function} FunctionNode */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Position} Position */
+
+/**
+ * Get the `(` token of the given function node.
+ * @param {FunctionExpression | FunctionDeclaration} node - The function node to get.
+ * @param {SourceCode} sourceCode - The source code object to get tokens.
+ * @returns {Token} `(` token.
+ */
+function getOpeningParenOfParams(node, sourceCode) {
+    return node.id
+        ? /** @type {Token} */ (
+              sourceCode.getTokenAfter(node.id, isOpeningParenToken)
+          )
+        : /** @type {Token} */ (
+              sourceCode.getFirstToken(node, isOpeningParenToken)
+          )
+}
+
+/**
+ * Get the location of the given function node for reporting.
+ * @param {FunctionNode} node - The function node to get.
+ * @param {SourceCode} sourceCode - The source code object to get tokens.
+ * @returns {SourceLocation|null} The location of the function node for reporting.
+ */
+function getFunctionHeadLocation(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+
+    /** @type {Position|null} */
+    let start = null;
+    /** @type {Position|null} */
+    let end = null;
+
+    if (node.type === "ArrowFunctionExpression") {
+        const arrowToken = /** @type {Token} */ (
+            sourceCode.getTokenBefore(node.body, isArrowToken)
+        );
+
+        start = arrowToken.loc.start;
+        end = arrowToken.loc.end;
+    } else if (
+        parent.type === "Property" ||
+        parent.type === "MethodDefinition" ||
+        parent.type === "PropertyDefinition"
+    ) {
+        start = /** @type {SourceLocation} */ (parent.loc).start;
+        end = getOpeningParenOfParams(node, sourceCode).loc.start;
+    } else {
+        start = /** @type {SourceLocation} */ (node.loc).start;
+        end = getOpeningParenOfParams(node, sourceCode).loc.start;
+    }
+
+    return {
+        start: { ...start },
+        end: { ...end },
+    }
+}
+
+/* globals globalThis, global, self, window */
+/** @typedef {import("./types.mjs").StaticValue} StaticValue */
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
+/** @typedef {import("@typescript-eslint/types").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */
+/** @typedef {import("@typescript-eslint/types").TSESTree.MemberExpression} MemberExpression */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Property} Property */
+/** @typedef {import("@typescript-eslint/types").TSESTree.RegExpLiteral} RegExpLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.BigIntLiteral} BigIntLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Literal} Literal */
+
+const globalObject =
+    typeof globalThis !== "undefined"
+        ? globalThis
+        : // @ts-ignore
+        typeof self !== "undefined"
+        ? // @ts-ignore
+          self
+        : // @ts-ignore
+        typeof window !== "undefined"
+        ? // @ts-ignore
+          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,
+        // @ts-ignore
+        isPrototypeOf,
+        Map,
+        Map.prototype.entries,
+        Map.prototype.get,
+        Map.prototype.has,
+        Map.prototype.keys,
+        Map.prototype.values,
+        .../** @type {(keyof typeof Math)[]} */ (
+            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,
+]);
+
+/** @type {ReadonlyArray<readonly [Function, ReadonlySet<string>]>} */
+const getterAllowed = [
+    [Map, new Set(["size"])],
+    [
+        RegExp,
+        new Set([
+            "dotAll",
+            "flags",
+            "global",
+            "hasIndices",
+            "ignoreCase",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode",
+        ]),
+    ],
+    [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) {
+    let x = object;
+    while ((typeof x === "object" || typeof x === "function") && x !== null) {
+        const d = Object.getOwnPropertyDescriptor(x, name);
+        if (d) {
+            return d
+        }
+        x = Object.getPrototypeOf(x);
+    }
+    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) {
+    const d = getPropertyDescriptor(object, name);
+    return d != null && d.get != null
+}
+
+/**
+ * Get the element values of a given node list.
+ * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values.
+ * @param {Scope|undefined|null} initialScope The initial scope to find variables.
+ * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.
+ */
+function getElementValues(nodeList, initialScope) {
+    const valueList = [];
+
+    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
+            }
+            valueList.push(.../** @type {Iterable<any>} */ (argument.value));
+        } else {
+            const element = getStaticValueR(elementNode, initialScope);
+            if (element == null) {
+                return null
+            }
+            valueList.push(element.value);
+        }
+    }
+
+    return valueList
+}
+
+/**
+ * Returns whether the given variable is never written to after initialization.
+ * @param {import("eslint").Scope.Variable} variable
+ * @returns {boolean}
+ */
+function isEffectivelyConst(variable) {
+    const refs = variable.references;
+
+    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 false
+}
+
+/**
+ * @template {TSESTreeNodeTypes} T
+ * @callback VisitorCallback
+ * @param {TSESTreeNode & { type: T }} node
+ * @param {Scope|undefined|null} initialScope
+ * @returns {StaticValue | null}
+ */
+/**
+ * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback<K> } } Operations
+ */
+/**
+ * @type {Operations}
+ */
+const operations = Object.freeze({
+    ArrayExpression(node, initialScope) {
+        const elements = getElementValues(node.elements, initialScope);
+        return elements != null ? { value: elements } : null
+    },
+
+    AssignmentExpression(node, initialScope) {
+        if (node.operator === "=") {
+            return getStaticValueR(node.right, initialScope)
+        }
+        return null
+    },
+
+    //eslint-disable-next-line complexity
+    BinaryExpression(node, initialScope) {
+        if (node.operator === "in" || node.operator === "instanceof") {
+            // Not supported.
+            return null
+        }
+
+        const left = getStaticValueR(node.left, initialScope);
+        const right = getStaticValueR(node.right, initialScope);
+        if (left != null && right != null) {
+            switch (node.operator) {
+                case "==":
+                    return { value: left.value == right.value } //eslint-disable-line eqeqeq
+                case "!=":
+                    return { value: left.value != right.value } //eslint-disable-line eqeqeq
+                case "===":
+                    return { value: left.value === right.value }
+                case "!==":
+                    return { value: left.value !== right.value }
+                case "<":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <
+                            /** @type {any} */ (right.value),
+                    }
+                case "<=":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <=
+                            /** @type {any} */ (right.value),
+                    }
+                case ">":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >
+                            /** @type {any} */ (right.value),
+                    }
+                case ">=":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >=
+                            /** @type {any} */ (right.value),
+                    }
+                case "<<":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <<
+                            /** @type {any} */ (right.value),
+                    }
+                case ">>":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >>
+                            /** @type {any} */ (right.value),
+                    }
+                case ">>>":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >>>
+                            /** @type {any} */ (right.value),
+                    }
+                case "+":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) +
+                            /** @type {any} */ (right.value),
+                    }
+                case "-":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) -
+                            /** @type {any} */ (right.value),
+                    }
+                case "*":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) *
+                            /** @type {any} */ (right.value),
+                    }
+                case "/":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) /
+                            /** @type {any} */ (right.value),
+                    }
+                case "%":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) %
+                            /** @type {any} */ (right.value),
+                    }
+                case "**":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) **
+                            /** @type {any} */ (right.value),
+                    }
+                case "|":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) |
+                            /** @type {any} */ (right.value),
+                    }
+                case "^":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) ^
+                            /** @type {any} */ (right.value),
+                    }
+                case "&":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) &
+                            /** @type {any} */ (right.value),
+                    }
+
+                // no default
+            }
+        }
+
+        return null
+    },
+
+    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
+                }
+                const object = getStaticValueR(calleeNode.object, initialScope);
+                if (object != null) {
+                    if (
+                        object.value == null &&
+                        (object.optional || node.optional)
+                    ) {
+                        return { value: undefined, optional: true }
+                    }
+                    const property = getStaticPropertyNameValue(
+                        calleeNode,
+                        initialScope,
+                    );
+
+                    if (property != null) {
+                        const receiver =
+                            /** @type {Record<PropertyKey, (...args: any[]) => any>} */ (
+                                object.value
+                            );
+                        const methodName = /** @type {PropertyKey} */ (
+                            property.value
+                        );
+                        if (callAllowed.has(receiver[methodName])) {
+                            return {
+                                value: receiver[methodName](...args),
+                            }
+                        }
+                        if (callPassThrough.has(receiver[methodName])) {
+                            return { value: args[0] }
+                        }
+                    }
+                }
+            } else {
+                const callee = getStaticValueR(calleeNode, initialScope);
+                if (callee != null) {
+                    if (callee.value == null && node.optional) {
+                        return { value: undefined, optional: true }
+                    }
+                    const func = /** @type {(...args: any[]) => any} */ (
+                        callee.value
+                    );
+                    if (callAllowed.has(func)) {
+                        return { value: func(...args) }
+                    }
+                    if (callPassThrough.has(func)) {
+                        return { value: args[0] }
+                    }
+                }
+            }
+        }
+
+        return null
+    },
+
+    ConditionalExpression(node, initialScope) {
+        const test = getStaticValueR(node.test, initialScope);
+        if (test != null) {
+            return test.value
+                ? getStaticValueR(node.consequent, initialScope)
+                : getStaticValueR(node.alternate, initialScope)
+        }
+        return null
+    },
+
+    ExpressionStatement(node, initialScope) {
+        return getStaticValueR(node.expression, 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] }
+            }
+
+            // 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)
+                }
+            }
+        }
+        return null
+    },
+
+    Literal(node) {
+        const literal =
+            /** @type {Partial<Literal> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
+                node
+            );
+        //istanbul ignore if : this is implementation-specific behavior.
+        if (
+            (literal.regex != null || literal.bigint != null) &&
+            literal.value == null
+        ) {
+            // It was a RegExp/BigInt literal, but Node.js didn't support it.
+            return null
+        }
+        return { value: literal.value }
+    },
+
+    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
+            }
+
+            const right = getStaticValueR(node.right, initialScope);
+            if (right != null) {
+                return right
+            }
+        }
+
+        return null
+    },
+
+    MemberExpression(node, initialScope) {
+        if (node.property.type === "PrivateIdentifier") {
+            return null
+        }
+        const object = getStaticValueR(node.object, initialScope);
+        if (object != null) {
+            if (object.value == null && (object.optional || node.optional)) {
+                return { value: undefined, optional: true }
+            }
+            const property = getStaticPropertyNameValue(node, initialScope);
+
+            if (property != null) {
+                if (
+                    !isGetter(
+                        /** @type {object} */ (object.value),
+                        /** @type {PropertyKey} */ (property.value),
+                    )
+                ) {
+                    return {
+                        value: /** @type {Record<PropertyKey, unknown>} */ (
+                            object.value
+                        )[/** @type {PropertyKey} */ (property.value)],
+                    }
+                }
+
+                for (const [classFn, allowed] of getterAllowed) {
+                    if (
+                        object.value instanceof classFn &&
+                        allowed.has(/** @type {string} */ (property.value))
+                    ) {
+                        return {
+                            value: /** @type {Record<PropertyKey, unknown>} */ (
+                                object.value
+                            )[/** @type {PropertyKey} */ (property.value)],
+                        }
+                    }
+                }
+            }
+        }
+        return null
+    },
+
+    ChainExpression(node, initialScope) {
+        const expression = getStaticValueR(node.expression, initialScope);
+        if (expression != null) {
+            return { value: expression.value }
+        }
+        return null
+    },
+
+    NewExpression(node, initialScope) {
+        const callee = getStaticValueR(node.callee, initialScope);
+        const args = getElementValues(node.arguments, initialScope);
+
+        if (callee != null && args != null) {
+            const Func = /** @type {new (...args: any[]) => any} */ (
+                callee.value
+            );
+            if (callAllowed.has(Func)) {
+                return { value: new Func(...args) }
+            }
+        }
+
+        return null
+    },
+
+    ObjectExpression(node, initialScope) {
+        /** @type {Record<PropertyKey, unknown>} */
+        const object = {};
+
+        for (const propertyNode of node.properties) {
+            if (propertyNode.type === "Property") {
+                if (propertyNode.kind !== "init") {
+                    return null
+                }
+                const key = getStaticPropertyNameValue(
+                    propertyNode,
+                    initialScope,
+                );
+                const value = getStaticValueR(propertyNode.value, initialScope);
+                if (key == null || value == null) {
+                    return null
+                }
+                object[/** @type {PropertyKey} */ (key.value)] = value.value;
+            } else if (
+                propertyNode.type === "SpreadElement" ||
+                // @ts-expect-error -- Backward compatibility
+                propertyNode.type === "ExperimentalSpreadProperty"
+            ) {
+                const argument = getStaticValueR(
+                    propertyNode.argument,
+                    initialScope,
+                );
+                if (argument == null) {
+                    return null
+                }
+                Object.assign(object, argument.value);
+            } else {
+                return null
+            }
+        }
+
+        return { value: object }
+    },
+
+    SequenceExpression(node, initialScope) {
+        const last = node.expressions[node.expressions.length - 1];
+        return getStaticValueR(last, initialScope)
+    },
+
+    TaggedTemplateExpression(node, initialScope) {
+        const tag = getStaticValueR(node.tag, initialScope);
+        const expressions = getElementValues(
+            node.quasi.expressions,
+            initialScope,
+        );
+
+        if (tag != null && expressions != null) {
+            const func = /** @type {(...args: any[]) => any} */ (tag.value);
+            /** @type {any[] & { raw?: string[] }} */
+            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 null
+    },
+
+    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) {
+                value += expressions[i];
+                value += /** @type {string} */ (node.quasis[i + 1].value.cooked);
+            }
+            return { value }
+        }
+        return null
+    },
+
+    UnaryExpression(node, initialScope) {
+        if (node.operator === "delete") {
+            // Not supported.
+            return null
+        }
+        if (node.operator === "void") {
+            return { value: undefined }
+        }
+
+        const arg = getStaticValueR(node.argument, initialScope);
+        if (arg != null) {
+            switch (node.operator) {
+                case "-":
+                    return { value: -(/** @type {any} */ (arg.value)) }
+                case "+":
+                    return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion
+                case "!":
+                    return { value: !arg.value }
+                case "~":
+                    return { value: ~(/** @type {any} */ (arg.value)) }
+                case "typeof":
+                    return { value: typeof arg.value }
+
+                // no default
+            }
+        }
+
+        return null
+    },
+    TSAsExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSSatisfiesExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSTypeAssertion(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSNonNullExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSInstantiationExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+});
+
+/**
+ * Get the value of a given node if it's a static value.
+ * @param {Node|TSESTreeNode|null|undefined} node The node to get.
+ * @param {Scope|undefined|null} initialScope The scope to start finding variable.
+ * @returns {StaticValue|null} The static value of the node, or `null`.
+ */
+function getStaticValueR(node, initialScope) {
+    if (node != null && Object.hasOwnProperty.call(operations, node.type)) {
+        return /** @type {VisitorCallback<any>} */ (operations[node.type])(
+            /** @type {TSESTreeNode} */ (node),
+            initialScope,
+        )
+    }
+    return null
+}
+
+/**
+ * Get the static value of property name from a MemberExpression node or a Property node.
+ * @param {MemberExpression|Property} node The node to get.
+ * @param {Scope|null} [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 {StaticValue|null} The static value of the property name of the node, or `null`.
+ */
+function getStaticPropertyNameValue(node, initialScope) {
+    const nameNode = node.type === "Property" ? node.key : node.property;
+
+    if (node.computed) {
+        return getStaticValueR(nameNode, initialScope)
+    }
+
+    if (nameNode.type === "Identifier") {
+        return { value: nameNode.name }
+    }
+
+    if (nameNode.type === "Literal") {
+        if (/** @type {Partial<BigIntLiteral>} */ (nameNode).bigint) {
+            return { value: /** @type {BigIntLiteral} */ (nameNode).bigint }
+        }
+        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|null} [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 {StaticValue | null} The static value of the node, or `null`.
+ */
+function getStaticValue(node, initialScope = null) {
+    try {
+        return getStaticValueR(node, initialScope)
+    } catch (_error) {
+        return null
+    }
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").RegExpLiteral} RegExpLiteral */
+/** @typedef {import("estree").BigIntLiteral} BigIntLiteral */
+/** @typedef {import("estree").SimpleLiteral} SimpleLiteral */
+
+/**
+ * Get the value of a given node if it's a literal or a template literal.
+ * @param {Node} node The node to get.
+ * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.
+ * @returns {string|null} The value of the node, or `null`.
+ */
+function getStringIfConstant(node, initialScope = null) {
+    // Handle the literals that the platform doesn't support natively.
+    if (node && node.type === "Literal" && node.value === null) {
+        const literal =
+            /** @type {Partial<SimpleLiteral> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
+                node
+            );
+        if (literal.regex) {
+            return `/${literal.regex.pattern}/${literal.regex.flags}`
+        }
+        if (literal.bigint) {
+            return literal.bigint
+        }
+    }
+
+    const evaluated = getStaticValue(node, initialScope);
+
+    if (evaluated) {
+        // `String(Symbol.prototype)` throws error
+        try {
+            return String(evaluated.value)
+        } catch {
+            // No op
+        }
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").MethodDefinition} MethodDefinition */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Get the property name from a MemberExpression node or a Property node.
+ * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} 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 {string|null|undefined} The property name of the node.
+ */
+function getPropertyName(node, initialScope) {
+    switch (node.type) {
+        case "MemberExpression":
+            if (node.computed) {
+                return getStringIfConstant(node.property, initialScope)
+            }
+            if (node.property.type === "PrivateIdentifier") {
+                return null
+            }
+            return /** @type {Partial<Identifier>} */ (node.property).name
+
+        case "Property":
+        case "MethodDefinition":
+        case "PropertyDefinition":
+            if (node.computed) {
+                return getStringIfConstant(node.key, initialScope)
+            }
+            if (node.key.type === "Literal") {
+                return String(node.key.value)
+            }
+            if (node.key.type === "PrivateIdentifier") {
+                return null
+            }
+            return /** @type {Partial<Identifier>} */ (node.key).name
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("estree").Function} FunctionNode */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Get the name and kind of the given function node.
+ * @param {FunctionNode} node - The function node to get.
+ * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys.
+ * @returns {string} The name and kind of the function node.
+ */
+// eslint-disable-next-line complexity
+function getFunctionNameWithKind(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+    const tokens = [];
+    const isObjectMethod = parent.type === "Property" && parent.value === node;
+    const isClassMethod =
+        parent.type === "MethodDefinition" && parent.value === node;
+    const isClassFieldMethod =
+        parent.type === "PropertyDefinition" && parent.value === node;
+
+    // Modifiers.
+    if (isClassMethod || isClassFieldMethod) {
+        if (parent.static) {
+            tokens.push("static");
+        }
+        if (parent.key.type === "PrivateIdentifier") {
+            tokens.push("private");
+        }
+    }
+    if (node.async) {
+        tokens.push("async");
+    }
+    if (node.generator) {
+        tokens.push("generator");
+    }
+
+    // Kinds.
+    if (isObjectMethod || isClassMethod) {
+        if (parent.kind === "constructor") {
+            return "constructor"
+        }
+        if (parent.kind === "get") {
+            tokens.push("getter");
+        } else if (parent.kind === "set") {
+            tokens.push("setter");
+        } else {
+            tokens.push("method");
+        }
+    } else if (isClassFieldMethod) {
+        tokens.push("method");
+    } else {
+        if (node.type === "ArrowFunctionExpression") {
+            tokens.push("arrow");
+        }
+        tokens.push("function");
+    }
+
+    // Names.
+    if (isObjectMethod || isClassMethod || isClassFieldMethod) {
+        if (parent.key.type === "PrivateIdentifier") {
+            tokens.push(`#${parent.key.name}`);
+        } else {
+            const name = getPropertyName(parent);
+            if (name) {
+                tokens.push(`'${name}'`);
+            } else if (sourceCode) {
+                const keyText = sourceCode.getText(parent.key);
+                if (!keyText.includes("\n")) {
+                    tokens.push(`[${keyText}]`);
+                }
+            }
+        }
+    } else if (hasId(node)) {
+        tokens.push(`'${node.id.name}'`);
+    } else if (
+        parent.type === "VariableDeclarator" &&
+        parent.id &&
+        parent.id.type === "Identifier"
+    ) {
+        tokens.push(`'${parent.id.name}'`);
+    } else if (
+        (parent.type === "AssignmentExpression" ||
+            parent.type === "AssignmentPattern") &&
+        parent.left &&
+        parent.left.type === "Identifier"
+    ) {
+        tokens.push(`'${parent.left.name}'`);
+    } else if (
+        parent.type === "ExportDefaultDeclaration" &&
+        parent.declaration === node
+    ) {
+        tokens.push("'default'");
+    }
+
+    return tokens.join(" ")
+}
+
+/**
+ * @param {FunctionNode} node
+ * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }}
+ */
+function hasId(node) {
+    return Boolean(
+        /** @type {Partial<FunctionDeclaration | FunctionExpression>} */ (node)
+            .id,
+    )
+}
+
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("./types.mjs").HasSideEffectOptions} HasSideEffectOptions */
+/** @typedef {import("estree").BinaryExpression} BinaryExpression */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").MethodDefinition} MethodDefinition */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
+/** @typedef {import("estree").UnaryExpression} UnaryExpression */
+
+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 {x is Node} `true` if the value is an ASTNode.
+ */
+function isNode(x) {
+    return x !== null && typeof x === "object" && typeof x.type === "string"
+}
+
+const visitor = Object.freeze(
+    Object.assign(Object.create(null), {
+        /**
+         * @param {Node} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        $visit(node, options, visitorKeys) {
+            const { type } = node;
+
+            if (typeof (/** @type {any} */ (this)[type]) === "function") {
+                return /** @type {any} */ (this)[type](
+                    node,
+                    options,
+                    visitorKeys,
+                )
+            }
+
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+
+        /**
+         * @param {Node} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        $visitChildren(node, options, visitorKeys) {
+            const { type } = node;
+
+            for (const key of /** @type {(keyof Node)[]} */ (
+                visitorKeys[type] || eslintVisitorKeys.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
+        },
+        /**
+         * @param {BinaryExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        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
+        },
+        /**
+         * @param {MemberExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        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)
+        },
+        /**
+         * @param {MethodDefinition} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} 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
+        },
+        /**
+         * @param {Property} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        Property(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        /**
+         * @param {PropertyDefinition} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        PropertyDefinition(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        /**
+         * @param {UnaryExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} 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
+        },
+    }),
+);
+
+/**
+ * Check whether a given node has any side effect or not.
+ * @param {Node} node The node to get.
+ * @param {SourceCode} sourceCode The source code object.
+ * @param {HasSideEffectOptions} [options] The option object.
+ * @returns {boolean} `true` if the node has a certain side effect.
+ */
+function hasSideEffect(node, sourceCode, options = {}) {
+    const { considerGetters = false, considerImplicitTypeConversion = false } =
+        options;
+    return visitor.$visit(
+        node,
+        { considerGetters, considerImplicitTypeConversion },
+        sourceCode.visitorKeys || eslintVisitorKeys.KEYS,
+    )
+}
+
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+
+/**
+ * Get the left parenthesis of the parent node syntax if it exists.
+ * E.g., `if (a) {}` then the `(`.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {Token|null} The left parenthesis of the parent node syntax
+ */
+function getParentSyntaxParen(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+
+    switch (parent.type) {
+        case "CallExpression":
+        case "NewExpression":
+            if (parent.arguments.length === 1 && parent.arguments[0] === node) {
+                return sourceCode.getTokenAfter(
+                    parent.callee,
+                    isOpeningParenToken,
+                )
+            }
+            return null
+
+        case "DoWhileStatement":
+            if (parent.test === node) {
+                return sourceCode.getTokenAfter(
+                    parent.body,
+                    isOpeningParenToken,
+                )
+            }
+            return null
+
+        case "IfStatement":
+        case "WhileStatement":
+            if (parent.test === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "ImportExpression":
+            if (parent.source === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "SwitchStatement":
+            if (parent.discriminant === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "WithStatement":
+            if (parent.object === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        default:
+            return null
+    }
+}
+
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {number} times The number of parantheses.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {boolean} `true` if the node is parenthesized the given times.
+ */
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {boolean} `true` if the node is parenthesized.
+ */
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {Node|number} timesOrNode The first parameter.
+ * @param {Node|SourceCode} nodeOrSourceCode The second parameter.
+ * @param {SourceCode} [optionalSourceCode] The third parameter.
+ * @returns {boolean} `true` if the node is parenthesized.
+ */
+function isParenthesized(
+    timesOrNode,
+    nodeOrSourceCode,
+    optionalSourceCode,
+) {
+    /** @type {number} */
+    let times,
+        /** @type {RuleNode} */
+        node,
+        /** @type {SourceCode} */
+        sourceCode,
+        maybeLeftParen,
+        maybeRightParen;
+    if (typeof timesOrNode === "number") {
+        times = timesOrNode | 0;
+        node = /** @type {RuleNode} */ (nodeOrSourceCode);
+        sourceCode = /** @type {SourceCode} */ (optionalSourceCode);
+        if (!(times >= 1)) {
+            throw new TypeError("'times' should be a positive integer.")
+        }
+    } else {
+        times = 1;
+        node = /** @type {RuleNode} */ (timesOrNode);
+        sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode);
+    }
+
+    if (
+        node == null ||
+        // `Program` can't be parenthesized
+        node.parent == null ||
+        // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`
+        (node.parent.type === "CatchClause" && node.parent.param === node)
+    ) {
+        return false
+    }
+
+    maybeLeftParen = maybeRightParen = node;
+    do {
+        maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen);
+        maybeRightParen = sourceCode.getTokenAfter(maybeRightParen);
+    } while (
+        maybeLeftParen != null &&
+        maybeRightParen != null &&
+        isOpeningParenToken(maybeLeftParen) &&
+        isClosingParenToken(maybeRightParen) &&
+        // Avoid false positive such as `if (a) {}`
+        maybeLeftParen !== getParentSyntaxParen(node, sourceCode) &&
+        --times > 0
+    )
+
+    return times === 0
+}
+
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+const placeholder = /\$(?:[$&`']|[1-9][0-9]?)/gu;
+
+/** @type {WeakMap<PatternMatcher, {pattern:RegExp,escaped:boolean}>} */
+const internal = new WeakMap();
+
+/**
+ * Check whether a given character is escaped or not.
+ * @param {string} str The string to check.
+ * @param {number} index The location of the character to check.
+ * @returns {boolean} `true` if the character is escaped.
+ */
+function isEscaped(str, index) {
+    let escaped = false;
+    for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) {
+        escaped = !escaped;
+    }
+    return escaped
+}
+
+/**
+ * Replace a given string by a given matcher.
+ * @param {PatternMatcher} matcher The pattern matcher.
+ * @param {string} str The string to be replaced.
+ * @param {string} replacement The new substring to replace each matched part.
+ * @returns {string} The replaced string.
+ */
+function replaceS(matcher, str, replacement) {
+    const chunks = [];
+    let index = 0;
+
+    /**
+     * @param {string} key The placeholder.
+     * @param {RegExpExecArray} match The matched information.
+     * @returns {string} The replaced string.
+     */
+    function replacer(key, match) {
+        switch (key) {
+            case "$$":
+                return "$"
+            case "$&":
+                return match[0]
+            case "$`":
+                return str.slice(0, match.index)
+            case "$'":
+                return str.slice(match.index + match[0].length)
+            default: {
+                const i = key.slice(1);
+                if (i in match) {
+                    return match[/** @type {any} */ (i)]
+                }
+                return key
+            }
+        }
+    }
+
+    for (const match of matcher.execAll(str)) {
+        chunks.push(str.slice(index, match.index));
+        chunks.push(
+            replacement.replace(placeholder, (key) => replacer(key, match)),
+        );
+        index = match.index + match[0].length;
+    }
+    chunks.push(str.slice(index));
+
+    return chunks.join("")
+}
+
+/**
+ * Replace a given string by a given matcher.
+ * @param {PatternMatcher} matcher The pattern matcher.
+ * @param {string} str The string to be replaced.
+ * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part.
+ * @returns {string} The replaced string.
+ */
+function replaceF(matcher, str, replace) {
+    const chunks = [];
+    let index = 0;
+
+    for (const match of matcher.execAll(str)) {
+        chunks.push(str.slice(index, match.index));
+        chunks.push(
+            String(
+                replace(
+                    .../** @type {[string, ...string[]]} */ (
+                        /** @type {string[]} */ (match)
+                    ),
+                    match.index,
+                    match.input,
+                ),
+            ),
+        );
+        index = match.index + match[0].length;
+    }
+    chunks.push(str.slice(index));
+
+    return chunks.join("")
+}
+
+/**
+ * The class to find patterns as considering escape sequences.
+ */
+class PatternMatcher {
+    /**
+     * Initialize this matcher.
+     * @param {RegExp} pattern The pattern to match.
+     * @param {{escaped?:boolean}} [options] The options.
+     */
+    constructor(pattern, options = {}) {
+        const { escaped = false } = options;
+        if (!(pattern instanceof RegExp)) {
+            throw new TypeError("'pattern' should be a RegExp instance.")
+        }
+        if (!pattern.flags.includes("g")) {
+            throw new Error("'pattern' should contains 'g' flag.")
+        }
+
+        internal.set(this, {
+            pattern: new RegExp(pattern.source, pattern.flags),
+            escaped: Boolean(escaped),
+        });
+    }
+
+    /**
+     * Find the pattern in a given string.
+     * @param {string} str The string to find.
+     * @returns {IterableIterator<RegExpExecArray>} The iterator which iterate the matched information.
+     */
+    *execAll(str) {
+        const { pattern, escaped } =
+            /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this));
+        let match = null;
+        let lastIndex = 0;
+
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(str)) != null) {
+            if (escaped || !isEscaped(str, match.index)) {
+                lastIndex = pattern.lastIndex;
+                yield match;
+                pattern.lastIndex = lastIndex;
+            }
+        }
+    }
+
+    /**
+     * Check whether the pattern is found in a given string.
+     * @param {string} str The string to check.
+     * @returns {boolean} `true` if the pattern was found in the string.
+     */
+    test(str) {
+        const it = this.execAll(str);
+        const ret = it.next();
+        return !ret.done
+    }
+
+    /**
+     * Replace a given string.
+     * @param {string} str The string to be replaced.
+     * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.
+     * @returns {string} The replaced string.
+     */
+    [Symbol.replace](str, replacer) {
+        return typeof replacer === "function"
+            ? replaceF(this, String(str), replacer)
+            : replaceS(this, String(str), String(replacer))
+    }
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("eslint").Scope.Variable} Variable */
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").SimpleCallExpression} CallExpression */
+/** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
+/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
+/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
+/** @typedef {import("estree").ExportSpecifier} ExportSpecifier */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
+/** @typedef {import("./types.mjs").ReferenceTrackerOptions} ReferenceTrackerOptions */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TraceMap<T>} TraceMap
+ */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TraceMapObject<T>} TraceMapObject
+ */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TrackedReferences<T>} TrackedReferences
+ */
+
+const IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u;
+
+/**
+ * Check whether a given node is an import node or not.
+ * @param {Node} node
+ * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node.
+ */
+function isHasSource(node) {
+    return (
+        IMPORT_TYPE.test(node.type) &&
+        /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ (
+            node
+        ).source != null
+    )
+}
+const has =
+    /** @type {<T>(traceMap: TraceMap<unknown>, v: T) => v is (string extends T ? string : T)} */ (
+        Function.call.bind(Object.hasOwnProperty)
+    );
+
+const READ = Symbol("read");
+const CALL = Symbol("call");
+const CONSTRUCT = Symbol("construct");
+const ESM = Symbol("esm");
+
+const requireCall = { require: { [CALL]: true } };
+
+/**
+ * Check whether a given variable is modified or not.
+ * @param {Variable|undefined} variable The variable to check.
+ * @returns {boolean} `true` if the variable is modified.
+ */
+function isModifiedGlobal(variable) {
+    return (
+        variable == null ||
+        variable.defs.length !== 0 ||
+        variable.references.some((r) => r.isWrite())
+    )
+}
+
+/**
+ * Check if the value of a given node is passed through to the parent syntax as-is.
+ * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.
+ * @param {Node} node A node to check.
+ * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through.
+ */
+function isPassThrough(node) {
+    const parent = /** @type {TSESTreeNode} */ (node).parent;
+
+    if (parent) {
+        switch (parent.type) {
+            case "ConditionalExpression":
+                return parent.consequent === node || parent.alternate === node
+            case "LogicalExpression":
+                return true
+            case "SequenceExpression":
+                return (
+                    parent.expressions[parent.expressions.length - 1] === node
+                )
+            case "ChainExpression":
+                return true
+            case "TSAsExpression":
+            case "TSSatisfiesExpression":
+            case "TSTypeAssertion":
+            case "TSNonNullExpression":
+            case "TSInstantiationExpression":
+                return true
+
+            default:
+                return false
+        }
+    }
+    return false
+}
+
+/**
+ * The reference tracker.
+ */
+class ReferenceTracker {
+    /**
+     * Initialize this tracker.
+     * @param {Scope} globalScope The global scope.
+     * @param {object} [options] The options.
+     * @param {"legacy"|"strict"} [options.mode="strict"] The mode to determine the ImportDeclaration's behavior for CJS modules.
+     * @param {string[]} [options.globalObjectNames=["global","globalThis","self","window"]] The variable names for Global Object.
+     */
+    constructor(globalScope, options = {}) {
+        const {
+            mode = "strict",
+            globalObjectNames = ["global", "globalThis", "self", "window"],
+        } = options;
+        /** @private @type {Variable[]} */
+        this.variableStack = [];
+        /** @private */
+        this.globalScope = globalScope;
+        /** @private */
+        this.mode = mode;
+        /** @private */
+        this.globalObjectNames = globalObjectNames.slice(0);
+    }
+
+    /**
+     * Iterate the references of global variables.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateGlobalReferences(traceMap) {
+        for (const key of Object.keys(traceMap)) {
+            const nextTraceMap = traceMap[key];
+            const path = [key];
+            const variable = this.globalScope.set.get(key);
+
+            if (isModifiedGlobal(variable)) {
+                continue
+            }
+
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (variable),
+                path,
+                nextTraceMap,
+                true,
+            );
+        }
+
+        for (const key of this.globalObjectNames) {
+            /** @type {string[]} */
+            const path = [];
+            const variable = this.globalScope.set.get(key);
+
+            if (isModifiedGlobal(variable)) {
+                continue
+            }
+
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (variable),
+                path,
+                traceMap,
+                false,
+            );
+        }
+    }
+
+    /**
+     * Iterate the references of CommonJS modules.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateCjsReferences(traceMap) {
+        for (const { node } of this.iterateGlobalReferences(requireCall)) {
+            const key = getStringIfConstant(
+                /** @type {CallExpression} */ (node).arguments[0],
+            );
+            if (key == null || !has(traceMap, key)) {
+                continue
+            }
+
+            const nextTraceMap = traceMap[key];
+            const path = [key];
+
+            if (nextTraceMap[READ]) {
+                yield {
+                    node,
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+            yield* this._iteratePropertyReferences(
+                /** @type {CallExpression} */ (node),
+                path,
+                nextTraceMap,
+            );
+        }
+    }
+
+    /**
+     * Iterate the references of ES modules.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateEsmReferences(traceMap) {
+        const programNode = /** @type {Program} */ (this.globalScope.block);
+
+        for (const node of programNode.body) {
+            if (!isHasSource(node)) {
+                continue
+            }
+            const moduleId = /** @type {string} */ (node.source.value);
+
+            if (!has(traceMap, moduleId)) {
+                continue
+            }
+            const nextTraceMap = traceMap[moduleId];
+            const path = [moduleId];
+
+            if (nextTraceMap[READ]) {
+                yield {
+                    // eslint-disable-next-line object-shorthand -- apply type
+                    node: /** @type {RuleNode} */ (node),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+
+            if (node.type === "ExportAllDeclaration") {
+                for (const key of Object.keys(nextTraceMap)) {
+                    const exportTraceMap = nextTraceMap[key];
+                    if (exportTraceMap[READ]) {
+                        yield {
+                            // eslint-disable-next-line object-shorthand -- apply type
+                            node: /** @type {RuleNode} */ (node),
+                            path: path.concat(key),
+                            type: READ,
+                            info: exportTraceMap[READ],
+                        };
+                    }
+                }
+            } else {
+                for (const specifier of node.specifiers) {
+                    const esm = has(nextTraceMap, ESM);
+                    const it = this._iterateImportReferences(
+                        specifier,
+                        path,
+                        esm
+                            ? nextTraceMap
+                            : this.mode === "legacy"
+                            ? { default: nextTraceMap, ...nextTraceMap }
+                            : { default: nextTraceMap },
+                    );
+
+                    if (esm) {
+                        yield* it;
+                    } else {
+                        for (const report of it) {
+                            report.path = report.path.filter(exceptDefault);
+                            if (
+                                report.path.length >= 2 ||
+                                report.type !== READ
+                            ) {
+                                yield report;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Iterate the property references for a given expression AST node.
+     * @template T
+     * @param {Expression} node The expression AST node to iterate property references.
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate property references.
+     */
+    *iteratePropertyReferences(node, traceMap) {
+        yield* this._iteratePropertyReferences(node, [], traceMap);
+    }
+
+    /**
+     * Iterate the references for a given variable.
+     * @private
+     * @template T
+     * @param {Variable} variable The variable to iterate that references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @param {boolean} shouldReport = The flag to report those references.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateVariableReferences(variable, path, traceMap, shouldReport) {
+        if (this.variableStack.includes(variable)) {
+            return
+        }
+        this.variableStack.push(variable);
+        try {
+            for (const reference of variable.references) {
+                if (!reference.isRead()) {
+                    continue
+                }
+                const node = /** @type {RuleNode & Identifier} */ (
+                    reference.identifier
+                );
+
+                if (shouldReport && traceMap[READ]) {
+                    yield { node, path, type: READ, info: traceMap[READ] };
+                }
+                yield* this._iteratePropertyReferences(node, path, traceMap);
+            }
+        } finally {
+            this.variableStack.pop();
+        }
+    }
+
+    /**
+     * Iterate the references for a given AST node.
+     * @private
+     * @template T
+     * @param {Expression} rootNode The AST node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    //eslint-disable-next-line complexity
+    *_iteratePropertyReferences(rootNode, path, traceMap) {
+        let node = rootNode;
+        while (isPassThrough(node)) {
+            node = node.parent;
+        }
+
+        const parent = /** @type {RuleNode} */ (node).parent;
+        if (parent.type === "MemberExpression") {
+            if (parent.object === node) {
+                const key = getPropertyName(parent);
+                if (key == null || !has(traceMap, key)) {
+                    return
+                }
+
+                path = path.concat(key); //eslint-disable-line no-param-reassign
+                const nextTraceMap = traceMap[key];
+                if (nextTraceMap[READ]) {
+                    yield {
+                        node: parent,
+                        path,
+                        type: READ,
+                        info: nextTraceMap[READ],
+                    };
+                }
+                yield* this._iteratePropertyReferences(
+                    parent,
+                    path,
+                    nextTraceMap,
+                );
+            }
+            return
+        }
+        if (parent.type === "CallExpression") {
+            if (parent.callee === node && traceMap[CALL]) {
+                yield { node: parent, path, type: CALL, info: traceMap[CALL] };
+            }
+            return
+        }
+        if (parent.type === "NewExpression") {
+            if (parent.callee === node && traceMap[CONSTRUCT]) {
+                yield {
+                    node: parent,
+                    path,
+                    type: CONSTRUCT,
+                    info: traceMap[CONSTRUCT],
+                };
+            }
+            return
+        }
+        if (parent.type === "AssignmentExpression") {
+            if (parent.right === node) {
+                yield* this._iterateLhsReferences(parent.left, path, traceMap);
+                yield* this._iteratePropertyReferences(parent, path, traceMap);
+            }
+            return
+        }
+        if (parent.type === "AssignmentPattern") {
+            if (parent.right === node) {
+                yield* this._iterateLhsReferences(parent.left, path, traceMap);
+            }
+            return
+        }
+        if (parent.type === "VariableDeclarator") {
+            if (parent.init === node) {
+                yield* this._iterateLhsReferences(parent.id, path, traceMap);
+            }
+        }
+    }
+
+    /**
+     * Iterate the references for a given Pattern node.
+     * @private
+     * @template T
+     * @param {Pattern} patternNode The Pattern node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateLhsReferences(patternNode, path, traceMap) {
+        if (patternNode.type === "Identifier") {
+            const variable = findVariable(this.globalScope, patternNode);
+            if (variable != null) {
+                yield* this._iterateVariableReferences(
+                    variable,
+                    path,
+                    traceMap,
+                    false,
+                );
+            }
+            return
+        }
+        if (patternNode.type === "ObjectPattern") {
+            for (const property of patternNode.properties) {
+                const key = getPropertyName(
+                    /** @type {AssignmentProperty} */ (property),
+                );
+
+                if (key == null || !has(traceMap, key)) {
+                    continue
+                }
+
+                const nextPath = path.concat(key);
+                const nextTraceMap = traceMap[key];
+                if (nextTraceMap[READ]) {
+                    yield {
+                        node: /** @type {RuleNode} */ (property),
+                        path: nextPath,
+                        type: READ,
+                        info: nextTraceMap[READ],
+                    };
+                }
+                yield* this._iterateLhsReferences(
+                    /** @type {AssignmentProperty} */ (property).value,
+                    nextPath,
+                    nextTraceMap,
+                );
+            }
+            return
+        }
+        if (patternNode.type === "AssignmentPattern") {
+            yield* this._iterateLhsReferences(patternNode.left, path, traceMap);
+        }
+    }
+
+    /**
+     * Iterate the references for a given ModuleSpecifier node.
+     * @private
+     * @template T
+     * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateImportReferences(specifierNode, path, traceMap) {
+        const type = specifierNode.type;
+
+        if (type === "ImportSpecifier" || type === "ImportDefaultSpecifier") {
+            const key =
+                type === "ImportDefaultSpecifier"
+                    ? "default"
+                    : specifierNode.imported.type === "Identifier"
+                    ? specifierNode.imported.name
+                    : specifierNode.imported.value;
+            if (!has(traceMap, key)) {
+                return
+            }
+
+            path = path.concat(key); //eslint-disable-line no-param-reassign
+            const nextTraceMap = traceMap[key];
+            if (nextTraceMap[READ]) {
+                yield {
+                    node: /** @type {RuleNode} */ (specifierNode),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (
+                    findVariable(this.globalScope, specifierNode.local)
+                ),
+                path,
+                nextTraceMap,
+                false,
+            );
+
+            return
+        }
+
+        if (type === "ImportNamespaceSpecifier") {
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (
+                    findVariable(this.globalScope, specifierNode.local)
+                ),
+                path,
+                traceMap,
+                false,
+            );
+            return
+        }
+
+        if (type === "ExportSpecifier") {
+            const key =
+                specifierNode.local.type === "Identifier"
+                    ? specifierNode.local.name
+                    : specifierNode.local.value;
+            if (!has(traceMap, key)) {
+                return
+            }
+
+            path = path.concat(key); //eslint-disable-line no-param-reassign
+            const nextTraceMap = traceMap[key];
+            if (nextTraceMap[READ]) {
+                yield {
+                    node: /** @type {RuleNode} */ (specifierNode),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+        }
+    }
+}
+
+ReferenceTracker.READ = READ;
+ReferenceTracker.CALL = CALL;
+ReferenceTracker.CONSTRUCT = CONSTRUCT;
+ReferenceTracker.ESM = ESM;
+
+/**
+ * This is a predicate function for Array#filter.
+ * @param {string} name A name part.
+ * @param {number} index The index of the name.
+ * @returns {boolean} `false` if it's default.
+ */
+function exceptDefault(name, index) {
+    return !(index === 1 && name === "default")
+}
+
+/** @typedef {import("./types.mjs").StaticValue} StaticValue */
+
+var index = {
+    CALL,
+    CONSTRUCT,
+    ESM,
+    findVariable,
+    getFunctionHeadLocation,
+    getFunctionNameWithKind,
+    getInnermostScope,
+    getPropertyName,
+    getStaticValue,
+    getStringIfConstant,
+    hasSideEffect,
+    isArrowToken,
+    isClosingBraceToken,
+    isClosingBracketToken,
+    isClosingParenToken,
+    isColonToken,
+    isCommaToken,
+    isCommentToken,
+    isNotArrowToken,
+    isNotClosingBraceToken,
+    isNotClosingBracketToken,
+    isNotClosingParenToken,
+    isNotColonToken,
+    isNotCommaToken,
+    isNotCommentToken,
+    isNotOpeningBraceToken,
+    isNotOpeningBracketToken,
+    isNotOpeningParenToken,
+    isNotSemicolonToken,
+    isOpeningBraceToken,
+    isOpeningBracketToken,
+    isOpeningParenToken,
+    isParenthesized,
+    isSemicolonToken,
+    PatternMatcher,
+    READ,
+    ReferenceTracker,
+};
+
+exports.CALL = CALL;
+exports.CONSTRUCT = CONSTRUCT;
+exports.ESM = ESM;
+exports.PatternMatcher = PatternMatcher;
+exports.READ = READ;
+exports.ReferenceTracker = ReferenceTracker;
+exports["default"] = index;
+exports.findVariable = findVariable;
+exports.getFunctionHeadLocation = getFunctionHeadLocation;
+exports.getFunctionNameWithKind = getFunctionNameWithKind;
+exports.getInnermostScope = getInnermostScope;
+exports.getPropertyName = getPropertyName;
+exports.getStaticValue = getStaticValue;
+exports.getStringIfConstant = getStringIfConstant;
+exports.hasSideEffect = hasSideEffect;
+exports.isArrowToken = isArrowToken;
+exports.isClosingBraceToken = isClosingBraceToken;
+exports.isClosingBracketToken = isClosingBracketToken;
+exports.isClosingParenToken = isClosingParenToken;
+exports.isColonToken = isColonToken;
+exports.isCommaToken = isCommaToken;
+exports.isCommentToken = isCommentToken;
+exports.isNotArrowToken = isNotArrowToken;
+exports.isNotClosingBraceToken = isNotClosingBraceToken;
+exports.isNotClosingBracketToken = isNotClosingBracketToken;
+exports.isNotClosingParenToken = isNotClosingParenToken;
+exports.isNotColonToken = isNotColonToken;
+exports.isNotCommaToken = isNotCommaToken;
+exports.isNotCommentToken = isNotCommentToken;
+exports.isNotOpeningBraceToken = isNotOpeningBraceToken;
+exports.isNotOpeningBracketToken = isNotOpeningBracketToken;
+exports.isNotOpeningParenToken = isNotOpeningParenToken;
+exports.isNotSemicolonToken = isNotSemicolonToken;
+exports.isOpeningBraceToken = isOpeningBraceToken;
+exports.isOpeningBracketToken = isOpeningBracketToken;
+exports.isOpeningParenToken = isOpeningParenToken;
+exports.isParenthesized = isParenthesized;
+exports.isSemicolonToken = isSemicolonToken;
+//# sourceMappingURL=index.js.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/index.mjs

@@ -0,0 +1,2453 @@
+import { getKeys, KEYS } from 'eslint-visitor-keys';
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+
+/**
+ * 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) {
+    const location = /** @type {[number, number]} */ (node.range)[0];
+
+    let scope = initialScope;
+    let found = false;
+    do {
+        found = false;
+        for (const childScope of scope.childScopes) {
+            const range = /** @type {[number, number]} */ (
+                childScope.block.range
+            );
+
+            if (range[0] <= location && location < range[1]) {
+                scope = childScope;
+                found = true;
+                break
+            }
+        }
+    } while (found)
+
+    return scope
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("eslint").Scope.Variable} Variable */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Find the variable of a given name.
+ * @param {Scope} initialScope The scope to start finding.
+ * @param {string|Identifier} 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) {
+    let name = "";
+    /** @type {Scope|null} */
+    let scope = initialScope;
+
+    if (typeof nameOrNode === "string") {
+        name = nameOrNode;
+    } else {
+        name = nameOrNode.name;
+        scope = getInnermostScope(scope, nameOrNode);
+    }
+
+    while (scope != null) {
+        const variable = scope.set.get(name);
+        if (variable != null) {
+            return variable
+        }
+        scope = scope.upper;
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("estree").Comment} Comment */
+/** @typedef {import("./types.mjs").ArrowToken} ArrowToken */
+/** @typedef {import("./types.mjs").CommaToken} CommaToken */
+/** @typedef {import("./types.mjs").SemicolonToken} SemicolonToken */
+/** @typedef {import("./types.mjs").ColonToken} ColonToken */
+/** @typedef {import("./types.mjs").OpeningParenToken} OpeningParenToken */
+/** @typedef {import("./types.mjs").ClosingParenToken} ClosingParenToken */
+/** @typedef {import("./types.mjs").OpeningBracketToken} OpeningBracketToken */
+/** @typedef {import("./types.mjs").ClosingBracketToken} ClosingBracketToken */
+/** @typedef {import("./types.mjs").OpeningBraceToken} OpeningBraceToken */
+/** @typedef {import("./types.mjs").ClosingBraceToken} ClosingBraceToken */
+/**
+ * @template {string} Value
+ * @typedef {import("./types.mjs").PunctuatorToken<Value>} PunctuatorToken
+ */
+
+/** @typedef {Comment | Token} CommentOrToken */
+
+/**
+ * Creates the negate function of the given function.
+ * @param {function(CommentOrToken):boolean} f - The function to negate.
+ * @returns {function(CommentOrToken):boolean} Negated function.
+ */
+function negate(f) {
+    return (token) => !f(token)
+}
+
+/**
+ * Checks if the given token is a PunctuatorToken with the given value
+ * @template {string} Value
+ * @param {CommentOrToken} token - The token to check.
+ * @param {Value} value - The value to check.
+ * @returns {token is PunctuatorToken<Value>} `true` if the token is a PunctuatorToken with the given value.
+ */
+function isPunctuatorTokenWithValue(token, value) {
+    return token.type === "Punctuator" && token.value === value
+}
+
+/**
+ * Checks if the given token is an arrow token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ArrowToken} `true` if the token is an arrow token.
+ */
+function isArrowToken(token) {
+    return isPunctuatorTokenWithValue(token, "=>")
+}
+
+/**
+ * Checks if the given token is a comma token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is CommaToken} `true` if the token is a comma token.
+ */
+function isCommaToken(token) {
+    return isPunctuatorTokenWithValue(token, ",")
+}
+
+/**
+ * Checks if the given token is a semicolon token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is SemicolonToken} `true` if the token is a semicolon token.
+ */
+function isSemicolonToken(token) {
+    return isPunctuatorTokenWithValue(token, ";")
+}
+
+/**
+ * Checks if the given token is a colon token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ColonToken} `true` if the token is a colon token.
+ */
+function isColonToken(token) {
+    return isPunctuatorTokenWithValue(token, ":")
+}
+
+/**
+ * Checks if the given token is an opening parenthesis token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token.
+ */
+function isOpeningParenToken(token) {
+    return isPunctuatorTokenWithValue(token, "(")
+}
+
+/**
+ * Checks if the given token is a closing parenthesis token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token.
+ */
+function isClosingParenToken(token) {
+    return isPunctuatorTokenWithValue(token, ")")
+}
+
+/**
+ * Checks if the given token is an opening square bracket token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token.
+ */
+function isOpeningBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "[")
+}
+
+/**
+ * Checks if the given token is a closing square bracket token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token.
+ */
+function isClosingBracketToken(token) {
+    return isPunctuatorTokenWithValue(token, "]")
+}
+
+/**
+ * Checks if the given token is an opening brace token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token.
+ */
+function isOpeningBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "{")
+}
+
+/**
+ * Checks if the given token is a closing brace token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token.
+ */
+function isClosingBraceToken(token) {
+    return isPunctuatorTokenWithValue(token, "}")
+}
+
+/**
+ * Checks if the given token is a comment token or not.
+ * @param {CommentOrToken} token - The token to check.
+ * @returns {token is Comment} `true` if the token is a comment token.
+ */
+function isCommentToken(token) {
+    return ["Block", "Line", "Shebang"].includes(token.type)
+}
+
+const isNotArrowToken = negate(isArrowToken);
+const isNotCommaToken = negate(isCommaToken);
+const isNotSemicolonToken = negate(isSemicolonToken);
+const isNotColonToken = negate(isColonToken);
+const isNotOpeningParenToken = negate(isOpeningParenToken);
+const isNotClosingParenToken = negate(isClosingParenToken);
+const isNotOpeningBracketToken = negate(isOpeningBracketToken);
+const isNotClosingBracketToken = negate(isClosingBracketToken);
+const isNotOpeningBraceToken = negate(isOpeningBraceToken);
+const isNotClosingBraceToken = negate(isClosingBraceToken);
+const isNotCommentToken = negate(isCommentToken);
+
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("estree").Function} FunctionNode */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Position} Position */
+
+/**
+ * Get the `(` token of the given function node.
+ * @param {FunctionExpression | FunctionDeclaration} node - The function node to get.
+ * @param {SourceCode} sourceCode - The source code object to get tokens.
+ * @returns {Token} `(` token.
+ */
+function getOpeningParenOfParams(node, sourceCode) {
+    return node.id
+        ? /** @type {Token} */ (
+              sourceCode.getTokenAfter(node.id, isOpeningParenToken)
+          )
+        : /** @type {Token} */ (
+              sourceCode.getFirstToken(node, isOpeningParenToken)
+          )
+}
+
+/**
+ * Get the location of the given function node for reporting.
+ * @param {FunctionNode} node - The function node to get.
+ * @param {SourceCode} sourceCode - The source code object to get tokens.
+ * @returns {SourceLocation|null} The location of the function node for reporting.
+ */
+function getFunctionHeadLocation(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+
+    /** @type {Position|null} */
+    let start = null;
+    /** @type {Position|null} */
+    let end = null;
+
+    if (node.type === "ArrowFunctionExpression") {
+        const arrowToken = /** @type {Token} */ (
+            sourceCode.getTokenBefore(node.body, isArrowToken)
+        );
+
+        start = arrowToken.loc.start;
+        end = arrowToken.loc.end;
+    } else if (
+        parent.type === "Property" ||
+        parent.type === "MethodDefinition" ||
+        parent.type === "PropertyDefinition"
+    ) {
+        start = /** @type {SourceLocation} */ (parent.loc).start;
+        end = getOpeningParenOfParams(node, sourceCode).loc.start;
+    } else {
+        start = /** @type {SourceLocation} */ (node.loc).start;
+        end = getOpeningParenOfParams(node, sourceCode).loc.start;
+    }
+
+    return {
+        start: { ...start },
+        end: { ...end },
+    }
+}
+
+/* globals globalThis, global, self, window */
+/** @typedef {import("./types.mjs").StaticValue} StaticValue */
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
+/** @typedef {import("@typescript-eslint/types").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */
+/** @typedef {import("@typescript-eslint/types").TSESTree.MemberExpression} MemberExpression */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Property} Property */
+/** @typedef {import("@typescript-eslint/types").TSESTree.RegExpLiteral} RegExpLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.BigIntLiteral} BigIntLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Literal} Literal */
+
+const globalObject =
+    typeof globalThis !== "undefined"
+        ? globalThis
+        : // @ts-ignore
+        typeof self !== "undefined"
+        ? // @ts-ignore
+          self
+        : // @ts-ignore
+        typeof window !== "undefined"
+        ? // @ts-ignore
+          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,
+        // @ts-ignore
+        isPrototypeOf,
+        Map,
+        Map.prototype.entries,
+        Map.prototype.get,
+        Map.prototype.has,
+        Map.prototype.keys,
+        Map.prototype.values,
+        .../** @type {(keyof typeof Math)[]} */ (
+            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,
+]);
+
+/** @type {ReadonlyArray<readonly [Function, ReadonlySet<string>]>} */
+const getterAllowed = [
+    [Map, new Set(["size"])],
+    [
+        RegExp,
+        new Set([
+            "dotAll",
+            "flags",
+            "global",
+            "hasIndices",
+            "ignoreCase",
+            "multiline",
+            "source",
+            "sticky",
+            "unicode",
+        ]),
+    ],
+    [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) {
+    let x = object;
+    while ((typeof x === "object" || typeof x === "function") && x !== null) {
+        const d = Object.getOwnPropertyDescriptor(x, name);
+        if (d) {
+            return d
+        }
+        x = Object.getPrototypeOf(x);
+    }
+    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) {
+    const d = getPropertyDescriptor(object, name);
+    return d != null && d.get != null
+}
+
+/**
+ * Get the element values of a given node list.
+ * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values.
+ * @param {Scope|undefined|null} initialScope The initial scope to find variables.
+ * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.
+ */
+function getElementValues(nodeList, initialScope) {
+    const valueList = [];
+
+    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
+            }
+            valueList.push(.../** @type {Iterable<any>} */ (argument.value));
+        } else {
+            const element = getStaticValueR(elementNode, initialScope);
+            if (element == null) {
+                return null
+            }
+            valueList.push(element.value);
+        }
+    }
+
+    return valueList
+}
+
+/**
+ * Returns whether the given variable is never written to after initialization.
+ * @param {import("eslint").Scope.Variable} variable
+ * @returns {boolean}
+ */
+function isEffectivelyConst(variable) {
+    const refs = variable.references;
+
+    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 false
+}
+
+/**
+ * @template {TSESTreeNodeTypes} T
+ * @callback VisitorCallback
+ * @param {TSESTreeNode & { type: T }} node
+ * @param {Scope|undefined|null} initialScope
+ * @returns {StaticValue | null}
+ */
+/**
+ * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback<K> } } Operations
+ */
+/**
+ * @type {Operations}
+ */
+const operations = Object.freeze({
+    ArrayExpression(node, initialScope) {
+        const elements = getElementValues(node.elements, initialScope);
+        return elements != null ? { value: elements } : null
+    },
+
+    AssignmentExpression(node, initialScope) {
+        if (node.operator === "=") {
+            return getStaticValueR(node.right, initialScope)
+        }
+        return null
+    },
+
+    //eslint-disable-next-line complexity
+    BinaryExpression(node, initialScope) {
+        if (node.operator === "in" || node.operator === "instanceof") {
+            // Not supported.
+            return null
+        }
+
+        const left = getStaticValueR(node.left, initialScope);
+        const right = getStaticValueR(node.right, initialScope);
+        if (left != null && right != null) {
+            switch (node.operator) {
+                case "==":
+                    return { value: left.value == right.value } //eslint-disable-line eqeqeq
+                case "!=":
+                    return { value: left.value != right.value } //eslint-disable-line eqeqeq
+                case "===":
+                    return { value: left.value === right.value }
+                case "!==":
+                    return { value: left.value !== right.value }
+                case "<":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <
+                            /** @type {any} */ (right.value),
+                    }
+                case "<=":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <=
+                            /** @type {any} */ (right.value),
+                    }
+                case ">":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >
+                            /** @type {any} */ (right.value),
+                    }
+                case ">=":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >=
+                            /** @type {any} */ (right.value),
+                    }
+                case "<<":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) <<
+                            /** @type {any} */ (right.value),
+                    }
+                case ">>":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >>
+                            /** @type {any} */ (right.value),
+                    }
+                case ">>>":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) >>>
+                            /** @type {any} */ (right.value),
+                    }
+                case "+":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) +
+                            /** @type {any} */ (right.value),
+                    }
+                case "-":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) -
+                            /** @type {any} */ (right.value),
+                    }
+                case "*":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) *
+                            /** @type {any} */ (right.value),
+                    }
+                case "/":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) /
+                            /** @type {any} */ (right.value),
+                    }
+                case "%":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) %
+                            /** @type {any} */ (right.value),
+                    }
+                case "**":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) **
+                            /** @type {any} */ (right.value),
+                    }
+                case "|":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) |
+                            /** @type {any} */ (right.value),
+                    }
+                case "^":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) ^
+                            /** @type {any} */ (right.value),
+                    }
+                case "&":
+                    return {
+                        value:
+                            /** @type {any} */ (left.value) &
+                            /** @type {any} */ (right.value),
+                    }
+
+                // no default
+            }
+        }
+
+        return null
+    },
+
+    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
+                }
+                const object = getStaticValueR(calleeNode.object, initialScope);
+                if (object != null) {
+                    if (
+                        object.value == null &&
+                        (object.optional || node.optional)
+                    ) {
+                        return { value: undefined, optional: true }
+                    }
+                    const property = getStaticPropertyNameValue(
+                        calleeNode,
+                        initialScope,
+                    );
+
+                    if (property != null) {
+                        const receiver =
+                            /** @type {Record<PropertyKey, (...args: any[]) => any>} */ (
+                                object.value
+                            );
+                        const methodName = /** @type {PropertyKey} */ (
+                            property.value
+                        );
+                        if (callAllowed.has(receiver[methodName])) {
+                            return {
+                                value: receiver[methodName](...args),
+                            }
+                        }
+                        if (callPassThrough.has(receiver[methodName])) {
+                            return { value: args[0] }
+                        }
+                    }
+                }
+            } else {
+                const callee = getStaticValueR(calleeNode, initialScope);
+                if (callee != null) {
+                    if (callee.value == null && node.optional) {
+                        return { value: undefined, optional: true }
+                    }
+                    const func = /** @type {(...args: any[]) => any} */ (
+                        callee.value
+                    );
+                    if (callAllowed.has(func)) {
+                        return { value: func(...args) }
+                    }
+                    if (callPassThrough.has(func)) {
+                        return { value: args[0] }
+                    }
+                }
+            }
+        }
+
+        return null
+    },
+
+    ConditionalExpression(node, initialScope) {
+        const test = getStaticValueR(node.test, initialScope);
+        if (test != null) {
+            return test.value
+                ? getStaticValueR(node.consequent, initialScope)
+                : getStaticValueR(node.alternate, initialScope)
+        }
+        return null
+    },
+
+    ExpressionStatement(node, initialScope) {
+        return getStaticValueR(node.expression, 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] }
+            }
+
+            // 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)
+                }
+            }
+        }
+        return null
+    },
+
+    Literal(node) {
+        const literal =
+            /** @type {Partial<Literal> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
+                node
+            );
+        //istanbul ignore if : this is implementation-specific behavior.
+        if (
+            (literal.regex != null || literal.bigint != null) &&
+            literal.value == null
+        ) {
+            // It was a RegExp/BigInt literal, but Node.js didn't support it.
+            return null
+        }
+        return { value: literal.value }
+    },
+
+    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
+            }
+
+            const right = getStaticValueR(node.right, initialScope);
+            if (right != null) {
+                return right
+            }
+        }
+
+        return null
+    },
+
+    MemberExpression(node, initialScope) {
+        if (node.property.type === "PrivateIdentifier") {
+            return null
+        }
+        const object = getStaticValueR(node.object, initialScope);
+        if (object != null) {
+            if (object.value == null && (object.optional || node.optional)) {
+                return { value: undefined, optional: true }
+            }
+            const property = getStaticPropertyNameValue(node, initialScope);
+
+            if (property != null) {
+                if (
+                    !isGetter(
+                        /** @type {object} */ (object.value),
+                        /** @type {PropertyKey} */ (property.value),
+                    )
+                ) {
+                    return {
+                        value: /** @type {Record<PropertyKey, unknown>} */ (
+                            object.value
+                        )[/** @type {PropertyKey} */ (property.value)],
+                    }
+                }
+
+                for (const [classFn, allowed] of getterAllowed) {
+                    if (
+                        object.value instanceof classFn &&
+                        allowed.has(/** @type {string} */ (property.value))
+                    ) {
+                        return {
+                            value: /** @type {Record<PropertyKey, unknown>} */ (
+                                object.value
+                            )[/** @type {PropertyKey} */ (property.value)],
+                        }
+                    }
+                }
+            }
+        }
+        return null
+    },
+
+    ChainExpression(node, initialScope) {
+        const expression = getStaticValueR(node.expression, initialScope);
+        if (expression != null) {
+            return { value: expression.value }
+        }
+        return null
+    },
+
+    NewExpression(node, initialScope) {
+        const callee = getStaticValueR(node.callee, initialScope);
+        const args = getElementValues(node.arguments, initialScope);
+
+        if (callee != null && args != null) {
+            const Func = /** @type {new (...args: any[]) => any} */ (
+                callee.value
+            );
+            if (callAllowed.has(Func)) {
+                return { value: new Func(...args) }
+            }
+        }
+
+        return null
+    },
+
+    ObjectExpression(node, initialScope) {
+        /** @type {Record<PropertyKey, unknown>} */
+        const object = {};
+
+        for (const propertyNode of node.properties) {
+            if (propertyNode.type === "Property") {
+                if (propertyNode.kind !== "init") {
+                    return null
+                }
+                const key = getStaticPropertyNameValue(
+                    propertyNode,
+                    initialScope,
+                );
+                const value = getStaticValueR(propertyNode.value, initialScope);
+                if (key == null || value == null) {
+                    return null
+                }
+                object[/** @type {PropertyKey} */ (key.value)] = value.value;
+            } else if (
+                propertyNode.type === "SpreadElement" ||
+                // @ts-expect-error -- Backward compatibility
+                propertyNode.type === "ExperimentalSpreadProperty"
+            ) {
+                const argument = getStaticValueR(
+                    propertyNode.argument,
+                    initialScope,
+                );
+                if (argument == null) {
+                    return null
+                }
+                Object.assign(object, argument.value);
+            } else {
+                return null
+            }
+        }
+
+        return { value: object }
+    },
+
+    SequenceExpression(node, initialScope) {
+        const last = node.expressions[node.expressions.length - 1];
+        return getStaticValueR(last, initialScope)
+    },
+
+    TaggedTemplateExpression(node, initialScope) {
+        const tag = getStaticValueR(node.tag, initialScope);
+        const expressions = getElementValues(
+            node.quasi.expressions,
+            initialScope,
+        );
+
+        if (tag != null && expressions != null) {
+            const func = /** @type {(...args: any[]) => any} */ (tag.value);
+            /** @type {any[] & { raw?: string[] }} */
+            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 null
+    },
+
+    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) {
+                value += expressions[i];
+                value += /** @type {string} */ (node.quasis[i + 1].value.cooked);
+            }
+            return { value }
+        }
+        return null
+    },
+
+    UnaryExpression(node, initialScope) {
+        if (node.operator === "delete") {
+            // Not supported.
+            return null
+        }
+        if (node.operator === "void") {
+            return { value: undefined }
+        }
+
+        const arg = getStaticValueR(node.argument, initialScope);
+        if (arg != null) {
+            switch (node.operator) {
+                case "-":
+                    return { value: -(/** @type {any} */ (arg.value)) }
+                case "+":
+                    return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion
+                case "!":
+                    return { value: !arg.value }
+                case "~":
+                    return { value: ~(/** @type {any} */ (arg.value)) }
+                case "typeof":
+                    return { value: typeof arg.value }
+
+                // no default
+            }
+        }
+
+        return null
+    },
+    TSAsExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSSatisfiesExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSTypeAssertion(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSNonNullExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSInstantiationExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+});
+
+/**
+ * Get the value of a given node if it's a static value.
+ * @param {Node|TSESTreeNode|null|undefined} node The node to get.
+ * @param {Scope|undefined|null} initialScope The scope to start finding variable.
+ * @returns {StaticValue|null} The static value of the node, or `null`.
+ */
+function getStaticValueR(node, initialScope) {
+    if (node != null && Object.hasOwnProperty.call(operations, node.type)) {
+        return /** @type {VisitorCallback<any>} */ (operations[node.type])(
+            /** @type {TSESTreeNode} */ (node),
+            initialScope,
+        )
+    }
+    return null
+}
+
+/**
+ * Get the static value of property name from a MemberExpression node or a Property node.
+ * @param {MemberExpression|Property} node The node to get.
+ * @param {Scope|null} [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 {StaticValue|null} The static value of the property name of the node, or `null`.
+ */
+function getStaticPropertyNameValue(node, initialScope) {
+    const nameNode = node.type === "Property" ? node.key : node.property;
+
+    if (node.computed) {
+        return getStaticValueR(nameNode, initialScope)
+    }
+
+    if (nameNode.type === "Identifier") {
+        return { value: nameNode.name }
+    }
+
+    if (nameNode.type === "Literal") {
+        if (/** @type {Partial<BigIntLiteral>} */ (nameNode).bigint) {
+            return { value: /** @type {BigIntLiteral} */ (nameNode).bigint }
+        }
+        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|null} [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 {StaticValue | null} The static value of the node, or `null`.
+ */
+function getStaticValue(node, initialScope = null) {
+    try {
+        return getStaticValueR(node, initialScope)
+    } catch (_error) {
+        return null
+    }
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").RegExpLiteral} RegExpLiteral */
+/** @typedef {import("estree").BigIntLiteral} BigIntLiteral */
+/** @typedef {import("estree").SimpleLiteral} SimpleLiteral */
+
+/**
+ * Get the value of a given node if it's a literal or a template literal.
+ * @param {Node} node The node to get.
+ * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.
+ * @returns {string|null} The value of the node, or `null`.
+ */
+function getStringIfConstant(node, initialScope = null) {
+    // Handle the literals that the platform doesn't support natively.
+    if (node && node.type === "Literal" && node.value === null) {
+        const literal =
+            /** @type {Partial<SimpleLiteral> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
+                node
+            );
+        if (literal.regex) {
+            return `/${literal.regex.pattern}/${literal.regex.flags}`
+        }
+        if (literal.bigint) {
+            return literal.bigint
+        }
+    }
+
+    const evaluated = getStaticValue(node, initialScope);
+
+    if (evaluated) {
+        // `String(Symbol.prototype)` throws error
+        try {
+            return String(evaluated.value)
+        } catch {
+            // No op
+        }
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").MethodDefinition} MethodDefinition */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Get the property name from a MemberExpression node or a Property node.
+ * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} 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 {string|null|undefined} The property name of the node.
+ */
+function getPropertyName(node, initialScope) {
+    switch (node.type) {
+        case "MemberExpression":
+            if (node.computed) {
+                return getStringIfConstant(node.property, initialScope)
+            }
+            if (node.property.type === "PrivateIdentifier") {
+                return null
+            }
+            return /** @type {Partial<Identifier>} */ (node.property).name
+
+        case "Property":
+        case "MethodDefinition":
+        case "PropertyDefinition":
+            if (node.computed) {
+                return getStringIfConstant(node.key, initialScope)
+            }
+            if (node.key.type === "Literal") {
+                return String(node.key.value)
+            }
+            if (node.key.type === "PrivateIdentifier") {
+                return null
+            }
+            return /** @type {Partial<Identifier>} */ (node.key).name
+    }
+
+    return null
+}
+
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("estree").Function} FunctionNode */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").Identifier} Identifier */
+
+/**
+ * Get the name and kind of the given function node.
+ * @param {FunctionNode} node - The function node to get.
+ * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys.
+ * @returns {string} The name and kind of the function node.
+ */
+// eslint-disable-next-line complexity
+function getFunctionNameWithKind(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+    const tokens = [];
+    const isObjectMethod = parent.type === "Property" && parent.value === node;
+    const isClassMethod =
+        parent.type === "MethodDefinition" && parent.value === node;
+    const isClassFieldMethod =
+        parent.type === "PropertyDefinition" && parent.value === node;
+
+    // Modifiers.
+    if (isClassMethod || isClassFieldMethod) {
+        if (parent.static) {
+            tokens.push("static");
+        }
+        if (parent.key.type === "PrivateIdentifier") {
+            tokens.push("private");
+        }
+    }
+    if (node.async) {
+        tokens.push("async");
+    }
+    if (node.generator) {
+        tokens.push("generator");
+    }
+
+    // Kinds.
+    if (isObjectMethod || isClassMethod) {
+        if (parent.kind === "constructor") {
+            return "constructor"
+        }
+        if (parent.kind === "get") {
+            tokens.push("getter");
+        } else if (parent.kind === "set") {
+            tokens.push("setter");
+        } else {
+            tokens.push("method");
+        }
+    } else if (isClassFieldMethod) {
+        tokens.push("method");
+    } else {
+        if (node.type === "ArrowFunctionExpression") {
+            tokens.push("arrow");
+        }
+        tokens.push("function");
+    }
+
+    // Names.
+    if (isObjectMethod || isClassMethod || isClassFieldMethod) {
+        if (parent.key.type === "PrivateIdentifier") {
+            tokens.push(`#${parent.key.name}`);
+        } else {
+            const name = getPropertyName(parent);
+            if (name) {
+                tokens.push(`'${name}'`);
+            } else if (sourceCode) {
+                const keyText = sourceCode.getText(parent.key);
+                if (!keyText.includes("\n")) {
+                    tokens.push(`[${keyText}]`);
+                }
+            }
+        }
+    } else if (hasId(node)) {
+        tokens.push(`'${node.id.name}'`);
+    } else if (
+        parent.type === "VariableDeclarator" &&
+        parent.id &&
+        parent.id.type === "Identifier"
+    ) {
+        tokens.push(`'${parent.id.name}'`);
+    } else if (
+        (parent.type === "AssignmentExpression" ||
+            parent.type === "AssignmentPattern") &&
+        parent.left &&
+        parent.left.type === "Identifier"
+    ) {
+        tokens.push(`'${parent.left.name}'`);
+    } else if (
+        parent.type === "ExportDefaultDeclaration" &&
+        parent.declaration === node
+    ) {
+        tokens.push("'default'");
+    }
+
+    return tokens.join(" ")
+}
+
+/**
+ * @param {FunctionNode} node
+ * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }}
+ */
+function hasId(node) {
+    return Boolean(
+        /** @type {Partial<FunctionDeclaration | FunctionExpression>} */ (node)
+            .id,
+    )
+}
+
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("./types.mjs").HasSideEffectOptions} HasSideEffectOptions */
+/** @typedef {import("estree").BinaryExpression} BinaryExpression */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").MethodDefinition} MethodDefinition */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
+/** @typedef {import("estree").UnaryExpression} UnaryExpression */
+
+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 {x is Node} `true` if the value is an ASTNode.
+ */
+function isNode(x) {
+    return x !== null && typeof x === "object" && typeof x.type === "string"
+}
+
+const visitor = Object.freeze(
+    Object.assign(Object.create(null), {
+        /**
+         * @param {Node} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        $visit(node, options, visitorKeys) {
+            const { type } = node;
+
+            if (typeof (/** @type {any} */ (this)[type]) === "function") {
+                return /** @type {any} */ (this)[type](
+                    node,
+                    options,
+                    visitorKeys,
+                )
+            }
+
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+
+        /**
+         * @param {Node} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        $visitChildren(node, options, visitorKeys) {
+            const { type } = node;
+
+            for (const key of /** @type {(keyof Node)[]} */ (
+                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
+        },
+        /**
+         * @param {BinaryExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        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
+        },
+        /**
+         * @param {MemberExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        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)
+        },
+        /**
+         * @param {MethodDefinition} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} 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
+        },
+        /**
+         * @param {Property} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        Property(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        /**
+         * @param {PropertyDefinition} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} visitorKeys
+         */
+        PropertyDefinition(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        /**
+         * @param {UnaryExpression} node
+         * @param {HasSideEffectOptions} options
+         * @param {Record<string, string[]>} 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
+        },
+    }),
+);
+
+/**
+ * Check whether a given node has any side effect or not.
+ * @param {Node} node The node to get.
+ * @param {SourceCode} sourceCode The source code object.
+ * @param {HasSideEffectOptions} [options] The option object.
+ * @returns {boolean} `true` if the node has a certain side effect.
+ */
+function hasSideEffect(node, sourceCode, options = {}) {
+    const { considerGetters = false, considerImplicitTypeConversion = false } =
+        options;
+    return visitor.$visit(
+        node,
+        { considerGetters, considerImplicitTypeConversion },
+        sourceCode.visitorKeys || KEYS,
+    )
+}
+
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("eslint").SourceCode} SourceCode */
+/** @typedef {import("eslint").AST.Token} Token */
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+
+/**
+ * Get the left parenthesis of the parent node syntax if it exists.
+ * E.g., `if (a) {}` then the `(`.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {Token|null} The left parenthesis of the parent node syntax
+ */
+function getParentSyntaxParen(node, sourceCode) {
+    const parent = /** @type {RuleNode} */ (node).parent;
+
+    switch (parent.type) {
+        case "CallExpression":
+        case "NewExpression":
+            if (parent.arguments.length === 1 && parent.arguments[0] === node) {
+                return sourceCode.getTokenAfter(
+                    parent.callee,
+                    isOpeningParenToken,
+                )
+            }
+            return null
+
+        case "DoWhileStatement":
+            if (parent.test === node) {
+                return sourceCode.getTokenAfter(
+                    parent.body,
+                    isOpeningParenToken,
+                )
+            }
+            return null
+
+        case "IfStatement":
+        case "WhileStatement":
+            if (parent.test === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "ImportExpression":
+            if (parent.source === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "SwitchStatement":
+            if (parent.discriminant === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        case "WithStatement":
+            if (parent.object === node) {
+                return sourceCode.getFirstToken(parent, 1)
+            }
+            return null
+
+        default:
+            return null
+    }
+}
+
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {number} times The number of parantheses.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {boolean} `true` if the node is parenthesized the given times.
+ */
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {Node} node The AST node to check.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {boolean} `true` if the node is parenthesized.
+ */
+/**
+ * Check whether a given node is parenthesized or not.
+ * @param {Node|number} timesOrNode The first parameter.
+ * @param {Node|SourceCode} nodeOrSourceCode The second parameter.
+ * @param {SourceCode} [optionalSourceCode] The third parameter.
+ * @returns {boolean} `true` if the node is parenthesized.
+ */
+function isParenthesized(
+    timesOrNode,
+    nodeOrSourceCode,
+    optionalSourceCode,
+) {
+    /** @type {number} */
+    let times,
+        /** @type {RuleNode} */
+        node,
+        /** @type {SourceCode} */
+        sourceCode,
+        maybeLeftParen,
+        maybeRightParen;
+    if (typeof timesOrNode === "number") {
+        times = timesOrNode | 0;
+        node = /** @type {RuleNode} */ (nodeOrSourceCode);
+        sourceCode = /** @type {SourceCode} */ (optionalSourceCode);
+        if (!(times >= 1)) {
+            throw new TypeError("'times' should be a positive integer.")
+        }
+    } else {
+        times = 1;
+        node = /** @type {RuleNode} */ (timesOrNode);
+        sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode);
+    }
+
+    if (
+        node == null ||
+        // `Program` can't be parenthesized
+        node.parent == null ||
+        // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`
+        (node.parent.type === "CatchClause" && node.parent.param === node)
+    ) {
+        return false
+    }
+
+    maybeLeftParen = maybeRightParen = node;
+    do {
+        maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen);
+        maybeRightParen = sourceCode.getTokenAfter(maybeRightParen);
+    } while (
+        maybeLeftParen != null &&
+        maybeRightParen != null &&
+        isOpeningParenToken(maybeLeftParen) &&
+        isClosingParenToken(maybeRightParen) &&
+        // Avoid false positive such as `if (a) {}`
+        maybeLeftParen !== getParentSyntaxParen(node, sourceCode) &&
+        --times > 0
+    )
+
+    return times === 0
+}
+
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+const placeholder = /\$(?:[$&`']|[1-9][0-9]?)/gu;
+
+/** @type {WeakMap<PatternMatcher, {pattern:RegExp,escaped:boolean}>} */
+const internal = new WeakMap();
+
+/**
+ * Check whether a given character is escaped or not.
+ * @param {string} str The string to check.
+ * @param {number} index The location of the character to check.
+ * @returns {boolean} `true` if the character is escaped.
+ */
+function isEscaped(str, index) {
+    let escaped = false;
+    for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) {
+        escaped = !escaped;
+    }
+    return escaped
+}
+
+/**
+ * Replace a given string by a given matcher.
+ * @param {PatternMatcher} matcher The pattern matcher.
+ * @param {string} str The string to be replaced.
+ * @param {string} replacement The new substring to replace each matched part.
+ * @returns {string} The replaced string.
+ */
+function replaceS(matcher, str, replacement) {
+    const chunks = [];
+    let index = 0;
+
+    /**
+     * @param {string} key The placeholder.
+     * @param {RegExpExecArray} match The matched information.
+     * @returns {string} The replaced string.
+     */
+    function replacer(key, match) {
+        switch (key) {
+            case "$$":
+                return "$"
+            case "$&":
+                return match[0]
+            case "$`":
+                return str.slice(0, match.index)
+            case "$'":
+                return str.slice(match.index + match[0].length)
+            default: {
+                const i = key.slice(1);
+                if (i in match) {
+                    return match[/** @type {any} */ (i)]
+                }
+                return key
+            }
+        }
+    }
+
+    for (const match of matcher.execAll(str)) {
+        chunks.push(str.slice(index, match.index));
+        chunks.push(
+            replacement.replace(placeholder, (key) => replacer(key, match)),
+        );
+        index = match.index + match[0].length;
+    }
+    chunks.push(str.slice(index));
+
+    return chunks.join("")
+}
+
+/**
+ * Replace a given string by a given matcher.
+ * @param {PatternMatcher} matcher The pattern matcher.
+ * @param {string} str The string to be replaced.
+ * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part.
+ * @returns {string} The replaced string.
+ */
+function replaceF(matcher, str, replace) {
+    const chunks = [];
+    let index = 0;
+
+    for (const match of matcher.execAll(str)) {
+        chunks.push(str.slice(index, match.index));
+        chunks.push(
+            String(
+                replace(
+                    .../** @type {[string, ...string[]]} */ (
+                        /** @type {string[]} */ (match)
+                    ),
+                    match.index,
+                    match.input,
+                ),
+            ),
+        );
+        index = match.index + match[0].length;
+    }
+    chunks.push(str.slice(index));
+
+    return chunks.join("")
+}
+
+/**
+ * The class to find patterns as considering escape sequences.
+ */
+class PatternMatcher {
+    /**
+     * Initialize this matcher.
+     * @param {RegExp} pattern The pattern to match.
+     * @param {{escaped?:boolean}} [options] The options.
+     */
+    constructor(pattern, options = {}) {
+        const { escaped = false } = options;
+        if (!(pattern instanceof RegExp)) {
+            throw new TypeError("'pattern' should be a RegExp instance.")
+        }
+        if (!pattern.flags.includes("g")) {
+            throw new Error("'pattern' should contains 'g' flag.")
+        }
+
+        internal.set(this, {
+            pattern: new RegExp(pattern.source, pattern.flags),
+            escaped: Boolean(escaped),
+        });
+    }
+
+    /**
+     * Find the pattern in a given string.
+     * @param {string} str The string to find.
+     * @returns {IterableIterator<RegExpExecArray>} The iterator which iterate the matched information.
+     */
+    *execAll(str) {
+        const { pattern, escaped } =
+            /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this));
+        let match = null;
+        let lastIndex = 0;
+
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(str)) != null) {
+            if (escaped || !isEscaped(str, match.index)) {
+                lastIndex = pattern.lastIndex;
+                yield match;
+                pattern.lastIndex = lastIndex;
+            }
+        }
+    }
+
+    /**
+     * Check whether the pattern is found in a given string.
+     * @param {string} str The string to check.
+     * @returns {boolean} `true` if the pattern was found in the string.
+     */
+    test(str) {
+        const it = this.execAll(str);
+        const ret = it.next();
+        return !ret.done
+    }
+
+    /**
+     * Replace a given string.
+     * @param {string} str The string to be replaced.
+     * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.
+     * @returns {string} The replaced string.
+     */
+    [Symbol.replace](str, replacer) {
+        return typeof replacer === "function"
+            ? replaceF(this, String(str), replacer)
+            : replaceS(this, String(str), String(replacer))
+    }
+}
+
+/** @typedef {import("eslint").Scope.Scope} Scope */
+/** @typedef {import("eslint").Scope.Variable} Variable */
+/** @typedef {import("eslint").Rule.Node} RuleNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").SimpleCallExpression} CallExpression */
+/** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
+/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
+/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
+/** @typedef {import("estree").ExportSpecifier} ExportSpecifier */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
+/** @typedef {import("./types.mjs").ReferenceTrackerOptions} ReferenceTrackerOptions */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TraceMap<T>} TraceMap
+ */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TraceMapObject<T>} TraceMapObject
+ */
+/**
+ * @template T
+ * @typedef {import("./types.mjs").TrackedReferences<T>} TrackedReferences
+ */
+
+const IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u;
+
+/**
+ * Check whether a given node is an import node or not.
+ * @param {Node} node
+ * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node.
+ */
+function isHasSource(node) {
+    return (
+        IMPORT_TYPE.test(node.type) &&
+        /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ (
+            node
+        ).source != null
+    )
+}
+const has =
+    /** @type {<T>(traceMap: TraceMap<unknown>, v: T) => v is (string extends T ? string : T)} */ (
+        Function.call.bind(Object.hasOwnProperty)
+    );
+
+const READ = Symbol("read");
+const CALL = Symbol("call");
+const CONSTRUCT = Symbol("construct");
+const ESM = Symbol("esm");
+
+const requireCall = { require: { [CALL]: true } };
+
+/**
+ * Check whether a given variable is modified or not.
+ * @param {Variable|undefined} variable The variable to check.
+ * @returns {boolean} `true` if the variable is modified.
+ */
+function isModifiedGlobal(variable) {
+    return (
+        variable == null ||
+        variable.defs.length !== 0 ||
+        variable.references.some((r) => r.isWrite())
+    )
+}
+
+/**
+ * Check if the value of a given node is passed through to the parent syntax as-is.
+ * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.
+ * @param {Node} node A node to check.
+ * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through.
+ */
+function isPassThrough(node) {
+    const parent = /** @type {TSESTreeNode} */ (node).parent;
+
+    if (parent) {
+        switch (parent.type) {
+            case "ConditionalExpression":
+                return parent.consequent === node || parent.alternate === node
+            case "LogicalExpression":
+                return true
+            case "SequenceExpression":
+                return (
+                    parent.expressions[parent.expressions.length - 1] === node
+                )
+            case "ChainExpression":
+                return true
+            case "TSAsExpression":
+            case "TSSatisfiesExpression":
+            case "TSTypeAssertion":
+            case "TSNonNullExpression":
+            case "TSInstantiationExpression":
+                return true
+
+            default:
+                return false
+        }
+    }
+    return false
+}
+
+/**
+ * The reference tracker.
+ */
+class ReferenceTracker {
+    /**
+     * Initialize this tracker.
+     * @param {Scope} globalScope The global scope.
+     * @param {object} [options] The options.
+     * @param {"legacy"|"strict"} [options.mode="strict"] The mode to determine the ImportDeclaration's behavior for CJS modules.
+     * @param {string[]} [options.globalObjectNames=["global","globalThis","self","window"]] The variable names for Global Object.
+     */
+    constructor(globalScope, options = {}) {
+        const {
+            mode = "strict",
+            globalObjectNames = ["global", "globalThis", "self", "window"],
+        } = options;
+        /** @private @type {Variable[]} */
+        this.variableStack = [];
+        /** @private */
+        this.globalScope = globalScope;
+        /** @private */
+        this.mode = mode;
+        /** @private */
+        this.globalObjectNames = globalObjectNames.slice(0);
+    }
+
+    /**
+     * Iterate the references of global variables.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateGlobalReferences(traceMap) {
+        for (const key of Object.keys(traceMap)) {
+            const nextTraceMap = traceMap[key];
+            const path = [key];
+            const variable = this.globalScope.set.get(key);
+
+            if (isModifiedGlobal(variable)) {
+                continue
+            }
+
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (variable),
+                path,
+                nextTraceMap,
+                true,
+            );
+        }
+
+        for (const key of this.globalObjectNames) {
+            /** @type {string[]} */
+            const path = [];
+            const variable = this.globalScope.set.get(key);
+
+            if (isModifiedGlobal(variable)) {
+                continue
+            }
+
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (variable),
+                path,
+                traceMap,
+                false,
+            );
+        }
+    }
+
+    /**
+     * Iterate the references of CommonJS modules.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateCjsReferences(traceMap) {
+        for (const { node } of this.iterateGlobalReferences(requireCall)) {
+            const key = getStringIfConstant(
+                /** @type {CallExpression} */ (node).arguments[0],
+            );
+            if (key == null || !has(traceMap, key)) {
+                continue
+            }
+
+            const nextTraceMap = traceMap[key];
+            const path = [key];
+
+            if (nextTraceMap[READ]) {
+                yield {
+                    node,
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+            yield* this._iteratePropertyReferences(
+                /** @type {CallExpression} */ (node),
+                path,
+                nextTraceMap,
+            );
+        }
+    }
+
+    /**
+     * Iterate the references of ES modules.
+     * @template T
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *iterateEsmReferences(traceMap) {
+        const programNode = /** @type {Program} */ (this.globalScope.block);
+
+        for (const node of programNode.body) {
+            if (!isHasSource(node)) {
+                continue
+            }
+            const moduleId = /** @type {string} */ (node.source.value);
+
+            if (!has(traceMap, moduleId)) {
+                continue
+            }
+            const nextTraceMap = traceMap[moduleId];
+            const path = [moduleId];
+
+            if (nextTraceMap[READ]) {
+                yield {
+                    // eslint-disable-next-line object-shorthand -- apply type
+                    node: /** @type {RuleNode} */ (node),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+
+            if (node.type === "ExportAllDeclaration") {
+                for (const key of Object.keys(nextTraceMap)) {
+                    const exportTraceMap = nextTraceMap[key];
+                    if (exportTraceMap[READ]) {
+                        yield {
+                            // eslint-disable-next-line object-shorthand -- apply type
+                            node: /** @type {RuleNode} */ (node),
+                            path: path.concat(key),
+                            type: READ,
+                            info: exportTraceMap[READ],
+                        };
+                    }
+                }
+            } else {
+                for (const specifier of node.specifiers) {
+                    const esm = has(nextTraceMap, ESM);
+                    const it = this._iterateImportReferences(
+                        specifier,
+                        path,
+                        esm
+                            ? nextTraceMap
+                            : this.mode === "legacy"
+                            ? { default: nextTraceMap, ...nextTraceMap }
+                            : { default: nextTraceMap },
+                    );
+
+                    if (esm) {
+                        yield* it;
+                    } else {
+                        for (const report of it) {
+                            report.path = report.path.filter(exceptDefault);
+                            if (
+                                report.path.length >= 2 ||
+                                report.type !== READ
+                            ) {
+                                yield report;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Iterate the property references for a given expression AST node.
+     * @template T
+     * @param {Expression} node The expression AST node to iterate property references.
+     * @param {TraceMap<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate property references.
+     */
+    *iteratePropertyReferences(node, traceMap) {
+        yield* this._iteratePropertyReferences(node, [], traceMap);
+    }
+
+    /**
+     * Iterate the references for a given variable.
+     * @private
+     * @template T
+     * @param {Variable} variable The variable to iterate that references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @param {boolean} shouldReport = The flag to report those references.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateVariableReferences(variable, path, traceMap, shouldReport) {
+        if (this.variableStack.includes(variable)) {
+            return
+        }
+        this.variableStack.push(variable);
+        try {
+            for (const reference of variable.references) {
+                if (!reference.isRead()) {
+                    continue
+                }
+                const node = /** @type {RuleNode & Identifier} */ (
+                    reference.identifier
+                );
+
+                if (shouldReport && traceMap[READ]) {
+                    yield { node, path, type: READ, info: traceMap[READ] };
+                }
+                yield* this._iteratePropertyReferences(node, path, traceMap);
+            }
+        } finally {
+            this.variableStack.pop();
+        }
+    }
+
+    /**
+     * Iterate the references for a given AST node.
+     * @private
+     * @template T
+     * @param {Expression} rootNode The AST node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    //eslint-disable-next-line complexity
+    *_iteratePropertyReferences(rootNode, path, traceMap) {
+        let node = rootNode;
+        while (isPassThrough(node)) {
+            node = node.parent;
+        }
+
+        const parent = /** @type {RuleNode} */ (node).parent;
+        if (parent.type === "MemberExpression") {
+            if (parent.object === node) {
+                const key = getPropertyName(parent);
+                if (key == null || !has(traceMap, key)) {
+                    return
+                }
+
+                path = path.concat(key); //eslint-disable-line no-param-reassign
+                const nextTraceMap = traceMap[key];
+                if (nextTraceMap[READ]) {
+                    yield {
+                        node: parent,
+                        path,
+                        type: READ,
+                        info: nextTraceMap[READ],
+                    };
+                }
+                yield* this._iteratePropertyReferences(
+                    parent,
+                    path,
+                    nextTraceMap,
+                );
+            }
+            return
+        }
+        if (parent.type === "CallExpression") {
+            if (parent.callee === node && traceMap[CALL]) {
+                yield { node: parent, path, type: CALL, info: traceMap[CALL] };
+            }
+            return
+        }
+        if (parent.type === "NewExpression") {
+            if (parent.callee === node && traceMap[CONSTRUCT]) {
+                yield {
+                    node: parent,
+                    path,
+                    type: CONSTRUCT,
+                    info: traceMap[CONSTRUCT],
+                };
+            }
+            return
+        }
+        if (parent.type === "AssignmentExpression") {
+            if (parent.right === node) {
+                yield* this._iterateLhsReferences(parent.left, path, traceMap);
+                yield* this._iteratePropertyReferences(parent, path, traceMap);
+            }
+            return
+        }
+        if (parent.type === "AssignmentPattern") {
+            if (parent.right === node) {
+                yield* this._iterateLhsReferences(parent.left, path, traceMap);
+            }
+            return
+        }
+        if (parent.type === "VariableDeclarator") {
+            if (parent.init === node) {
+                yield* this._iterateLhsReferences(parent.id, path, traceMap);
+            }
+        }
+    }
+
+    /**
+     * Iterate the references for a given Pattern node.
+     * @private
+     * @template T
+     * @param {Pattern} patternNode The Pattern node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateLhsReferences(patternNode, path, traceMap) {
+        if (patternNode.type === "Identifier") {
+            const variable = findVariable(this.globalScope, patternNode);
+            if (variable != null) {
+                yield* this._iterateVariableReferences(
+                    variable,
+                    path,
+                    traceMap,
+                    false,
+                );
+            }
+            return
+        }
+        if (patternNode.type === "ObjectPattern") {
+            for (const property of patternNode.properties) {
+                const key = getPropertyName(
+                    /** @type {AssignmentProperty} */ (property),
+                );
+
+                if (key == null || !has(traceMap, key)) {
+                    continue
+                }
+
+                const nextPath = path.concat(key);
+                const nextTraceMap = traceMap[key];
+                if (nextTraceMap[READ]) {
+                    yield {
+                        node: /** @type {RuleNode} */ (property),
+                        path: nextPath,
+                        type: READ,
+                        info: nextTraceMap[READ],
+                    };
+                }
+                yield* this._iterateLhsReferences(
+                    /** @type {AssignmentProperty} */ (property).value,
+                    nextPath,
+                    nextTraceMap,
+                );
+            }
+            return
+        }
+        if (patternNode.type === "AssignmentPattern") {
+            yield* this._iterateLhsReferences(patternNode.left, path, traceMap);
+        }
+    }
+
+    /**
+     * Iterate the references for a given ModuleSpecifier node.
+     * @private
+     * @template T
+     * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references.
+     * @param {string[]} path The current path.
+     * @param {TraceMapObject<T>} traceMap The trace map.
+     * @returns {IterableIterator<TrackedReferences<T>>} The iterator to iterate references.
+     */
+    *_iterateImportReferences(specifierNode, path, traceMap) {
+        const type = specifierNode.type;
+
+        if (type === "ImportSpecifier" || type === "ImportDefaultSpecifier") {
+            const key =
+                type === "ImportDefaultSpecifier"
+                    ? "default"
+                    : specifierNode.imported.type === "Identifier"
+                    ? specifierNode.imported.name
+                    : specifierNode.imported.value;
+            if (!has(traceMap, key)) {
+                return
+            }
+
+            path = path.concat(key); //eslint-disable-line no-param-reassign
+            const nextTraceMap = traceMap[key];
+            if (nextTraceMap[READ]) {
+                yield {
+                    node: /** @type {RuleNode} */ (specifierNode),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (
+                    findVariable(this.globalScope, specifierNode.local)
+                ),
+                path,
+                nextTraceMap,
+                false,
+            );
+
+            return
+        }
+
+        if (type === "ImportNamespaceSpecifier") {
+            yield* this._iterateVariableReferences(
+                /** @type {Variable} */ (
+                    findVariable(this.globalScope, specifierNode.local)
+                ),
+                path,
+                traceMap,
+                false,
+            );
+            return
+        }
+
+        if (type === "ExportSpecifier") {
+            const key =
+                specifierNode.local.type === "Identifier"
+                    ? specifierNode.local.name
+                    : specifierNode.local.value;
+            if (!has(traceMap, key)) {
+                return
+            }
+
+            path = path.concat(key); //eslint-disable-line no-param-reassign
+            const nextTraceMap = traceMap[key];
+            if (nextTraceMap[READ]) {
+                yield {
+                    node: /** @type {RuleNode} */ (specifierNode),
+                    path,
+                    type: READ,
+                    info: nextTraceMap[READ],
+                };
+            }
+        }
+    }
+}
+
+ReferenceTracker.READ = READ;
+ReferenceTracker.CALL = CALL;
+ReferenceTracker.CONSTRUCT = CONSTRUCT;
+ReferenceTracker.ESM = ESM;
+
+/**
+ * This is a predicate function for Array#filter.
+ * @param {string} name A name part.
+ * @param {number} index The index of the name.
+ * @returns {boolean} `false` if it's default.
+ */
+function exceptDefault(name, index) {
+    return !(index === 1 && name === "default")
+}
+
+/** @typedef {import("./types.mjs").StaticValue} StaticValue */
+
+var index = {
+    CALL,
+    CONSTRUCT,
+    ESM,
+    findVariable,
+    getFunctionHeadLocation,
+    getFunctionNameWithKind,
+    getInnermostScope,
+    getPropertyName,
+    getStaticValue,
+    getStringIfConstant,
+    hasSideEffect,
+    isArrowToken,
+    isClosingBraceToken,
+    isClosingBracketToken,
+    isClosingParenToken,
+    isColonToken,
+    isCommaToken,
+    isCommentToken,
+    isNotArrowToken,
+    isNotClosingBraceToken,
+    isNotClosingBracketToken,
+    isNotClosingParenToken,
+    isNotColonToken,
+    isNotCommaToken,
+    isNotCommentToken,
+    isNotOpeningBraceToken,
+    isNotOpeningBracketToken,
+    isNotOpeningParenToken,
+    isNotSemicolonToken,
+    isOpeningBraceToken,
+    isOpeningBracketToken,
+    isOpeningParenToken,
+    isParenthesized,
+    isSemicolonToken,
+    PatternMatcher,
+    READ,
+    ReferenceTracker,
+};
+
+export { CALL, CONSTRUCT, ESM, PatternMatcher, READ, ReferenceTracker, index as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };
+//# sourceMappingURL=index.mjs.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/README.md

@@ -0,0 +1,105 @@
+# eslint-visitor-keys
+
+[![npm version](https://img.shields.io/npm/v/eslint-visitor-keys.svg)](https://www.npmjs.com/package/eslint-visitor-keys)
+[![Downloads/month](https://img.shields.io/npm/dm/eslint-visitor-keys.svg)](http://www.npmtrends.com/eslint-visitor-keys)
+[![Build Status](https://github.com/eslint/eslint-visitor-keys/workflows/CI/badge.svg)](https://github.com/eslint/eslint-visitor-keys/actions)
+
+Constants and utilities about visitor keys to traverse AST.
+
+## 💿 Installation
+
+Use [npm] to install.
+
+```bash
+$ npm install eslint-visitor-keys
+```
+
+### Requirements
+
+- [Node.js] `^12.22.0`, `^14.17.0`, or `>=16.0.0`
+
+
+## 📖 Usage
+
+To use in an ESM file:
+
+```js
+import * as evk from "eslint-visitor-keys"
+```
+
+To use in a CommonJS file:
+
+```js
+const evk = require("eslint-visitor-keys")
+```
+
+### evk.KEYS
+
+> type: `{ [type: string]: string[] | undefined }`
+
+Visitor keys. This keys are frozen.
+
+This is an object. Keys are the type of [ESTree] nodes. Their values are an array of property names which have child nodes.
+
+For example:
+
+```
+console.log(evk.KEYS.AssignmentExpression) // → ["left", "right"]
+```
+
+### evk.getKeys(node)
+
+> type: `(node: object) => string[]`
+
+Get the visitor keys of a given AST node.
+
+This is similar to `Object.keys(node)` of ES Standard, but some keys are excluded: `parent`, `leadingComments`, `trailingComments`, and names which start with `_`.
+
+This will be used to traverse unknown nodes.
+
+For example:
+
+```js
+const node = {
+    type: "AssignmentExpression",
+    left: { type: "Identifier", name: "foo" },
+    right: { type: "Literal", value: 0 }
+}
+console.log(evk.getKeys(node)) // → ["type", "left", "right"]
+```
+
+### evk.unionWith(additionalKeys)
+
+> type: `(additionalKeys: object) => { [type: string]: string[] | undefined }`
+
+Make the union set with `evk.KEYS` and the given keys.
+
+- The order of keys is, `additionalKeys` is at first, then `evk.KEYS` is concatenated after that.
+- It removes duplicated keys as keeping the first one.
+
+For example:
+
+```js
+console.log(evk.unionWith({
+    MethodDefinition: ["decorators"]
+})) // → { ..., MethodDefinition: ["decorators", "key", "value"], ... }
+```
+
+## 📰 Change log
+
+See [GitHub releases](https://github.com/eslint/eslint-visitor-keys/releases).
+
+## 🍻 Contributing
+
+Welcome. See [ESLint contribution guidelines](https://eslint.org/docs/developer-guide/contributing/).
+
+### Development commands
+
+- `npm test` runs tests and measures code coverage.
+- `npm run lint` checks source codes with ESLint.
+- `npm run test:open-coverage` opens the code coverage report of the previous test with your default browser.
+
+
+[npm]: https://www.npmjs.com/
+[Node.js]: https://nodejs.org/
+[ESTree]: https://github.com/estree/estree

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs

@@ -0,0 +1,384 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+
+/**
+ * @type {VisitorKeys}
+ */
+const KEYS = {
+    ArrayExpression: [
+        "elements"
+    ],
+    ArrayPattern: [
+        "elements"
+    ],
+    ArrowFunctionExpression: [
+        "params",
+        "body"
+    ],
+    AssignmentExpression: [
+        "left",
+        "right"
+    ],
+    AssignmentPattern: [
+        "left",
+        "right"
+    ],
+    AwaitExpression: [
+        "argument"
+    ],
+    BinaryExpression: [
+        "left",
+        "right"
+    ],
+    BlockStatement: [
+        "body"
+    ],
+    BreakStatement: [
+        "label"
+    ],
+    CallExpression: [
+        "callee",
+        "arguments"
+    ],
+    CatchClause: [
+        "param",
+        "body"
+    ],
+    ChainExpression: [
+        "expression"
+    ],
+    ClassBody: [
+        "body"
+    ],
+    ClassDeclaration: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ClassExpression: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ConditionalExpression: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ContinueStatement: [
+        "label"
+    ],
+    DebuggerStatement: [],
+    DoWhileStatement: [
+        "body",
+        "test"
+    ],
+    EmptyStatement: [],
+    ExperimentalRestProperty: [
+        "argument"
+    ],
+    ExperimentalSpreadProperty: [
+        "argument"
+    ],
+    ExportAllDeclaration: [
+        "exported",
+        "source"
+    ],
+    ExportDefaultDeclaration: [
+        "declaration"
+    ],
+    ExportNamedDeclaration: [
+        "declaration",
+        "specifiers",
+        "source"
+    ],
+    ExportSpecifier: [
+        "exported",
+        "local"
+    ],
+    ExpressionStatement: [
+        "expression"
+    ],
+    ForInStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForOfStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForStatement: [
+        "init",
+        "test",
+        "update",
+        "body"
+    ],
+    FunctionDeclaration: [
+        "id",
+        "params",
+        "body"
+    ],
+    FunctionExpression: [
+        "id",
+        "params",
+        "body"
+    ],
+    Identifier: [],
+    IfStatement: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ImportDeclaration: [
+        "specifiers",
+        "source"
+    ],
+    ImportDefaultSpecifier: [
+        "local"
+    ],
+    ImportExpression: [
+        "source"
+    ],
+    ImportNamespaceSpecifier: [
+        "local"
+    ],
+    ImportSpecifier: [
+        "imported",
+        "local"
+    ],
+    JSXAttribute: [
+        "name",
+        "value"
+    ],
+    JSXClosingElement: [
+        "name"
+    ],
+    JSXClosingFragment: [],
+    JSXElement: [
+        "openingElement",
+        "children",
+        "closingElement"
+    ],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: [
+        "expression"
+    ],
+    JSXFragment: [
+        "openingFragment",
+        "children",
+        "closingFragment"
+    ],
+    JSXIdentifier: [],
+    JSXMemberExpression: [
+        "object",
+        "property"
+    ],
+    JSXNamespacedName: [
+        "namespace",
+        "name"
+    ],
+    JSXOpeningElement: [
+        "name",
+        "attributes"
+    ],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: [
+        "argument"
+    ],
+    JSXSpreadChild: [
+        "expression"
+    ],
+    JSXText: [],
+    LabeledStatement: [
+        "label",
+        "body"
+    ],
+    Literal: [],
+    LogicalExpression: [
+        "left",
+        "right"
+    ],
+    MemberExpression: [
+        "object",
+        "property"
+    ],
+    MetaProperty: [
+        "meta",
+        "property"
+    ],
+    MethodDefinition: [
+        "key",
+        "value"
+    ],
+    NewExpression: [
+        "callee",
+        "arguments"
+    ],
+    ObjectExpression: [
+        "properties"
+    ],
+    ObjectPattern: [
+        "properties"
+    ],
+    PrivateIdentifier: [],
+    Program: [
+        "body"
+    ],
+    Property: [
+        "key",
+        "value"
+    ],
+    PropertyDefinition: [
+        "key",
+        "value"
+    ],
+    RestElement: [
+        "argument"
+    ],
+    ReturnStatement: [
+        "argument"
+    ],
+    SequenceExpression: [
+        "expressions"
+    ],
+    SpreadElement: [
+        "argument"
+    ],
+    StaticBlock: [
+        "body"
+    ],
+    Super: [],
+    SwitchCase: [
+        "test",
+        "consequent"
+    ],
+    SwitchStatement: [
+        "discriminant",
+        "cases"
+    ],
+    TaggedTemplateExpression: [
+        "tag",
+        "quasi"
+    ],
+    TemplateElement: [],
+    TemplateLiteral: [
+        "quasis",
+        "expressions"
+    ],
+    ThisExpression: [],
+    ThrowStatement: [
+        "argument"
+    ],
+    TryStatement: [
+        "block",
+        "handler",
+        "finalizer"
+    ],
+    UnaryExpression: [
+        "argument"
+    ],
+    UpdateExpression: [
+        "argument"
+    ],
+    VariableDeclaration: [
+        "declarations"
+    ],
+    VariableDeclarator: [
+        "id",
+        "init"
+    ],
+    WhileStatement: [
+        "test",
+        "body"
+    ],
+    WithStatement: [
+        "object",
+        "body"
+    ],
+    YieldExpression: [
+        "argument"
+    ]
+};
+
+// Types.
+const NODE_TYPES = Object.keys(KEYS);
+
+// Freeze the keys.
+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.
+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) {
+    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) {
+    return Object.keys(node).filter(filterKey);
+}
+
+// Disable valid-jsdoc rule because it reports syntax error on the type of @returns.
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+function unionWith(additionalKeys) {
+    const retv = /** @type {{
+        [type: string]: ReadonlyArray<string>
+    }} */ (Object.assign({}, KEYS));
+
+    for (const type of Object.keys(additionalKeys)) {
+        if (Object.prototype.hasOwnProperty.call(retv, type)) {
+            const keys = new Set(additionalKeys[type]);
+
+            for (const key of retv[type]) {
+                keys.add(key);
+            }
+
+            retv[type] = Object.freeze(Array.from(keys));
+        } else {
+            retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+        }
+    }
+
+    return Object.freeze(retv);
+}
+
+exports.KEYS = KEYS;
+exports.getKeys = getKeys;
+exports.unionWith = unionWith;

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.d.cts

@@ -0,0 +1,27 @@
+type VisitorKeys$1 = {
+    readonly [type: string]: readonly string[];
+};
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+/**
+ * @type {VisitorKeys}
+ */
+declare const KEYS: VisitorKeys$1;
+
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+declare function getKeys(node: object): readonly string[];
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+declare function unionWith(additionalKeys: VisitorKeys): VisitorKeys;
+
+type VisitorKeys = VisitorKeys$1;
+
+export { KEYS, VisitorKeys, getKeys, unionWith };

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+export function getKeys(node: object): readonly string[];
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+export function unionWith(additionalKeys: VisitorKeys): VisitorKeys;
+export { KEYS };
+export type VisitorKeys = import('./visitor-keys.js').VisitorKeys;
+import KEYS from "./visitor-keys.js";
+//# sourceMappingURL=index.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/visitor-keys.d.ts

@@ -0,0 +1,12 @@
+export default KEYS;
+export type VisitorKeys = {
+    readonly [type: string]: readonly string[];
+};
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+/**
+ * @type {VisitorKeys}
+ */
+declare const KEYS: VisitorKeys;
+//# sourceMappingURL=visitor-keys.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/lib/index.js

@@ -0,0 +1,65 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+import KEYS from "./visitor-keys.js";
+
+/**
+ * @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
+ */
+
+// 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) {
+    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.
+ */
+export function getKeys(node) {
+    return Object.keys(node).filter(filterKey);
+}
+
+// Disable valid-jsdoc rule because it reports syntax error on the type of @returns.
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+export function unionWith(additionalKeys) {
+    const retv = /** @type {{
+        [type: string]: ReadonlyArray<string>
+    }} */ (Object.assign({}, KEYS));
+
+    for (const type of Object.keys(additionalKeys)) {
+        if (Object.prototype.hasOwnProperty.call(retv, type)) {
+            const keys = new Set(additionalKeys[type]);
+
+            for (const key of retv[type]) {
+                keys.add(key);
+            }
+
+            retv[type] = Object.freeze(Array.from(keys));
+        } else {
+            retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+        }
+    }
+
+    return Object.freeze(retv);
+}
+
+export { KEYS };

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/lib/visitor-keys.js

@@ -0,0 +1,315 @@
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+
+/**
+ * @type {VisitorKeys}
+ */
+const KEYS = {
+    ArrayExpression: [
+        "elements"
+    ],
+    ArrayPattern: [
+        "elements"
+    ],
+    ArrowFunctionExpression: [
+        "params",
+        "body"
+    ],
+    AssignmentExpression: [
+        "left",
+        "right"
+    ],
+    AssignmentPattern: [
+        "left",
+        "right"
+    ],
+    AwaitExpression: [
+        "argument"
+    ],
+    BinaryExpression: [
+        "left",
+        "right"
+    ],
+    BlockStatement: [
+        "body"
+    ],
+    BreakStatement: [
+        "label"
+    ],
+    CallExpression: [
+        "callee",
+        "arguments"
+    ],
+    CatchClause: [
+        "param",
+        "body"
+    ],
+    ChainExpression: [
+        "expression"
+    ],
+    ClassBody: [
+        "body"
+    ],
+    ClassDeclaration: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ClassExpression: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ConditionalExpression: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ContinueStatement: [
+        "label"
+    ],
+    DebuggerStatement: [],
+    DoWhileStatement: [
+        "body",
+        "test"
+    ],
+    EmptyStatement: [],
+    ExperimentalRestProperty: [
+        "argument"
+    ],
+    ExperimentalSpreadProperty: [
+        "argument"
+    ],
+    ExportAllDeclaration: [
+        "exported",
+        "source"
+    ],
+    ExportDefaultDeclaration: [
+        "declaration"
+    ],
+    ExportNamedDeclaration: [
+        "declaration",
+        "specifiers",
+        "source"
+    ],
+    ExportSpecifier: [
+        "exported",
+        "local"
+    ],
+    ExpressionStatement: [
+        "expression"
+    ],
+    ForInStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForOfStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForStatement: [
+        "init",
+        "test",
+        "update",
+        "body"
+    ],
+    FunctionDeclaration: [
+        "id",
+        "params",
+        "body"
+    ],
+    FunctionExpression: [
+        "id",
+        "params",
+        "body"
+    ],
+    Identifier: [],
+    IfStatement: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ImportDeclaration: [
+        "specifiers",
+        "source"
+    ],
+    ImportDefaultSpecifier: [
+        "local"
+    ],
+    ImportExpression: [
+        "source"
+    ],
+    ImportNamespaceSpecifier: [
+        "local"
+    ],
+    ImportSpecifier: [
+        "imported",
+        "local"
+    ],
+    JSXAttribute: [
+        "name",
+        "value"
+    ],
+    JSXClosingElement: [
+        "name"
+    ],
+    JSXClosingFragment: [],
+    JSXElement: [
+        "openingElement",
+        "children",
+        "closingElement"
+    ],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: [
+        "expression"
+    ],
+    JSXFragment: [
+        "openingFragment",
+        "children",
+        "closingFragment"
+    ],
+    JSXIdentifier: [],
+    JSXMemberExpression: [
+        "object",
+        "property"
+    ],
+    JSXNamespacedName: [
+        "namespace",
+        "name"
+    ],
+    JSXOpeningElement: [
+        "name",
+        "attributes"
+    ],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: [
+        "argument"
+    ],
+    JSXSpreadChild: [
+        "expression"
+    ],
+    JSXText: [],
+    LabeledStatement: [
+        "label",
+        "body"
+    ],
+    Literal: [],
+    LogicalExpression: [
+        "left",
+        "right"
+    ],
+    MemberExpression: [
+        "object",
+        "property"
+    ],
+    MetaProperty: [
+        "meta",
+        "property"
+    ],
+    MethodDefinition: [
+        "key",
+        "value"
+    ],
+    NewExpression: [
+        "callee",
+        "arguments"
+    ],
+    ObjectExpression: [
+        "properties"
+    ],
+    ObjectPattern: [
+        "properties"
+    ],
+    PrivateIdentifier: [],
+    Program: [
+        "body"
+    ],
+    Property: [
+        "key",
+        "value"
+    ],
+    PropertyDefinition: [
+        "key",
+        "value"
+    ],
+    RestElement: [
+        "argument"
+    ],
+    ReturnStatement: [
+        "argument"
+    ],
+    SequenceExpression: [
+        "expressions"
+    ],
+    SpreadElement: [
+        "argument"
+    ],
+    StaticBlock: [
+        "body"
+    ],
+    Super: [],
+    SwitchCase: [
+        "test",
+        "consequent"
+    ],
+    SwitchStatement: [
+        "discriminant",
+        "cases"
+    ],
+    TaggedTemplateExpression: [
+        "tag",
+        "quasi"
+    ],
+    TemplateElement: [],
+    TemplateLiteral: [
+        "quasis",
+        "expressions"
+    ],
+    ThisExpression: [],
+    ThrowStatement: [
+        "argument"
+    ],
+    TryStatement: [
+        "block",
+        "handler",
+        "finalizer"
+    ],
+    UnaryExpression: [
+        "argument"
+    ],
+    UpdateExpression: [
+        "argument"
+    ],
+    VariableDeclaration: [
+        "declarations"
+    ],
+    VariableDeclarator: [
+        "id",
+        "init"
+    ],
+    WhileStatement: [
+        "test",
+        "body"
+    ],
+    WithStatement: [
+        "object",
+        "body"
+    ],
+    YieldExpression: [
+        "argument"
+    ]
+};
+
+// Types.
+const NODE_TYPES = Object.keys(KEYS);
+
+// Freeze the keys.
+for (const type of NODE_TYPES) {
+    Object.freeze(KEYS[type]);
+}
+Object.freeze(KEYS);
+
+export default KEYS;

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "eslint-visitor-keys",
+  "version": "3.4.3",
+  "description": "Constants and utilities about visitor keys to traverse AST.",
+  "type": "module",
+  "main": "dist/eslint-visitor-keys.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": [
+      {
+        "import": "./lib/index.js",
+        "require": "./dist/eslint-visitor-keys.cjs"
+      },
+      "./dist/eslint-visitor-keys.cjs"
+    ],
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/index.d.ts",
+    "dist/visitor-keys.d.ts",
+    "dist/eslint-visitor-keys.cjs",
+    "dist/eslint-visitor-keys.d.cts",
+    "lib"
+  ],
+  "engines": {
+    "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+  },
+  "devDependencies": {
+    "@types/estree": "^0.0.51",
+    "@types/estree-jsx": "^0.0.1",
+    "@typescript-eslint/parser": "^5.14.0",
+    "c8": "^7.11.0",
+    "chai": "^4.3.6",
+    "eslint": "^7.29.0",
+    "eslint-config-eslint": "^7.0.0",
+    "eslint-plugin-jsdoc": "^35.4.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-release": "^3.2.0",
+    "esquery": "^1.4.0",
+    "json-diff": "^0.7.3",
+    "mocha": "^9.2.1",
+    "opener": "^1.5.2",
+    "rollup": "^2.70.0",
+    "rollup-plugin-dts": "^4.2.3",
+    "tsd": "^0.19.1",
+    "typescript": "^4.6.2"
+  },
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:types",
+    "build:cjs": "rollup -c",
+    "build:debug": "npm run build:cjs -- -m && npm run build:types",
+    "build:keys": "node tools/build-keys-from-ts",
+    "build:types": "tsc",
+    "lint": "eslint .",
+    "prepare": "npm run build",
+    "release:generate:latest": "eslint-generate-release",
+    "release:generate:alpha": "eslint-generate-prerelease alpha",
+    "release:generate:beta": "eslint-generate-prerelease beta",
+    "release:generate:rc": "eslint-generate-prerelease rc",
+    "release:publish": "eslint-publish-release",
+    "test": "mocha tests/lib/**/*.cjs && c8 mocha tests/lib/**/*.js && npm run test:types",
+    "test:open-coverage": "c8 report --reporter lcov && opener coverage/lcov-report/index.html",
+    "test:types": "tsd"
+  },
+  "repository": "eslint/eslint-visitor-keys",
+  "funding": "https://opencollective.com/eslint",
+  "keywords": [],
+  "author": "Toru Nagashima (https://github.com/mysticatea)",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/eslint/eslint-visitor-keys/issues"
+  },
+  "homepage": "https://github.com/eslint/eslint-visitor-keys#readme"
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/eslint-utils/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@eslint-community/eslint-utils",
+    "version": "4.7.0",
+    "description": "Utilities for ESLint plugins.",
+    "keywords": [
+        "eslint"
+    ],
+    "homepage": "https://github.com/eslint-community/eslint-utils#readme",
+    "bugs": {
+        "url": "https://github.com/eslint-community/eslint-utils/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/eslint-community/eslint-utils"
+    },
+    "license": "MIT",
+    "author": "Toru Nagashima",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": "./index.mjs",
+            "require": "./index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "main": "index",
+    "module": "index.mjs",
+    "files": [
+        "index.*"
+    ],
+    "scripts": {
+        "prebuild": "npm run -s clean",
+        "build": "npm run build:dts && npm run build:rollup",
+        "build:dts": "tsc -p tsconfig.build.json",
+        "build:rollup": "rollup -c",
+        "clean": "rimraf .nyc_output coverage index.* dist",
+        "coverage": "opener ./coverage/lcov-report/index.html",
+        "docs:build": "vitepress build docs",
+        "docs:watch": "vitepress dev docs",
+        "format": "npm run -s format:prettier -- --write",
+        "format:prettier": "prettier .",
+        "format:check": "npm run -s format:prettier -- --check",
+        "lint:eslint": "eslint .",
+        "lint:format": "npm run -s format:check",
+        "lint:installed-check": "installed-check -v -i installed-check -i npm-run-all2 -i knip -i rollup-plugin-dts",
+        "lint:knip": "knip",
+        "lint": "run-p lint:*",
+        "test-coverage": "c8 mocha --reporter dot \"test/*.mjs\"",
+        "test": "mocha --reporter dot \"test/*.mjs\"",
+        "preversion": "npm run test-coverage && npm run -s build",
+        "postversion": "git push && git push --tags",
+        "prewatch": "npm run -s clean",
+        "watch": "warun \"{src,test}/**/*.mjs\" -- npm run -s test:mocha"
+    },
+    "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+    },
+    "devDependencies": {
+        "@eslint-community/eslint-plugin-mysticatea": "^15.6.1",
+        "@types/eslint": "^9.6.1",
+        "@types/estree": "^1.0.7",
+        "@typescript-eslint/parser": "^5.62.0",
+        "@typescript-eslint/types": "^5.62.0",
+        "c8": "^8.0.1",
+        "dot-prop": "^7.2.0",
+        "eslint": "^8.57.1",
+        "installed-check": "^8.0.1",
+        "knip": "^5.33.3",
+        "mocha": "^9.2.2",
+        "npm-run-all2": "^6.2.3",
+        "opener": "^1.5.2",
+        "prettier": "2.8.8",
+        "rimraf": "^3.0.2",
+        "rollup": "^2.79.2",
+        "rollup-plugin-dts": "^4.2.3",
+        "rollup-plugin-sourcemaps": "^0.6.3",
+        "semver": "^7.6.3",
+        "typescript": "^4.9.5",
+        "vitepress": "^1.4.1",
+        "warun": "^1.0.0"
+    },
+    "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+    },
+    "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+    },
+    "funding": "https://opencollective.com/eslint"
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/regexpp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/regexpp/README.md

@@ -0,0 +1,177 @@
+# @eslint-community/regexpp
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/regexpp.svg)](https://www.npmjs.com/package/@eslint-community/regexpp)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/regexpp.svg)](http://www.npmtrends.com/@eslint-community/regexpp)
+[![Build Status](https://github.com/eslint-community/regexpp/workflows/CI/badge.svg)](https://github.com/eslint-community/regexpp/actions)
+[![codecov](https://codecov.io/gh/eslint-community/regexpp/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/regexpp)
+
+A regular expression parser for ECMAScript.
+
+## 💿 Installation
+
+```bash
+$ npm install @eslint-community/regexpp
+```
+
+- require Node@^12.0.0 || ^14.0.0 || >=16.0.0.
+
+## 📖 Usage
+
+```ts
+import {
+    AST,
+    RegExpParser,
+    RegExpValidator,
+    RegExpVisitor,
+    parseRegExpLiteral,
+    validateRegExpLiteral,
+    visitRegExpAST
+} from "@eslint-community/regexpp"
+```
+
+### parseRegExpLiteral(source, options?)
+
+Parse a given regular expression literal then make AST object.
+
+This is equivalent to `new RegExpParser(options).parseLiteral(source)`.
+
+- **Parameters:**
+    - `source` (`string | RegExp`) The source code to parse.
+    - `options?` ([`RegExpParser.Options`]) The options to parse.
+- **Return:**
+    - The AST of the regular expression.
+
+### validateRegExpLiteral(source, options?)
+
+Validate a given regular expression literal.
+
+This is equivalent to `new RegExpValidator(options).validateLiteral(source)`.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `options?` ([`RegExpValidator.Options`]) The options to validate.
+
+### visitRegExpAST(ast, handlers)
+
+Visit each node of a given AST.
+
+This is equivalent to `new RegExpVisitor(handlers).visit(ast)`.
+
+- **Parameters:**
+    - `ast` ([`AST.Node`]) The AST to visit.
+    - `handlers` ([`RegExpVisitor.Handlers`]) The callbacks.
+
+### RegExpParser
+
+#### new RegExpParser(options?)
+
+- **Parameters:**
+    - `options?` ([`RegExpParser.Options`]) The options to parse.
+
+#### parser.parseLiteral(source, start?, end?)
+
+Parse a regular expression literal.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"/abc/g"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+- **Return:**
+    - The AST of the regular expression.
+
+#### parser.parsePattern(source, start?, end?, flags?)
+
+Parse a regular expression pattern.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"abc"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
+- **Return:**
+    - The AST of the regular expression pattern.
+
+#### parser.parseFlags(source, start?, end?)
+
+Parse a regular expression flags.
+
+- **Parameters:**
+    - `source` (`string`) The source code to parse. E.g. `"gim"`.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+- **Return:**
+    - The AST of the regular expression flags.
+
+### RegExpValidator
+
+#### new RegExpValidator(options)
+
+- **Parameters:**
+    - `options` ([`RegExpValidator.Options`]) The options to validate.
+
+#### validator.validateLiteral(source, start, end)
+
+Validate a regular expression literal.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+
+#### validator.validatePattern(source, start, end, flags)
+
+Validate a regular expression pattern.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+    - `flags?` (`{ unicode?: boolean, unicodeSets?: boolean }`) The flags to enable Unicode mode, and Unicode Set mode.
+
+#### validator.validateFlags(source, start, end)
+
+Validate a regular expression flags.
+
+- **Parameters:**
+    - `source` (`string`) The source code to validate.
+    - `start?` (`number`) The start index in the source code. Default is `0`.
+    - `end?` (`number`) The end index in the source code. Default is `source.length`.
+
+### RegExpVisitor
+
+#### new RegExpVisitor(handlers)
+
+- **Parameters:**
+    - `handlers` ([`RegExpVisitor.Handlers`]) The callbacks.
+
+#### visitor.visit(ast)
+
+Validate a regular expression literal.
+
+- **Parameters:**
+    - `ast` ([`AST.Node`]) The AST to visit.
+
+## 📰 Changelog
+
+- [GitHub Releases](https://github.com/eslint-community/regexpp/releases)
+
+## 🍻 Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+- `npm test` runs tests and measures coverage.
+- `npm run build` compiles TypeScript source code to `index.js`, `index.js.map`, and `index.d.ts`.
+- `npm run clean` removes the temporary files which are created by `npm test` and `npm run build`.
+- `npm run lint` runs ESLint.
+- `npm run update:test` updates test fixtures.
+- `npm run update:ids` updates `src/unicode/ids.ts`.
+- `npm run watch` runs tests with `--watch` option.
+
+[`AST.Node`]: src/ast.ts#L4
+[`RegExpParser.Options`]: src/parser.ts#L743
+[`RegExpValidator.Options`]: src/validator.ts#L220
+[`RegExpVisitor.Handlers`]: src/visitor.ts#L291

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/regexpp/index.d.ts

@@ -0,0 +1,1163 @@
+// Generated by dts-bundle v0.7.3
+
+declare module "@eslint-community/regexpp" {
+  import * as AST from "@eslint-community/regexpp/ast";
+  import { RegExpParser } from "@eslint-community/regexpp/parser";
+  import { RegExpValidator } from "@eslint-community/regexpp/validator";
+  import { RegExpVisitor } from "@eslint-community/regexpp/visitor";
+  export { RegExpSyntaxError } from "@eslint-community/regexpp/regexp-syntax-error";
+  export { AST, RegExpParser, RegExpValidator };
+  /**
+   * Parse a given regular expression literal then make AST object.
+   * @param source The source code to parse.
+   * @param options The options to parse.
+   * @returns The AST of the regular expression.
+   */
+  export function parseRegExpLiteral(
+    source: RegExp | string,
+    options?: RegExpParser.Options
+  ): AST.RegExpLiteral;
+  /**
+   * Validate a given regular expression literal.
+   * @param source The source code to validate.
+   * @param options The options to validate.
+   */
+  export function validateRegExpLiteral(
+    source: string,
+    options?: RegExpValidator.Options
+  ): void;
+  export function visitRegExpAST(
+    node: AST.Node,
+    handlers: RegExpVisitor.Handlers
+  ): void;
+}
+
+declare module "@eslint-community/regexpp/ast" {
+  /**
+   * The type which includes all nodes.
+   */
+  export type Node = BranchNode | LeafNode;
+  /**
+   * The type which includes all branch nodes.
+   */
+  export type BranchNode =
+    | Alternative
+    | CapturingGroup
+    | CharacterClass
+    | CharacterClassRange
+    | ClassIntersection
+    | ClassStringDisjunction
+    | ClassSubtraction
+    | ExpressionCharacterClass
+    | Group
+    | LookaroundAssertion
+    | Modifiers
+    | Pattern
+    | Quantifier
+    | RegExpLiteral
+    | StringAlternative;
+  /**
+   * The type which includes all leaf nodes.
+   */
+  export type LeafNode =
+    | Backreference
+    | BoundaryAssertion
+    | Character
+    | CharacterSet
+    | Flags
+    | ModifierFlags;
+  /**
+   * The type which includes all atom nodes.
+   */
+  export type Element = Assertion | QuantifiableElement | Quantifier;
+  /**
+   * The type which includes all atom nodes that Quantifier node can have as children.
+   */
+  export type QuantifiableElement =
+    | Backreference
+    | CapturingGroup
+    | Character
+    | CharacterClass
+    | CharacterSet
+    | ExpressionCharacterClass
+    | Group
+    | LookaheadAssertion;
+  /**
+   * The type which includes all character class atom nodes.
+   */
+  export type CharacterClassElement =
+    | ClassRangesCharacterClassElement
+    | UnicodeSetsCharacterClassElement;
+  export type ClassRangesCharacterClassElement =
+    | Character
+    | CharacterClassRange
+    | CharacterUnicodePropertyCharacterSet
+    | EscapeCharacterSet;
+  export type UnicodeSetsCharacterClassElement =
+    | Character
+    | CharacterClassRange
+    | ClassStringDisjunction
+    | EscapeCharacterSet
+    | ExpressionCharacterClass
+    | UnicodePropertyCharacterSet
+    | UnicodeSetsCharacterClass;
+  /**
+   * The type which defines common properties for all node types.
+   */
+  export interface NodeBase {
+    /** The node type. */
+    type: Node["type"];
+    /** The parent node. */
+    parent: Node["parent"];
+    /** The 0-based index that this node starts. */
+    start: number;
+    /** The 0-based index that this node ends. */
+    end: number;
+    /** The raw text of this node. */
+    raw: string;
+  }
+  /**
+   * The root node.
+   */
+  export interface RegExpLiteral extends NodeBase {
+    type: "RegExpLiteral";
+    parent: null;
+    pattern: Pattern;
+    flags: Flags;
+  }
+  /**
+   * The pattern.
+   */
+  export interface Pattern extends NodeBase {
+    type: "Pattern";
+    parent: RegExpLiteral | null;
+    alternatives: Alternative[];
+  }
+  /**
+   * The alternative.
+   * E.g. `a|b`
+   */
+  export interface Alternative extends NodeBase {
+    type: "Alternative";
+    parent: CapturingGroup | Group | LookaroundAssertion | Pattern;
+    elements: Element[];
+  }
+  /**
+   * The uncapturing group.
+   * E.g. `(?:ab)`
+   */
+  export interface Group extends NodeBase {
+    type: "Group";
+    parent: Alternative | Quantifier;
+    modifiers: Modifiers | null;
+    alternatives: Alternative[];
+  }
+  /**
+   * The capturing group.
+   * E.g. `(ab)`, `(?<name>ab)`
+   */
+  export interface CapturingGroup extends NodeBase {
+    type: "CapturingGroup";
+    parent: Alternative | Quantifier;
+    name: string | null;
+    alternatives: Alternative[];
+    references: Backreference[];
+  }
+  /**
+   * The lookaround assertion.
+   */
+  export type LookaroundAssertion = LookaheadAssertion | LookbehindAssertion;
+  /**
+   * The lookahead assertion.
+   * E.g. `(?=ab)`, `(?!ab)`
+   */
+  export interface LookaheadAssertion extends NodeBase {
+    type: "Assertion";
+    parent: Alternative | Quantifier;
+    kind: "lookahead";
+    negate: boolean;
+    alternatives: Alternative[];
+  }
+  /**
+   * The lookbehind assertion.
+   * E.g. `(?<=ab)`, `(?<!ab)`
+   */
+  export interface LookbehindAssertion extends NodeBase {
+    type: "Assertion";
+    parent: Alternative;
+    kind: "lookbehind";
+    negate: boolean;
+    alternatives: Alternative[];
+  }
+  /**
+   * The quantifier.
+   * E.g. `a?`, `a*`, `a+`, `a{1,2}`, `a??`, `a*?`, `a+?`, `a{1,2}?`
+   */
+  export interface Quantifier extends NodeBase {
+    type: "Quantifier";
+    parent: Alternative;
+    min: number;
+    max: number;
+    greedy: boolean;
+    element: QuantifiableElement;
+  }
+  /**
+   * The character class.
+   * E.g. `[ab]`, `[^ab]`
+   */
+  export type CharacterClass =
+    | ClassRangesCharacterClass
+    | UnicodeSetsCharacterClass;
+  interface BaseCharacterClass extends NodeBase {
+    type: "CharacterClass";
+    parent:
+      | Alternative
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier
+      | UnicodeSetsCharacterClass;
+    unicodeSets: boolean;
+    negate: boolean;
+    elements: CharacterClassElement[];
+  }
+  /**
+   * The character class used in legacy (neither `u` nor `v` flag) and Unicode mode (`u` flag).
+   *
+   * This character class is guaranteed to **not** contain strings.
+   *
+   * In Unicode sets mode (`v` flag), {@link UnicodeSetsCharacterClass} is used.
+   */
+  export interface ClassRangesCharacterClass extends BaseCharacterClass {
+    parent: Alternative | Quantifier;
+    unicodeSets: false;
+    elements: ClassRangesCharacterClassElement[];
+  }
+  /**
+   * The character class used in Unicode sets mode (`v` flag).
+   *
+   * This character class may contain strings.
+   */
+  export interface UnicodeSetsCharacterClass extends BaseCharacterClass {
+    parent:
+      | Alternative
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier
+      | UnicodeSetsCharacterClass;
+    unicodeSets: true;
+    elements: UnicodeSetsCharacterClassElement[];
+  }
+  /**
+   * The character class.
+   * E.g. `[a-b]`
+   */
+  export interface CharacterClassRange extends NodeBase {
+    type: "CharacterClassRange";
+    parent: CharacterClass;
+    min: Character;
+    max: Character;
+  }
+  /**
+   * The assertion.
+   */
+  export type Assertion = BoundaryAssertion | LookaroundAssertion;
+  /**
+   * The boundary assertion.
+   */
+  export type BoundaryAssertion = EdgeAssertion | WordBoundaryAssertion;
+  /**
+   * The edge boundary assertion.
+   * E.g. `^`, `$`
+   */
+  export interface EdgeAssertion extends NodeBase {
+    type: "Assertion";
+    parent: Alternative | Quantifier;
+    kind: "end" | "start";
+  }
+  /**
+   * The word bondary assertion.
+   * E.g. `\b`, `\B`
+   */
+  export interface WordBoundaryAssertion extends NodeBase {
+    type: "Assertion";
+    parent: Alternative | Quantifier;
+    kind: "word";
+    negate: boolean;
+  }
+  /**
+   * The character set.
+   */
+  export type CharacterSet =
+    | AnyCharacterSet
+    | EscapeCharacterSet
+    | UnicodePropertyCharacterSet;
+  /**
+   * The dot.
+   * E.g. `.`
+   */
+  export interface AnyCharacterSet extends NodeBase {
+    type: "CharacterSet";
+    parent: Alternative | Quantifier;
+    kind: "any";
+  }
+  /**
+   * The character class escape.
+   * E.g. `\d`, `\s`, `\w`, `\D`, `\S`, `\W`
+   */
+  export interface EscapeCharacterSet extends NodeBase {
+    type: "CharacterSet";
+    parent:
+      | Alternative
+      | CharacterClass
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier;
+    kind: "digit" | "space" | "word";
+    negate: boolean;
+  }
+  /**
+   * The unicode property escape.
+   * E.g. `\p{ASCII}`, `\P{ASCII}`, `\p{Script=Hiragana}`
+   */
+  export type UnicodePropertyCharacterSet =
+    | CharacterUnicodePropertyCharacterSet
+    | StringsUnicodePropertyCharacterSet;
+  interface BaseUnicodePropertyCharacterSet extends NodeBase {
+    type: "CharacterSet";
+    parent:
+      | Alternative
+      | CharacterClass
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier;
+    kind: "property";
+    strings: boolean;
+    key: string;
+    value: string | null;
+    negate: boolean;
+  }
+  export interface CharacterUnicodePropertyCharacterSet
+    extends BaseUnicodePropertyCharacterSet {
+    strings: false;
+    value: string | null;
+    negate: boolean;
+  }
+  /** StringsUnicodePropertyCharacterSet is Unicode property escape with property of strings. */
+  export interface StringsUnicodePropertyCharacterSet
+    extends BaseUnicodePropertyCharacterSet {
+    parent:
+      | Alternative
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier
+      | UnicodeSetsCharacterClass;
+    strings: true;
+    value: null;
+    negate: false;
+  }
+  /**
+   * The expression character class.
+   * E.g. `[a--b]`, `[a&&b]`,`[^a--b]`, `[^a&&b]`
+   */
+  export interface ExpressionCharacterClass extends NodeBase {
+    type: "ExpressionCharacterClass";
+    parent:
+      | Alternative
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier
+      | UnicodeSetsCharacterClass;
+    negate: boolean;
+    expression: ClassIntersection | ClassSubtraction;
+  }
+  export type ClassSetOperand =
+    | Character
+    | ClassStringDisjunction
+    | EscapeCharacterSet
+    | ExpressionCharacterClass
+    | UnicodePropertyCharacterSet
+    | UnicodeSetsCharacterClass;
+  /**
+   * The character class intersection.
+   * E.g. `a&&b`
+   */
+  export interface ClassIntersection extends NodeBase {
+    type: "ClassIntersection";
+    parent: ClassIntersection | ExpressionCharacterClass;
+    left: ClassIntersection | ClassSetOperand;
+    right: ClassSetOperand;
+  }
+  /**
+   * The character class subtraction.
+   * E.g. `a--b`
+   */
+  export interface ClassSubtraction extends NodeBase {
+    type: "ClassSubtraction";
+    parent: ClassSubtraction | ExpressionCharacterClass;
+    left: ClassSetOperand | ClassSubtraction;
+    right: ClassSetOperand;
+  }
+  /**
+   * The character class string disjunction.
+   * E.g. `\q{a|b}`
+   */
+  export interface ClassStringDisjunction extends NodeBase {
+    type: "ClassStringDisjunction";
+    parent: ClassIntersection | ClassSubtraction | UnicodeSetsCharacterClass;
+    alternatives: StringAlternative[];
+  }
+  /** StringAlternative is only used for `\q{alt}`({@link ClassStringDisjunction}). */
+  export interface StringAlternative extends NodeBase {
+    type: "StringAlternative";
+    parent: ClassStringDisjunction;
+    elements: Character[];
+  }
+  /**
+   * The character.
+   * This includes escape sequences which mean a character.
+   * E.g. `a`, `あ`, `✿`, `\x65`, `\u0065`, `\u{65}`, `\/`
+   */
+  export interface Character extends NodeBase {
+    type: "Character";
+    parent:
+      | Alternative
+      | CharacterClass
+      | CharacterClassRange
+      | ClassIntersection
+      | ClassSubtraction
+      | Quantifier
+      | StringAlternative;
+    value: number;
+  }
+  /**
+   * The backreference.
+   * E.g. `\1`, `\k<name>`
+   */
+  export type Backreference = AmbiguousBackreference | UnambiguousBackreference;
+  interface BaseBackreference extends NodeBase {
+    type: "Backreference";
+    parent: Alternative | Quantifier;
+    ref: number | string;
+    ambiguous: boolean;
+    resolved: CapturingGroup | CapturingGroup[];
+  }
+  export interface AmbiguousBackreference extends BaseBackreference {
+    ref: string;
+    ambiguous: true;
+    resolved: CapturingGroup[];
+  }
+  export interface UnambiguousBackreference extends BaseBackreference {
+    ambiguous: false;
+    resolved: CapturingGroup;
+  }
+  /**
+   * The modifiers.
+   */
+  export interface Modifiers extends NodeBase {
+    type: "Modifiers";
+    parent: Group;
+    /**
+     * The add modifier flags.
+     */
+    add: ModifierFlags;
+    /**
+     * The remove modifier flags.
+     *
+     * `null` means no remove modifier flags. e.g. `(?ims:x)`
+     * The reason for `null` is that there is no position where the remove modifier flags appears. Must be behind the minus mark.
+     */
+    remove: ModifierFlags | null;
+  }
+  /**
+   * The modifier flags.
+   */
+  export interface ModifierFlags extends NodeBase {
+    type: "ModifierFlags";
+    parent: Modifiers;
+    dotAll: boolean;
+    ignoreCase: boolean;
+    multiline: boolean;
+  }
+  /**
+   * The flags.
+   */
+  export interface Flags extends NodeBase {
+    type: "Flags";
+    parent: RegExpLiteral | null;
+    dotAll: boolean;
+    global: boolean;
+    hasIndices: boolean;
+    ignoreCase: boolean;
+    multiline: boolean;
+    sticky: boolean;
+    unicode: boolean;
+    unicodeSets: boolean;
+  }
+  export {};
+}
+
+declare module "@eslint-community/regexpp/parser" {
+  import type {
+    Flags,
+    RegExpLiteral,
+    Pattern,
+  } from "@eslint-community/regexpp/ast";
+  import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
+  export namespace RegExpParser {
+    /**
+     * The options for RegExpParser construction.
+     */
+    interface Options {
+      /**
+       * The flag to disable Annex B syntax. Default is `false`.
+       */
+      strict?: boolean;
+      /**
+       * ECMAScript version. Default is `2025`.
+       * - `2015` added `u` and `y` flags.
+       * - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
+       *   and Unicode Property Escape.
+       * - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
+       * - `2022` added `d` flag.
+       * - `2023` added more valid Unicode Property Escapes.
+       * - `2024` added `v` flag.
+       * - `2025` added duplicate named capturing groups, modifiers.
+       */
+      ecmaVersion?: EcmaVersion;
+    }
+  }
+  export class RegExpParser {
+    /**
+     * Initialize this parser.
+     * @param options The options of parser.
+     */
+    constructor(options?: RegExpParser.Options);
+    /**
+     * Parse a regular expression literal. E.g. "/abc/g"
+     * @param source The source code to parse.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @returns The AST of the given regular expression.
+     */
+    parseLiteral(source: string, start?: number, end?: number): RegExpLiteral;
+    /**
+     * Parse a regular expression flags. E.g. "gim"
+     * @param source The source code to parse.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @returns The AST of the given flags.
+     */
+    parseFlags(source: string, start?: number, end?: number): Flags;
+    /**
+     * Parse a regular expression pattern. E.g. "abc"
+     * @param source The source code to parse.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @param flags The flags.
+     * @returns The AST of the given pattern.
+     */
+    parsePattern(
+      source: string,
+      start?: number,
+      end?: number,
+      flags?: {
+        unicode?: boolean;
+        unicodeSets?: boolean;
+      }
+    ): Pattern;
+    /**
+     * @deprecated Backward compatibility
+     * Use object `flags` instead of boolean `uFlag`.
+     *
+     * @param source The source code to parse.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @param uFlag The flag to set unicode mode.
+     * @returns The AST of the given pattern.
+     */
+    parsePattern(
+      source: string,
+      start?: number,
+      end?: number,
+      uFlag?: boolean
+    ): Pattern;
+  }
+}
+
+declare module "@eslint-community/regexpp/validator" {
+  import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
+  export type RegExpValidatorSourceContext = {
+    readonly source: string;
+    readonly start: number;
+    readonly end: number;
+    readonly kind: "flags" | "literal" | "pattern";
+  };
+  export namespace RegExpValidator {
+    /**
+     * The options for RegExpValidator construction.
+     */
+    interface Options {
+      /**
+       * The flag to disable Annex B syntax. Default is `false`.
+       */
+      strict?: boolean;
+      /**
+       * ECMAScript version. Default is `2025`.
+       * - `2015` added `u` and `y` flags.
+       * - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
+       *   and Unicode Property Escape.
+       * - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
+       * - `2022` added `d` flag.
+       * - `2023` added more valid Unicode Property Escapes.
+       * - `2024` added `v` flag.
+       * - `2025` added duplicate named capturing groups, modifiers.
+       */
+      ecmaVersion?: EcmaVersion;
+      /**
+       * A function that is called when the validator entered a RegExp literal.
+       * @param start The 0-based index of the first character.
+       */
+      onLiteralEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a RegExp literal.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onLiteralLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator found flags.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param flags.global `g` flag.
+       * @param flags.ignoreCase `i` flag.
+       * @param flags.multiline `m` flag.
+       * @param flags.unicode `u` flag.
+       * @param flags.sticky `y` flag.
+       * @param flags.dotAll `s` flag.
+       * @param flags.hasIndices `d` flag.
+       * @param flags.unicodeSets `v` flag.
+       */
+      onRegExpFlags?: (
+        start: number,
+        end: number,
+        flags: {
+          global: boolean;
+          ignoreCase: boolean;
+          multiline: boolean;
+          unicode: boolean;
+          sticky: boolean;
+          dotAll: boolean;
+          hasIndices: boolean;
+          unicodeSets: boolean;
+        }
+      ) => void;
+      /**
+       * A function that is called when the validator found flags.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param global `g` flag.
+       * @param ignoreCase `i` flag.
+       * @param multiline `m` flag.
+       * @param unicode `u` flag.
+       * @param sticky `y` flag.
+       * @param dotAll `s` flag.
+       * @param hasIndices `d` flag.
+       *
+       * @deprecated Use `onRegExpFlags` instead.
+       */
+      onFlags?: (
+        start: number,
+        end: number,
+        global: boolean,
+        ignoreCase: boolean,
+        multiline: boolean,
+        unicode: boolean,
+        sticky: boolean,
+        dotAll: boolean,
+        hasIndices: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator entered a pattern.
+       * @param start The 0-based index of the first character.
+       */
+      onPatternEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a pattern.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onPatternLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered a disjunction.
+       * @param start The 0-based index of the first character.
+       */
+      onDisjunctionEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a disjunction.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onDisjunctionLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered an alternative.
+       * @param start The 0-based index of the first character.
+       * @param index The 0-based index of alternatives in a disjunction.
+       */
+      onAlternativeEnter?: (start: number, index: number) => void;
+      /**
+       * A function that is called when the validator left an alternative.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param index The 0-based index of alternatives in a disjunction.
+       */
+      onAlternativeLeave?: (start: number, end: number, index: number) => void;
+      /**
+       * A function that is called when the validator entered an uncapturing group.
+       * @param start The 0-based index of the first character.
+       */
+      onGroupEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left an uncapturing group.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onGroupLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered a modifiers.
+       * @param start The 0-based index of the first character.
+       */
+      onModifiersEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onModifiersLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator found an add modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param flags flags.
+       * @param flags.ignoreCase `i` flag.
+       * @param flags.multiline `m` flag.
+       * @param flags.dotAll `s` flag.
+       */
+      onAddModifiers?: (
+        start: number,
+        end: number,
+        flags: {
+          ignoreCase: boolean;
+          multiline: boolean;
+          dotAll: boolean;
+        }
+      ) => void;
+      /**
+       * A function that is called when the validator found a remove modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param flags flags.
+       * @param flags.ignoreCase `i` flag.
+       * @param flags.multiline `m` flag.
+       * @param flags.dotAll `s` flag.
+       */
+      onRemoveModifiers?: (
+        start: number,
+        end: number,
+        flags: {
+          ignoreCase: boolean;
+          multiline: boolean;
+          dotAll: boolean;
+        }
+      ) => void;
+      /**
+       * A function that is called when the validator entered a capturing group.
+       * @param start The 0-based index of the first character.
+       * @param name The group name.
+       */
+      onCapturingGroupEnter?: (start: number, name: string | null) => void;
+      /**
+       * A function that is called when the validator left a capturing group.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param name The group name.
+       */
+      onCapturingGroupLeave?: (
+        start: number,
+        end: number,
+        name: string | null
+      ) => void;
+      /**
+       * A function that is called when the validator found a quantifier.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param min The minimum number of repeating.
+       * @param max The maximum number of repeating.
+       * @param greedy The flag to choose the longest matching.
+       */
+      onQuantifier?: (
+        start: number,
+        end: number,
+        min: number,
+        max: number,
+        greedy: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator entered a lookahead/lookbehind assertion.
+       * @param start The 0-based index of the first character.
+       * @param kind The kind of the assertion.
+       * @param negate The flag which represents that the assertion is negative.
+       */
+      onLookaroundAssertionEnter?: (
+        start: number,
+        kind: "lookahead" | "lookbehind",
+        negate: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator left a lookahead/lookbehind assertion.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the assertion.
+       * @param negate The flag which represents that the assertion is negative.
+       */
+      onLookaroundAssertionLeave?: (
+        start: number,
+        end: number,
+        kind: "lookahead" | "lookbehind",
+        negate: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator found an edge boundary assertion.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the assertion.
+       */
+      onEdgeAssertion?: (
+        start: number,
+        end: number,
+        kind: "end" | "start"
+      ) => void;
+      /**
+       * A function that is called when the validator found a word boundary assertion.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the assertion.
+       * @param negate The flag which represents that the assertion is negative.
+       */
+      onWordBoundaryAssertion?: (
+        start: number,
+        end: number,
+        kind: "word",
+        negate: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator found a dot.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the character set.
+       */
+      onAnyCharacterSet?: (start: number, end: number, kind: "any") => void;
+      /**
+       * A function that is called when the validator found a character set escape.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the character set.
+       * @param negate The flag which represents that the character set is negative.
+       */
+      onEscapeCharacterSet?: (
+        start: number,
+        end: number,
+        kind: "digit" | "space" | "word",
+        negate: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator found a Unicode proerty escape.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param kind The kind of the character set.
+       * @param key The property name.
+       * @param value The property value.
+       * @param negate The flag which represents that the character set is negative.
+       * @param strings If true, the given property is property of strings.
+       */
+      onUnicodePropertyCharacterSet?: (
+        start: number,
+        end: number,
+        kind: "property",
+        key: string,
+        value: string | null,
+        negate: boolean,
+        strings: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator found a character.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param value The code point of the character.
+       */
+      onCharacter?: (start: number, end: number, value: number) => void;
+      /**
+       * A function that is called when the validator found a backreference.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param ref The key of the referred capturing group.
+       */
+      onBackreference?: (
+        start: number,
+        end: number,
+        ref: number | string
+      ) => void;
+      /**
+       * A function that is called when the validator entered a character class.
+       * @param start The 0-based index of the first character.
+       * @param negate The flag which represents that the character class is negative.
+       * @param unicodeSets `true` if unicodeSets mode.
+       */
+      onCharacterClassEnter?: (
+        start: number,
+        negate: boolean,
+        unicodeSets: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator left a character class.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param negate The flag which represents that the character class is negative.
+       */
+      onCharacterClassLeave?: (
+        start: number,
+        end: number,
+        negate: boolean
+      ) => void;
+      /**
+       * A function that is called when the validator found a character class range.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param min The minimum code point of the range.
+       * @param max The maximum code point of the range.
+       */
+      onCharacterClassRange?: (
+        start: number,
+        end: number,
+        min: number,
+        max: number
+      ) => void;
+      /**
+       * A function that is called when the validator found a class intersection.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onClassIntersection?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator found a class subtraction.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onClassSubtraction?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered a class string disjunction.
+       * @param start The 0-based index of the first character.
+       */
+      onClassStringDisjunctionEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a class string disjunction.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onClassStringDisjunctionLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered a string alternative.
+       * @param start The 0-based index of the first character.
+       * @param index The 0-based index of alternatives in a disjunction.
+       */
+      onStringAlternativeEnter?: (start: number, index: number) => void;
+      /**
+       * A function that is called when the validator left a string alternative.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param index The 0-based index of alternatives in a disjunction.
+       */
+      onStringAlternativeLeave?: (
+        start: number,
+        end: number,
+        index: number
+      ) => void;
+    }
+  }
+  /**
+   * The regular expression validator.
+   */
+  export class RegExpValidator {
+    /**
+     * Initialize this validator.
+     * @param options The options of validator.
+     */
+    constructor(options?: RegExpValidator.Options);
+    /**
+     * Validate a regular expression literal. E.g. "/abc/g"
+     * @param source The source code to validate.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     */
+    validateLiteral(source: string, start?: number, end?: number): void;
+    /**
+     * Validate a regular expression flags. E.g. "gim"
+     * @param source The source code to validate.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     */
+    validateFlags(source: string, start?: number, end?: number): void;
+    /**
+     * Validate a regular expression pattern. E.g. "abc"
+     * @param source The source code to validate.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @param flags The flags.
+     */
+    validatePattern(
+      source: string,
+      start?: number,
+      end?: number,
+      flags?: {
+        unicode?: boolean;
+        unicodeSets?: boolean;
+      }
+    ): void;
+    /**
+     * @deprecated Backward compatibility
+     * Use object `flags` instead of boolean `uFlag`.
+     * @param source The source code to validate.
+     * @param start The start index in the source code.
+     * @param end The end index in the source code.
+     * @param uFlag The flag to set unicode mode.
+     */
+    validatePattern(
+      source: string,
+      start?: number,
+      end?: number,
+      uFlag?: boolean
+    ): void;
+  }
+}
+
+declare module "@eslint-community/regexpp/visitor" {
+  import type {
+    Alternative,
+    Assertion,
+    Backreference,
+    CapturingGroup,
+    Character,
+    CharacterClass,
+    CharacterClassRange,
+    CharacterSet,
+    ClassIntersection,
+    ClassStringDisjunction,
+    ClassSubtraction,
+    ExpressionCharacterClass,
+    Flags,
+    Group,
+    ModifierFlags,
+    Modifiers,
+    Node,
+    Pattern,
+    Quantifier,
+    RegExpLiteral,
+    StringAlternative,
+  } from "@eslint-community/regexpp/ast";
+  /**
+   * The visitor to walk on AST.
+   */
+  export class RegExpVisitor {
+    /**
+     * Initialize this visitor.
+     * @param handlers Callbacks for each node.
+     */
+    constructor(handlers: RegExpVisitor.Handlers);
+    /**
+     * Visit a given node and descendant nodes.
+     * @param node The root node to visit tree.
+     */
+    visit(node: Node): void;
+  }
+  export namespace RegExpVisitor {
+    interface Handlers {
+      onAlternativeEnter?: (node: Alternative) => void;
+      onAlternativeLeave?: (node: Alternative) => void;
+      onAssertionEnter?: (node: Assertion) => void;
+      onAssertionLeave?: (node: Assertion) => void;
+      onBackreferenceEnter?: (node: Backreference) => void;
+      onBackreferenceLeave?: (node: Backreference) => void;
+      onCapturingGroupEnter?: (node: CapturingGroup) => void;
+      onCapturingGroupLeave?: (node: CapturingGroup) => void;
+      onCharacterEnter?: (node: Character) => void;
+      onCharacterLeave?: (node: Character) => void;
+      onCharacterClassEnter?: (node: CharacterClass) => void;
+      onCharacterClassLeave?: (node: CharacterClass) => void;
+      onCharacterClassRangeEnter?: (node: CharacterClassRange) => void;
+      onCharacterClassRangeLeave?: (node: CharacterClassRange) => void;
+      onCharacterSetEnter?: (node: CharacterSet) => void;
+      onCharacterSetLeave?: (node: CharacterSet) => void;
+      onClassIntersectionEnter?: (node: ClassIntersection) => void;
+      onClassIntersectionLeave?: (node: ClassIntersection) => void;
+      onClassStringDisjunctionEnter?: (node: ClassStringDisjunction) => void;
+      onClassStringDisjunctionLeave?: (node: ClassStringDisjunction) => void;
+      onClassSubtractionEnter?: (node: ClassSubtraction) => void;
+      onClassSubtractionLeave?: (node: ClassSubtraction) => void;
+      onExpressionCharacterClassEnter?: (
+        node: ExpressionCharacterClass
+      ) => void;
+      onExpressionCharacterClassLeave?: (
+        node: ExpressionCharacterClass
+      ) => void;
+      onFlagsEnter?: (node: Flags) => void;
+      onFlagsLeave?: (node: Flags) => void;
+      onGroupEnter?: (node: Group) => void;
+      onGroupLeave?: (node: Group) => void;
+      onModifierFlagsEnter?: (node: ModifierFlags) => void;
+      onModifierFlagsLeave?: (node: ModifierFlags) => void;
+      onModifiersEnter?: (node: Modifiers) => void;
+      onModifiersLeave?: (node: Modifiers) => void;
+      onPatternEnter?: (node: Pattern) => void;
+      onPatternLeave?: (node: Pattern) => void;
+      onQuantifierEnter?: (node: Quantifier) => void;
+      onQuantifierLeave?: (node: Quantifier) => void;
+      onRegExpLiteralEnter?: (node: RegExpLiteral) => void;
+      onRegExpLiteralLeave?: (node: RegExpLiteral) => void;
+      onStringAlternativeEnter?: (node: StringAlternative) => void;
+      onStringAlternativeLeave?: (node: StringAlternative) => void;
+    }
+  }
+}
+
+declare module "@eslint-community/regexpp/regexp-syntax-error" {
+  import type { RegExpValidatorSourceContext } from "@eslint-community/regexpp/validator";
+  export class RegExpSyntaxError extends SyntaxError {
+    index: number;
+    constructor(message: string, index: number);
+  }
+  export function newRegExpSyntaxError(
+    srcCtx: RegExpValidatorSourceContext,
+    flags: {
+      unicode: boolean;
+      unicodeSets: boolean;
+    },
+    index: number,
+    message: string
+  ): RegExpSyntaxError;
+}
+
+declare module "@eslint-community/regexpp/ecma-versions" {
+  export type EcmaVersion =
+    | 5
+    | 2015
+    | 2016
+    | 2017
+    | 2018
+    | 2019
+    | 2020
+    | 2021
+    | 2022
+    | 2023
+    | 2024
+    | 2025;
+  export const latestEcmaVersion = 2025;
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@eslint-community/regexpp/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@eslint-community/regexpp",
+  "version": "4.12.1",
+  "description": "Regular expression parser for ECMAScript.",
+  "keywords": [
+    "regexp",
+    "regular",
+    "expression",
+    "parser",
+    "validator",
+    "ast",
+    "abstract",
+    "syntax",
+    "tree",
+    "ecmascript",
+    "es2015",
+    "es2016",
+    "es2017",
+    "es2018",
+    "es2019",
+    "es2020",
+    "es2021",
+    "annexB"
+  ],
+  "homepage": "https://github.com/eslint-community/regexpp#readme",
+  "bugs": {
+    "url": "https://github.com/eslint-community/regexpp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eslint-community/regexpp"
+  },
+  "license": "MIT",
+  "author": "Toru Nagashima",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "index",
+  "files": [
+    "index.*"
+  ],
+  "scripts": {
+    "prebuild": "npm run -s clean",
+    "build": "run-s build:*",
+    "build:tsc": "tsc --module es2015",
+    "build:rollup": "rollup -c",
+    "build:dts": "npm run -s build:tsc -- --removeComments false && dts-bundle --name @eslint-community/regexpp --main .temp/index.d.ts --out ../index.d.ts && prettier --write index.d.ts",
+    "clean": "rimraf .temp index.*",
+    "lint": "eslint . --ext .ts",
+    "test": "nyc _mocha \"test/*.ts\" --reporter dot --timeout 10000",
+    "debug": "mocha --require ts-node/register/transpile-only \"test/*.ts\" --reporter dot --timeout 10000",
+    "update:test": "ts-node scripts/update-fixtures.ts",
+    "update:unicode": "run-s update:unicode:*",
+    "update:unicode:ids": "ts-node scripts/update-unicode-ids.ts",
+    "update:unicode:props": "ts-node scripts/update-unicode-properties.ts",
+    "update:test262:extract": "ts-node -T scripts/extract-test262.ts",
+    "preversion": "npm test && npm run -s build",
+    "postversion": "git push && git push --tags",
+    "prewatch": "npm run -s clean",
+    "watch": "_mocha \"test/*.ts\" --require ts-node/register --reporter dot --timeout 10000 --watch-extensions ts --watch --growl"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@eslint-community/eslint-plugin-mysticatea": "^15.5.1",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "@types/eslint": "^8.44.3",
+    "@types/jsdom": "^16.2.15",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^12.20.55",
+    "dts-bundle": "^0.7.3",
+    "eslint": "^8.50.0",
+    "js-tokens": "^8.0.2",
+    "jsdom": "^19.0.0",
+    "mocha": "^9.2.2",
+    "npm-run-all2": "^6.2.2",
+    "nyc": "^14.1.1",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-sourcemaps": "^0.6.3",
+    "ts-node": "^10.9.1",
+    "typescript": "~5.0.2"
+  },
+  "engines": {
+    "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+  }
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/createProjectService.d.ts

@@ -0,0 +1,60 @@
+import type { ProjectServiceOptions } from '@typescript-eslint/types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+/**
+ * Shortcut type to refer to TypeScript's server ProjectService.
+ */
+export type TypeScriptProjectService = ts.server.ProjectService;
+/**
+ * A created Project Service instance, as well as metadata on its creation.
+ */
+export interface ProjectServiceAndMetadata {
+    /**
+     * Files allowed to be loaded from the default project, if any were specified.
+     */
+    allowDefaultProject: string[] | undefined;
+    /**
+     * The performance.now() timestamp of the last reload of the project service.
+     */
+    lastReloadTimestamp: number;
+    /**
+     * The maximum number of files that can be matched by the default project.
+     */
+    maximumDefaultProjectFileMatchCount: number;
+    /**
+     * The created TypeScript Project Service instance.
+     */
+    service: TypeScriptProjectService;
+}
+/**
+ * Settings to create a new Project Service instance with {@link createProjectService}.
+ */
+export interface CreateProjectServiceSettings {
+    /**
+     * Granular options to configure the project service.
+     */
+    options?: ProjectServiceOptions;
+    /**
+     * How aggressively (and slowly) to parse JSDoc comments.
+     */
+    jsDocParsingMode?: ts.JSDocParsingMode;
+    /**
+     * Root directory for the tsconfig.json file, if not the current directory.
+     */
+    tsconfigRootDir?: string;
+}
+/**
+ * Creates a new Project Service instance, as well as metadata on its creation.
+ * @param settings Settings to create a new Project Service instance.
+ * @returns A new Project Service instance, as well as metadata on its creation.
+ * @example
+ * ```ts
+ * import { createProjectService } from '@typescript-eslint/project-service';
+ *
+ * const { service } = createProjectService();
+ *
+ * service.openClientFile('index.ts');
+ * ```
+ */
+export declare function createProjectService({ jsDocParsingMode, options: optionsRaw, tsconfigRootDir, }?: CreateProjectServiceSettings): ProjectServiceAndMetadata;
+export { type ProjectServiceOptions } from '@typescript-eslint/types';
+//# sourceMappingURL=createProjectService.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/createProjectService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createProjectService.d.ts","sourceRoot":"","sources":["../src/createProjectService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,KAAK,EAAE,MAAM,gCAAgC,CAAC;AA4B1D;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,mBAAmB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAE1C;;OAEG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,mCAAmC,EAAE,MAAM,CAAC;IAE5C;;OAEG;IACH,OAAO,EAAE,wBAAwB,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;OAEG;IACH,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAEhC;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC;IAEvC;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,gBAAgB,EAChB,OAAO,EAAE,UAAe,EACxB,eAAe,GAChB,GAAE,4BAAiC,GAAG,yBAAyB,CA0H/D;AAED,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,0BAA0B,CAAC"}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/createProjectService.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectService = createProjectService;
+const debug_1 = __importDefault(require("debug"));
+const getParsedConfigFileFromTSServer_js_1 = require("./getParsedConfigFileFromTSServer.js");
+const DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;
+const log = (0, debug_1.default)('typescript-eslint:project-service:createProjectService');
+const logTsserverErr = (0, debug_1.default)('typescript-eslint:project-service:tsserver:err');
+const logTsserverInfo = (0, debug_1.default)('typescript-eslint:project-service:tsserver:info');
+const logTsserverPerf = (0, debug_1.default)('typescript-eslint:project-service:tsserver:perf');
+const logTsserverEvent = (0, debug_1.default)('typescript-eslint:project-service:tsserver:event');
+// For TypeScript APIs that expect a function to be passed in
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const doNothing = () => { };
+const createStubFileWatcher = () => ({
+    close: doNothing,
+});
+/**
+ * Creates a new Project Service instance, as well as metadata on its creation.
+ * @param settings Settings to create a new Project Service instance.
+ * @returns A new Project Service instance, as well as metadata on its creation.
+ * @example
+ * ```ts
+ * import { createProjectService } from '@typescript-eslint/project-service';
+ *
+ * const { service } = createProjectService();
+ *
+ * service.openClientFile('index.ts');
+ * ```
+ */
+function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir, } = {}) {
+    const options = {
+        defaultProject: 'tsconfig.json',
+        ...optionsRaw,
+    };
+    // We import this lazily to avoid its cost for users who don't use the service
+    // TODO: Once we drop support for TS<5.3 we can import from "typescript" directly
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const tsserver = require('typescript/lib/tsserverlibrary');
+    // TODO: see getWatchProgramsForProjects
+    // We don't watch the disk, we just refer to these when ESLint calls us
+    // there's a whole separate update pass in maybeInvalidateProgram at the bottom of getWatchProgramsForProjects
+    // (this "goes nuclear on TypeScript")
+    const system = {
+        ...tsserver.sys,
+        clearImmediate,
+        clearTimeout,
+        setImmediate,
+        setTimeout,
+        watchDirectory: createStubFileWatcher,
+        watchFile: createStubFileWatcher,
+        // We stop loading any TypeScript plugins by default, to prevent them from attaching disk watchers
+        // See https://github.com/typescript-eslint/typescript-eslint/issues/9905
+        ...(!options.loadTypeScriptPlugins && {
+            require: () => ({
+                error: {
+                    message: 'TypeScript plugins are not required when using parserOptions.projectService.',
+                },
+                module: undefined,
+            }),
+        }),
+    };
+    const logger = {
+        close: doNothing,
+        endGroup: doNothing,
+        getLogFileName: () => undefined,
+        // The debug library doesn't use levels without creating a namespace for each.
+        // Log levels are not passed to the writer so we wouldn't be able to forward
+        // to a respective namespace.  Supporting would require an additional flag for
+        // granular control.  Defaulting to all levels for now.
+        hasLevel: () => true,
+        info(s) {
+            this.msg(s, tsserver.server.Msg.Info);
+        },
+        loggingEnabled: () => 
+        // if none of the debug namespaces are enabled, then don't enable logging in tsserver
+        logTsserverInfo.enabled ||
+            logTsserverErr.enabled ||
+            logTsserverPerf.enabled,
+        msg: (s, type) => {
+            switch (type) {
+                case tsserver.server.Msg.Err:
+                    logTsserverErr(s);
+                    break;
+                case tsserver.server.Msg.Perf:
+                    logTsserverPerf(s);
+                    break;
+                default:
+                    logTsserverInfo(s);
+            }
+        },
+        perftrc(s) {
+            this.msg(s, tsserver.server.Msg.Perf);
+        },
+        startGroup: doNothing,
+    };
+    log('Creating Project Service with: %o', options);
+    const service = new tsserver.server.ProjectService({
+        cancellationToken: { isCancellationRequested: () => false },
+        eventHandler: logTsserverEvent.enabled
+            ? (e) => {
+                logTsserverEvent(e);
+            }
+            : undefined,
+        host: system,
+        jsDocParsingMode,
+        logger,
+        session: undefined,
+        useInferredProjectPerProjectRoot: false,
+        useSingleInferredProject: false,
+    });
+    service.setHostConfiguration({
+        preferences: {
+            includePackageJsonAutoImports: 'off',
+        },
+    });
+    log('Enabling default project: %s', options.defaultProject);
+    const configFile = (0, getParsedConfigFileFromTSServer_js_1.getParsedConfigFileFromTSServer)(tsserver, options.defaultProject, !!optionsRaw.defaultProject, tsconfigRootDir);
+    if (configFile) {
+        service.setCompilerOptionsForInferredProjects(
+        // NOTE: The inferred projects API is not intended for source files when a tsconfig
+        // exists. There is no API that generates an InferredProjectCompilerOptions suggesting
+        // it is meant for hard coded options passed in. Hard asserting as a work around.
+        // See https://github.com/microsoft/TypeScript/blob/27bcd4cb5a98bce46c9cdd749752703ead021a4b/src/server/protocol.ts#L1904
+        configFile.options);
+    }
+    return {
+        allowDefaultProject: options.allowDefaultProject,
+        lastReloadTimestamp: performance.now(),
+        maximumDefaultProjectFileMatchCount: options.maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING ??
+            DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD,
+        service,
+    };
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/getParsedConfigFileFromTSServer.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function getParsedConfigFileFromTSServer(tsserver: typeof ts, defaultProject: string, throwOnFailure: boolean, tsconfigRootDir?: string): ts.ParsedCommandLine | undefined;
+//# sourceMappingURL=getParsedConfigFileFromTSServer.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/getParsedConfigFileFromTSServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getParsedConfigFileFromTSServer.d.ts","sourceRoot":"","sources":["../src/getParsedConfigFileFromTSServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAI1D,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,OAAO,EAAE,EACnB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,OAAO,EACvB,eAAe,CAAC,EAAE,MAAM,GACvB,EAAE,CAAC,iBAAiB,GAAG,SAAS,CAYlC"}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/getParsedConfigFileFromTSServer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsedConfigFileFromTSServer = getParsedConfigFileFromTSServer;
+const tsconfig_utils_1 = require("@typescript-eslint/tsconfig-utils");
+function getParsedConfigFileFromTSServer(tsserver, defaultProject, throwOnFailure, tsconfigRootDir) {
+    try {
+        return (0, tsconfig_utils_1.getParsedConfigFile)(tsserver, defaultProject, tsconfigRootDir);
+    }
+    catch (error) {
+        if (throwOnFailure) {
+            throw new Error(`Could not read Project Service default project '${defaultProject}': ${error.message}`);
+        }
+    }
+    return undefined;
+}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createProjectService';
+//# sourceMappingURL=index.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/project-service/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createProjectService"), exports);

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/referencer/Referencer.d.ts

@@ -0,0 +1,87 @@
+import type { Lib, TSESTree } from '@typescript-eslint/types';
+import type { Scope } from '../scope';
+import type { ScopeManager } from '../ScopeManager';
+import type { ReferenceImplicitGlobal } from './Reference';
+import type { VisitorOptions } from './Visitor';
+import { Visitor } from './Visitor';
+export interface ReferencerOptions extends VisitorOptions {
+    jsxFragmentName: string | null;
+    jsxPragma: string | null;
+    lib: Lib[];
+}
+export declare class Referencer extends Visitor {
+    #private;
+    readonly scopeManager: ScopeManager;
+    constructor(options: ReferencerOptions, scopeManager: ScopeManager);
+    private populateGlobalsFromLib;
+    close(node: TSESTree.Node): void;
+    currentScope(): Scope;
+    currentScope(throwOnNull: true): Scope | null;
+    referencingDefaultValue(pattern: TSESTree.Identifier, assignments: (TSESTree.AssignmentExpression | TSESTree.AssignmentPattern)[], maybeImplicitGlobal: ReferenceImplicitGlobal | null, init: boolean): void;
+    /**
+     * Searches for a variable named "name" in the upper scopes and adds a pseudo-reference from itself to itself
+     */
+    private referenceInSomeUpperScope;
+    private referenceJsxFragment;
+    private referenceJsxPragma;
+    protected visitClass(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): void;
+    protected visitForIn(node: TSESTree.ForInStatement | TSESTree.ForOfStatement): void;
+    protected visitFunction(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.TSDeclareFunction | TSESTree.TSEmptyBodyFunctionExpression): void;
+    protected visitFunctionParameterTypeAnnotation(node: TSESTree.Parameter): void;
+    protected visitJSXElement(node: TSESTree.JSXClosingElement | TSESTree.JSXOpeningElement): void;
+    protected visitProperty(node: TSESTree.Property): void;
+    protected visitType(node: TSESTree.Node | null | undefined): void;
+    protected visitTypeAssertion(node: TSESTree.TSAsExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion): void;
+    protected ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
+    protected AssignmentExpression(node: TSESTree.AssignmentExpression): void;
+    protected BlockStatement(node: TSESTree.BlockStatement): void;
+    protected BreakStatement(): void;
+    protected CallExpression(node: TSESTree.CallExpression): void;
+    protected CatchClause(node: TSESTree.CatchClause): void;
+    protected ClassDeclaration(node: TSESTree.ClassDeclaration): void;
+    protected ClassExpression(node: TSESTree.ClassExpression): void;
+    protected ContinueStatement(): void;
+    protected ExportAllDeclaration(): void;
+    protected ExportDefaultDeclaration(node: TSESTree.ExportDefaultDeclaration): void;
+    protected ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void;
+    protected ForInStatement(node: TSESTree.ForInStatement): void;
+    protected ForOfStatement(node: TSESTree.ForOfStatement): void;
+    protected ForStatement(node: TSESTree.ForStatement): void;
+    protected FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
+    protected FunctionExpression(node: TSESTree.FunctionExpression): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+    protected ImportAttribute(): void;
+    protected ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    protected JSXAttribute(node: TSESTree.JSXAttribute): void;
+    protected JSXClosingElement(node: TSESTree.JSXClosingElement): void;
+    protected JSXFragment(node: TSESTree.JSXFragment): void;
+    protected JSXIdentifier(node: TSESTree.JSXIdentifier): void;
+    protected JSXMemberExpression(node: TSESTree.JSXMemberExpression): void;
+    protected JSXOpeningElement(node: TSESTree.JSXOpeningElement): void;
+    protected LabeledStatement(node: TSESTree.LabeledStatement): void;
+    protected MemberExpression(node: TSESTree.MemberExpression): void;
+    protected MetaProperty(): void;
+    protected NewExpression(node: TSESTree.NewExpression): void;
+    protected PrivateIdentifier(): void;
+    protected Program(node: TSESTree.Program): void;
+    protected Property(node: TSESTree.Property): void;
+    protected SwitchStatement(node: TSESTree.SwitchStatement): void;
+    protected TaggedTemplateExpression(node: TSESTree.TaggedTemplateExpression): void;
+    protected TSAsExpression(node: TSESTree.TSAsExpression): void;
+    protected TSDeclareFunction(node: TSESTree.TSDeclareFunction): void;
+    protected TSEmptyBodyFunctionExpression(node: TSESTree.TSEmptyBodyFunctionExpression): void;
+    protected TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void;
+    protected TSExportAssignment(node: TSESTree.TSExportAssignment): void;
+    protected TSImportEqualsDeclaration(node: TSESTree.TSImportEqualsDeclaration): void;
+    protected TSInstantiationExpression(node: TSESTree.TSInstantiationExpression): void;
+    protected TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void;
+    protected TSModuleDeclaration(node: TSESTree.TSModuleDeclaration): void;
+    protected TSSatisfiesExpression(node: TSESTree.TSSatisfiesExpression): void;
+    protected TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    protected TSTypeAssertion(node: TSESTree.TSTypeAssertion): void;
+    protected UpdateExpression(node: TSESTree.UpdateExpression): void;
+    protected VariableDeclaration(node: TSESTree.VariableDeclaration): void;
+    protected WithStatement(node: TSESTree.WithStatement): void;
+    private visitExpressionTarget;
+}
+//# sourceMappingURL=Referencer.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/referencer/TypeVisitor.d.ts

@@ -0,0 +1,32 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+export declare class TypeVisitor extends Visitor {
+    #private;
+    constructor(referencer: Referencer);
+    static visit(referencer: Referencer, node: TSESTree.Node): void;
+    protected visitFunctionType(node: TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSFunctionType | TSESTree.TSMethodSignature): void;
+    protected visitPropertyKey(node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature): void;
+    protected Identifier(node: TSESTree.Identifier): void;
+    protected MemberExpression(node: TSESTree.MemberExpression): void;
+    protected TSCallSignatureDeclaration(node: TSESTree.TSCallSignatureDeclaration): void;
+    protected TSConditionalType(node: TSESTree.TSConditionalType): void;
+    protected TSConstructorType(node: TSESTree.TSConstructorType): void;
+    protected TSConstructSignatureDeclaration(node: TSESTree.TSConstructSignatureDeclaration): void;
+    protected TSFunctionType(node: TSESTree.TSFunctionType): void;
+    protected TSImportType(node: TSESTree.TSImportType): void;
+    protected TSIndexSignature(node: TSESTree.TSIndexSignature): void;
+    protected TSInferType(node: TSESTree.TSInferType): void;
+    protected TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void;
+    protected TSMappedType(node: TSESTree.TSMappedType): void;
+    protected TSMethodSignature(node: TSESTree.TSMethodSignature): void;
+    protected TSNamedTupleMember(node: TSESTree.TSNamedTupleMember): void;
+    protected TSPropertySignature(node: TSESTree.TSPropertySignature): void;
+    protected TSQualifiedName(node: TSESTree.TSQualifiedName): void;
+    protected TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    protected TSTypeParameter(node: TSESTree.TSTypeParameter): void;
+    protected TSTypePredicate(node: TSESTree.TSTypePredicate): void;
+    protected TSTypeAnnotation(node: TSESTree.TSTypeAnnotation): void;
+    protected TSTypeQuery(node: TSESTree.TSTypeQuery): void;
+}
+//# sourceMappingURL=TypeVisitor.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/referencer/Visitor.d.ts

@@ -0,0 +1,14 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { PatternVisitorCallback, PatternVisitorOptions } from './PatternVisitor';
+import type { VisitorOptions } from './VisitorBase';
+import { VisitorBase } from './VisitorBase';
+interface VisitPatternOptions extends PatternVisitorOptions {
+    processRightHandNodes?: boolean;
+}
+export declare class Visitor extends VisitorBase {
+    #private;
+    constructor(optionsOrVisitor: Visitor | VisitorOptions);
+    protected visitPattern(node: TSESTree.Node, callback: PatternVisitorCallback, options?: VisitPatternOptions): void;
+}
+export { VisitorBase, type VisitorOptions } from './VisitorBase';
+//# sourceMappingURL=Visitor.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/referencer/VisitorBase.d.ts

@@ -0,0 +1,22 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import type { VisitorKeys } from '@typescript-eslint/visitor-keys';
+export interface VisitorOptions {
+    childVisitorKeys?: VisitorKeys | null;
+    visitChildrenEvenIfSelectorExists?: boolean;
+}
+export declare abstract class VisitorBase {
+    #private;
+    constructor(options: VisitorOptions);
+    /**
+     * Default method for visiting children.
+     * @param node the node whose children should be visited
+     * @param excludeArr a list of keys to not visit
+     */
+    visitChildren<T extends TSESTree.Node>(node: T | null | undefined, excludeArr?: (keyof T)[]): void;
+    /**
+     * Dispatching node.
+     */
+    visit(node: TSESTree.Node | null | undefined): void;
+}
+export type { VisitorKeys } from '@typescript-eslint/visitor-keys';
+//# sourceMappingURL=VisitorBase.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ESLintScopeVariable.d.ts

@@ -0,0 +1,33 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import { VariableBase } from './VariableBase';
+/**
+ * ESLint defines global variables using the eslint-scope Variable class
+ * This is declared here for consumers to use
+ */
+export declare class ESLintScopeVariable extends VariableBase {
+    /**
+     * Written to by ESLint.
+     * If this key exists, this variable is a global variable added by ESLint.
+     * If this is `true`, this variable can be assigned arbitrary values.
+     * If this is `false`, this variable is readonly.
+     */
+    writeable?: boolean;
+    /**
+     * Written to by ESLint.
+     * This property is undefined if there are no globals comment directives.
+     * The array of globals comment directives which defined this global variable in the source code file.
+     */
+    eslintExplicitGlobal?: boolean;
+    /**
+     * Written to by ESLint.
+     * The configured value in config files. This can be different from `variable.writeable` if there are globals comment directives.
+     */
+    eslintImplicitGlobalSetting?: 'readonly' | 'writable';
+    /**
+     * Written to by ESLint.
+     * If this key exists, it is a global variable added by ESLint.
+     * If `true`, this global variable was defined by a globals comment directive in the source code file.
+     */
+    eslintExplicitGlobalComments?: TSESTree.Comment[];
+}
+//# sourceMappingURL=ESLintScopeVariable.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ESLintScopeVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESLintScopeVariable.d.ts","sourceRoot":"","sources":["../../src/variable/ESLintScopeVariable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,YAAY;IACnD;;;;;OAKG;IACI,SAAS,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACI,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAEtC;;;OAGG;IACI,2BAA2B,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAE7D;;;;OAIG;IACI,4BAA4B,CAAC,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;CAC1D"}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ESLintScopeVariable.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESLintScopeVariable = void 0;
+const VariableBase_1 = require("./VariableBase");
+/**
+ * ESLint defines global variables using the eslint-scope Variable class
+ * This is declared here for consumers to use
+ */
+class ESLintScopeVariable extends VariableBase_1.VariableBase {
+    /**
+     * Written to by ESLint.
+     * If this key exists, this variable is a global variable added by ESLint.
+     * If this is `true`, this variable can be assigned arbitrary values.
+     * If this is `false`, this variable is readonly.
+     */
+    writeable; // note that this isn't a typo - ESlint uses this spelling here
+    /**
+     * Written to by ESLint.
+     * This property is undefined if there are no globals comment directives.
+     * The array of globals comment directives which defined this global variable in the source code file.
+     */
+    eslintExplicitGlobal;
+    /**
+     * Written to by ESLint.
+     * The configured value in config files. This can be different from `variable.writeable` if there are globals comment directives.
+     */
+    eslintImplicitGlobalSetting;
+    /**
+     * Written to by ESLint.
+     * If this key exists, it is a global variable added by ESLint.
+     * If `true`, this global variable was defined by a globals comment directive in the source code file.
+     */
+    eslintExplicitGlobalComments;
+}
+exports.ESLintScopeVariable = ESLintScopeVariable;

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ImplicitLibVariable.d.ts

@@ -0,0 +1,28 @@
+import type { Scope } from '../scope';
+import type { Variable } from './Variable';
+import { ESLintScopeVariable } from './ESLintScopeVariable';
+export interface ImplicitLibVariableOptions {
+    readonly eslintImplicitGlobalSetting?: ESLintScopeVariable['eslintImplicitGlobalSetting'];
+    readonly isTypeVariable?: boolean;
+    readonly isValueVariable?: boolean;
+    readonly writeable?: boolean;
+}
+export interface LibDefinition {
+    libs: readonly LibDefinition[];
+    variables: readonly [string, ImplicitLibVariableOptions][];
+}
+/**
+ * An variable implicitly defined by the TS Lib
+ */
+export declare class ImplicitLibVariable extends ESLintScopeVariable implements Variable {
+    /**
+     * `true` if the variable is valid in a type context, false otherwise
+     */
+    readonly isTypeVariable: boolean;
+    /**
+     * `true` if the variable is valid in a value context, false otherwise
+     */
+    readonly isValueVariable: boolean;
+    constructor(scope: Scope, name: string, { eslintImplicitGlobalSetting, isTypeVariable, isValueVariable, writeable, }: ImplicitLibVariableOptions);
+}
+//# sourceMappingURL=ImplicitLibVariable.d.ts.map

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ImplicitLibVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImplicitLibVariable.d.ts","sourceRoot":"","sources":["../../src/variable/ImplicitLibVariable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,2BAA2B,CAAC,EAAE,mBAAmB,CAAC,6BAA6B,CAAC,CAAC;IAC1F,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,0BAA0B,CAAC,EAAE,CAAC;CAC5D;AAED;;GAEG;AACH,qBAAa,mBACX,SAAQ,mBACR,YAAW,QAAQ;IAEnB;;OAEG;IACH,SAAgB,cAAc,EAAE,OAAO,CAAC;IAExC;;OAEG;IACH,SAAgB,eAAe,EAAE,OAAO,CAAC;gBAGvC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,EACZ,EACE,2BAA2B,EAC3B,cAAc,EACd,eAAe,EACf,SAAS,GACV,EAAE,0BAA0B;CAShC"}

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/ImplicitLibVariable.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplicitLibVariable = void 0;
+const ESLintScopeVariable_1 = require("./ESLintScopeVariable");
+/**
+ * An variable implicitly defined by the TS Lib
+ */
+class ImplicitLibVariable extends ESLintScopeVariable_1.ESLintScopeVariable {
+    /**
+     * `true` if the variable is valid in a type context, false otherwise
+     */
+    isTypeVariable;
+    /**
+     * `true` if the variable is valid in a value context, false otherwise
+     */
+    isValueVariable;
+    constructor(scope, name, { eslintImplicitGlobalSetting, isTypeVariable, isValueVariable, writeable, }) {
+        super(name, scope);
+        this.isTypeVariable = isTypeVariable ?? false;
+        this.isValueVariable = isValueVariable ?? false;
+        this.writeable = writeable ?? false;
+        this.eslintImplicitGlobalSetting =
+            eslintImplicitGlobalSetting ?? 'readonly';
+    }
+}
+exports.ImplicitLibVariable = ImplicitLibVariable;

novas/novacore-zephyr/claude-code-router/ui/node_modules/@typescript-eslint/scope-manager/dist/variable/Variable.d.ts

@@ -0,0 +1,17 @@
+import { VariableBase } from './VariableBase';
+/**
+ * A Variable represents a locally scoped identifier. These include arguments to functions.
+ */
+export declare class Variable extends VariableBase {
+    /**
+     * `true` if the variable is valid in a type context, false otherwise
+     * @public
+     */
+    get isTypeVariable(): boolean;
+    /**
+     * `true` if the variable is valid in a value context, false otherwise
+     * @public
+     */
+    get isValueVariable(): boolean;
+}
+//# sourceMappingURL=Variable.d.ts.map