@so1ve/eslint-config
Version:
Ray's eslint config.
1,544 lines (1,529 loc) • 1.34 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// build/shims.ts
import { createRequire } from "node:module";
import { dirname } from "node:path";
import { fileURLToPath } from "node:url";
var init_shims = __esm({
"build/shims.ts"() {
"use strict";
globalThis.require = createRequire(import.meta.url);
globalThis.__filename = fileURLToPath(import.meta.url);
globalThis.__dirname = dirname(__filename);
}
});
// ../../node_modules/.pnpm/tslib@2.6.2/node_modules/tslib/tslib.es6.mjs
var tslib_es6_exports = {};
__export(tslib_es6_exports, {
__addDisposableResource: () => __addDisposableResource,
__assign: () => __assign,
__asyncDelegator: () => __asyncDelegator,
__asyncGenerator: () => __asyncGenerator,
__asyncValues: () => __asyncValues,
__await: () => __await,
__awaiter: () => __awaiter,
__classPrivateFieldGet: () => __classPrivateFieldGet,
__classPrivateFieldIn: () => __classPrivateFieldIn,
__classPrivateFieldSet: () => __classPrivateFieldSet,
__createBinding: () => __createBinding,
__decorate: () => __decorate,
__disposeResources: () => __disposeResources,
__esDecorate: () => __esDecorate,
__exportStar: () => __exportStar,
__extends: () => __extends,
__generator: () => __generator,
__importDefault: () => __importDefault,
__importStar: () => __importStar,
__makeTemplateObject: () => __makeTemplateObject,
__metadata: () => __metadata,
__param: () => __param,
__propKey: () => __propKey,
__read: () => __read,
__rest: () => __rest,
__runInitializers: () => __runInitializers,
__setFunctionName: () => __setFunctionName,
__spread: () => __spread,
__spreadArray: () => __spreadArray,
__spreadArrays: () => __spreadArrays,
__values: () => __values,
default: () => tslib_es6_default
});
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
}
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) {
if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
return f;
}
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
context.addInitializer = function(f) {
if (done) throw new TypeError("Cannot add initializers after decoration has completed");
extraInitializers.push(accept(f || null));
};
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0) continue;
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
if (_ = accept(result.get)) descriptor.get = _;
if (_ = accept(result.set)) descriptor.set = _;
if (_ = accept(result.init)) initializers.unshift(_);
} else if (_ = accept(result)) {
if (kind === "field") initializers.unshift(_);
else descriptor[key] = _;
}
}
if (target) Object.defineProperty(target, contextIn.name, descriptor);
done = true;
}
function __runInitializers(thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
}
function __propKey(x) {
return typeof x === "symbol" ? x : "".concat(x);
}
function __setFunctionName(f, name, prefix) {
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, o) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function() {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function verb(n) {
if (g[n]) i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
}
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function(e) {
throw e;
}), verb("return"), i[Symbol.iterator] = function() {
return this;
}, i;
function verb(n, f) {
i[n] = o[n] ? function(v) {
return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
} : f;
}
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve, reject) {
v = o[n](v), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve({ value: v2, done: d });
}, reject);
}
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
} else {
cooked.raw = raw;
}
return cooked;
}
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return mod && mod.__esModule ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
function __classPrivateFieldIn(state, receiver) {
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
}
function __addDisposableResource(env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
env.stack.push({ value, dispose, async });
} else if (async) {
env.stack.push({ async: true });
}
return value;
}
function __disposeResources(env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
function next() {
while (env.stack.length) {
var rec = env.stack.pop();
try {
var result = rec.dispose && rec.dispose.call(rec.value);
if (rec.async) return Promise.resolve(result).then(next, function(e) {
fail(e);
return next();
});
} catch (e) {
fail(e);
}
}
if (env.hasError) throw env.error;
}
return next();
}
var extendStatics, __assign, __createBinding, __setModuleDefault, _SuppressedError, tslib_es6_default;
var init_tslib_es6 = __esm({
"../../node_modules/.pnpm/tslib@2.6.2/node_modules/tslib/tslib.es6.mjs"() {
"use strict";
init_shims();
extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
__assign = function() {
__assign = Object.assign || function __assign2(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
__createBinding = Object.create ? function(o, m, k, k2) {
if (k2 === void 0) 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 === void 0) k2 = k;
o[k2] = m[k];
};
__setModuleDefault = Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
};
_SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
tslib_es6_default = {
__extends,
__assign,
__rest,
__decorate,
__param,
__metadata,
__awaiter,
__generator,
__createBinding,
__exportStar,
__values,
__read,
__spread,
__spreadArrays,
__spreadArray,
__await,
__asyncGenerator,
__asyncDelegator,
__asyncValues,
__makeTemplateObject,
__importStar,
__importDefault,
__classPrivateFieldGet,
__classPrivateFieldSet,
__classPrivateFieldIn,
__addDisposableResource,
__disposeResources
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/electron.js
var require_electron = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/electron.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
settings: {
"import-x/core-modules": ["electron"]
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/errors.js
var require_errors = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/errors.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
plugins: ["import-x"],
rules: {
"import-x/no-unresolved": 2,
"import-x/named": 2,
"import-x/namespace": 2,
"import-x/default": 2,
"import-x/export": 2
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/react.js
var require_react = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/react.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
settings: {
"import-x/extensions": [".js", ".jsx"]
},
parserOptions: {
ecmaFeatures: {
jsx: true
}
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/react-native.js
var require_react_native = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/react-native.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
settings: {
"import-x/resolver": {
node: {
extensions: [".js", ".web.js", ".ios.js", ".android.js"]
}
}
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/recommended.js
var require_recommended = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/recommended.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
plugins: ["import-x"],
rules: {
"import-x/no-unresolved": "error",
"import-x/named": "error",
"import-x/namespace": "error",
"import-x/default": "error",
"import-x/export": "error",
"import-x/no-named-as-default": "warn",
"import-x/no-named-as-default-member": "warn",
"import-x/no-duplicates": "warn"
},
parserOptions: {
sourceType: "module",
ecmaVersion: 2018
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/stage-0.js
var require_stage_0 = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/stage-0.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
plugins: ["import-x"],
rules: {
"import-x/no-deprecated": 1
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/typescript.js
var require_typescript = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/typescript.js"(exports, module) {
"use strict";
init_shims();
var typeScriptExtensions = [".ts", ".tsx"];
var allExtensions = [...typeScriptExtensions, ".js", ".jsx"];
module.exports = {
settings: {
"import-x/extensions": allExtensions,
"import-x/external-module-folders": ["node_modules", "node_modules/@types"],
"import-x/parsers": {
"@typescript-eslint/parser": [...typeScriptExtensions, ".cts", ".mts"]
},
"import-x/resolver": {
node: {
extensions: allExtensions
}
}
},
rules: {
"import-x/named": "off"
}
};
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/warnings.js
var require_warnings = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/config/warnings.js"(exports, module) {
"use strict";
init_shims();
module.exports = {
plugins: ["import-x"],
rules: {
"import-x/no-named-as-default": 1,
"import-x/no-named-as-default-member": 1,
"import-x/no-duplicates": 1
}
};
}
});
// ../../node_modules/.pnpm/eslint-compat-utils@0.5.1_eslint@9.4.0/node_modules/eslint-compat-utils/dist/index.cjs
var require_dist = __commonJS({
"../../node_modules/.pnpm/eslint-compat-utils@0.5.1_eslint@9.4.0/node_modules/eslint-compat-utils/dist/index.cjs"(exports) {
"use strict";
init_shims();
var path = __require("path");
var fs2 = __require("fs");
function applyPolyfills(object, polyfill) {
return new Proxy(object, {
get(_target, p) {
var _a;
return (_a = object[p]) != null ? _a : polyfill[p];
}
});
}
function getParent(node2) {
return node2.parent;
}
var cache = /* @__PURE__ */ new WeakMap();
function getSourceCode(context) {
const original = context.sourceCode || context.getSourceCode();
const cached = cache.get(original);
if (cached) {
return cached;
}
const sourceCode = applyPolyfills(original, {
getScope(node2) {
const inner = node2.type !== "Program";
for (let n = node2; n; n = getParent(n)) {
const scope = original.scopeManager.acquire(n, inner);
if (scope) {
if (scope.type === "function-expression-name") {
return scope.childScopes[0];
}
return scope;
}
}
return original.scopeManager.scopes[0];
},
markVariableAsUsed(name, refNode = original.ast) {
const currentScope = sourceCode.getScope(refNode);
if (currentScope === context.getScope()) {
return context.markVariableAsUsed(name);
}
let initialScope = currentScope;
if (currentScope.type === "global" && currentScope.childScopes.length > 0 && currentScope.childScopes[0].block === original.ast) {
initialScope = currentScope.childScopes[0];
}
for (let scope = initialScope; scope; scope = scope.upper) {
const variable = scope.variables.find(
(scopeVar) => scopeVar.name === name
);
if (variable) {
variable.eslintUsed = true;
return true;
}
}
return false;
},
getAncestors(node2) {
const result = [];
for (let ancestor = getParent(node2); ancestor; ancestor = ancestor.parent) {
result.unshift(ancestor);
}
return result;
},
getDeclaredVariables(node2) {
return original.scopeManager.getDeclaredVariables(node2);
},
isSpaceBetween(first, second) {
if (first.range[0] <= second.range[1] && second.range[0] <= first.range[1]) {
return false;
}
const [startingNodeOrToken, endingNodeOrToken] = first.range[1] <= second.range[0] ? [first, second] : [second, first];
const tokens = sourceCode.getTokensBetween(first, second, {
includeComments: true
});
let startIndex = startingNodeOrToken.range[1];
for (const token of tokens) {
if (startIndex !== token.range[0]) {
return true;
}
startIndex = token.range[1];
}
return startIndex !== endingNodeOrToken.range[0];
}
});
cache.set(original, sourceCode);
return sourceCode;
}
function getCwd(context) {
var _a, _b, _c;
return (_c = (_b = context.cwd) != null ? _b : (_a = context.getCwd) == null ? void 0 : _a.call(context)) != null ? _c : (
// getCwd is added in v6.6.0
process.cwd()
);
}
function getFilename(context) {
var _a;
return (_a = context.filename) != null ? _a : context.getFilename();
}
function getPhysicalFilename(context) {
var _a, _b;
const physicalFilename = (_b = context.physicalFilename) != null ? _b : (_a = context.getPhysicalFilename) == null ? void 0 : _a.call(context);
if (physicalFilename != null) {
return physicalFilename;
}
const filename = getFilename(context);
let target = filename;
while (/^\d+_/u.test(path.basename(target)) && !fs2.existsSync(target)) {
const next = path.dirname(target);
if (next === target || !path.extname(next)) {
break;
}
target = next;
}
return target;
}
exports.getCwd = getCwd;
exports.getFilename = getFilename;
exports.getPhysicalFilename = getPhysicalFilename;
exports.getSourceCode = getSourceCode;
}
});
// ../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/utils/constants.js
var require_constants = __commonJS({
"../../node_modules/.pnpm/eslint-plugin-import-x@0.4.4_patch_hash=4oryti2zfrehz2qi62zyaaa334_eslint@9.4.0_typescript@5.4.5/node_modules/eslint-plugin-import-x/lib/utils/constants.js"(exports) {
"use strict";
init_shims();
Object.defineProperty(exports, "__esModule", { value: true });
exports.pluginName = void 0;
exports.pluginName = "import-x";
}
});
// ../../node_modules/.pnpm/eslint-visitor-keys@3.4.3/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs
var require_eslint_visitor_keys = __commonJS({
"../../node_modules/.pnpm/eslint-visitor-keys@3.4.3/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs"(exports) {
"use strict";
init_shims();
Object.defineProperty(exports, "__esModule", { value: true });
var 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"
]
};
var NODE_TYPES = Object.keys(KEYS);
for (const type of NODE_TYPES) {
Object.freeze(KEYS[type]);
}
Object.freeze(KEYS);
var KEY_BLACKLIST = /* @__PURE__ */ new Set([
"parent",
"leadingComments",
"trailingComments"
]);
function filterKey(key) {
return !KEY_BLACKLIST.has(key) && key[0] !== "_";
}
function getKeys(node2) {
return Object.keys(node2).filter(filterKey);
}
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;
}
});
// ../../node_modules/.pnpm/@eslint-community+eslint-utils@4.4.0_eslint@9.4.0/node_modules/@eslint-community/eslint-utils/index.js
var require_eslint_utils = __commonJS({
"../../node_modules/.pnpm/@eslint-community+eslint-utils@4.4.0_eslint@9.4.0/node_modules/@eslint-community/eslint-utils/index.js"(exports) {
"use strict";
init_shims();
Object.defineProperty(exports, "__esModule", { value: true });
var eslintVisitorKeys = require_eslint_visitor_keys();
function getInnermostScope(initialScope, node2) {
const location = node2.range[0];
let scope = initialScope;
let found = false;
do {
found = false;
for (const childScope of scope.childScopes) {
const range = childScope.block.range;
if (range[0] <= location && location < range[1]) {
scope = childScope;
found = true;
break;
}
}
} while (found);
return scope;
}
function findVariable(initialScope, nameOrNode) {
let name = "";
let scope = initialScope;
if (typeof nameOrNode === "string") {
name = nameOrNode;
} else {
name = nameOrNode.name;
scope = getInnermostScope(scope, nameOrNode);
}
while (scope != null) {
const variable = scope.set.get(name);
if (variable != null) {
return variable;
}
scope = scope.upper;
}
return null;
}
function negate0(token) {
return !this(token);
}
function negate(f) {
return negate0.bind(f);
}
function isPunctuatorTokenWithValue(token, value) {
return token.type === "Punctuator" && token.value === value;
}
function isArrowToken(token) {
return isPunctuatorTokenWithValue(token, "=>");
}
function isCommaToken(token) {
return isPunctuatorTokenWithValue(token, ",");
}
function isSemicolonToken(token) {
return isPunctuatorTokenWithValue(token, ";");
}
function isColonToken(token) {
return isPunctuatorTokenWithValue(token, ":");
}
function isOpeningParenToken(token) {
return isPunctuatorTokenWithValue(token, "(");
}
function isClosingParenToken(token) {
return isPunctuatorTokenWithValue(token, ")");
}
function isOpeningBracketToken(token) {
return isPunctuatorTokenWithValue(token, "[");
}
function isClosingBracketToken(token) {
return isPunctuatorTokenWithValue(token, "]");
}
function isOpeningBraceToken(token) {
return isPunctuatorTokenWithValue(token, "{");
}
function isClosingBraceToken(token) {
return isPunctuatorTokenWithValue(token, "}");
}
function isCommentToken(token) {
return ["Block", "Line", "Shebang"].includes(token.type);
}
var isNotArrowToken = negate(isArrowToken);
var isNotCommaToken = negate(isCommaToken);
var isNotSemicolonToken = negate(isSemicolonToken);
var isNotColonToken = negate(isColonToken);
var isNotOpeningParenToken = negate(isOpeningParenToken);
var isNotClosingParenToken = negate(isClosingParenToken);
var isNotOpeningBracketToken = negate(isOpeningBracketToken);
var isNotClosingBracketToken = negate(isClosingBracketToken);
var isNotOpeningBraceToken = negate(isOpeningBraceToken);
var isNotClosingBraceToken = negate(isClosingBraceToken);
var isNotCommentToken = negate(isCommentToken);
function getOpeningParenOfParams(node2, sourceCode) {
return node2.id ? sourceCode.getTokenAfter(node2.id, isOpeningParenToken) : sourceCode.getFirstToken(node2, isOpeningParenToken);
}
function getFunctionHeadLocation(node2, sourceCode) {
const parent = node2.parent;
let start = null;
let end = null;
if (node2.type === "ArrowFunctionExpression") {
const arrowToken = sourceCode.getTokenBefore(node2.body, isArrowToken);
start = arrowToken.loc.start;
end = arrowToken.loc.end;
} else if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
start = parent.loc.start;
end = getOpeningParenOfParams(node2, sourceCode).loc.start;
} else {
start = node2.loc.start;
end = getOpeningParenOfParams(node2, sourceCode).loc.start;
}
return {
start: { ...start },
end: { ...end }
};
}
var globalObject = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
var builtinNames = Object.freeze(
/* @__PURE__ */ 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"
])
);
var 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 : void 0,
Boolean,
Date,
Date.parse,
decodeURI,
decodeURIComponent,
encodeURI,
encodeURIComponent,
escape,
isFinite,
isNaN,
isPrototypeOf,
Map,
Map.prototype.entries,
Map.prototype.get,
Map.prototype.has,
Map.prototype.keys,
Map.prototype.values,
...Object.getOwnPropertyNames(Math).filter((k) => k !== "random").map((k) => Math[k]).filter((f) => typeof f === "function"),
Number,
Number.isFinite,
Number.isNaN,
Number.parseFloat,
Number.parseInt,
Number.prototype.toExponential,
Number.prototype.toFixed,
Number.prototype.toPrecision,
Number.prototype.toString,
Object,
Object.entries,
Object.is,
Object.isExtensible,
Object.isFrozen,
Object.isSealed,
Object.keys,
Object.values,
parseFloat,
parseInt,
RegExp,
Set,
Set.prototype.entries,
Set.prototype.has,
Set.prototype.keys,
Set.prototype.values,
String,
String.fromCharCode,
String.fromCodePoint,
String.raw,
String.prototype.at,
String.prototype.charAt,
String.prototype.charCodeAt,
String.prototype.codePointAt,
String.prototype.concat,
String.prototype.endsWith,
String.prototype.includes,
String.prototype.indexOf,
String.prototype.lastIndexOf,
String.prototype.normalize,
String.prototype.padEnd,
String.prototype.padStart,
String.prototype.slice,
String.prototype.startsWith,
String.prototype.substr,
String.prototype.substring,
String.prototype.toLowerCase,
String.prototype.toString,
String.prototype.toUpperCase,
String.prototype.trim,
String.prototype.trimEnd,
String.prototype.trimLeft,
String.prototype.trimRight,
String.prototype.trimStart,
Symbol.for,
Symbol.keyFor,
unescape
].filter((f) => typeof f === "function")
);
var callPassThrough = /* @__PURE__ */ new Set([
Object.freeze,
Object.preventExtensions,
Object.seal
]);
var getterAllowed = [
[Map, /* @__PURE__ */ new Set(["size"])],
[
RegExp,
/* @__PURE__ */ new Set([
"dotAll",
"flags",
"global",
"hasIndices",
"ignoreCase",
"multiline",
"source",
"sticky",
"unicode"
])
],
[Set, /* @__PURE__ */ new Set(["size"])]
];
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;
}
function isGetter(object, name) {
const d = getPropertyDescriptor(object, name);
return d != null && d.get != 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(...argument.value);
} else {
const element = getStaticValueR(elementNode, initialScope);
if (element == null) {
return null;
}
valueList.push(element.value);
}
}
return valueList;
}
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) {
return true;
}
return false;
}
var operations = Object.freeze({
ArrayExpression(node2, initialScope) {
const elements = getElementValues(node2.elements, initialScope);
return elements != null ? { value: elements } : null;
},
AssignmentExpression(node2, initialScope) {
if (node2.operator === "=") {
return getStaticValueR(node2.right, initialScope);
}
return null;
},
//eslint-disable-next-line complexity
BinaryExpression(node2, initialScope) {
if (node2.operator === "in" || node2.operator === "instanceof") {
return null;
}
const left = getStaticValueR(node2.left, initialScope);
const right = getStaticValueR(node2.right, initialScope);
if (left != null && right != null) {
switch (node2.operator) {
case "==":
return { value: left.value == right.value };
case "!=":
return { value: left.value != right.value };
case "===":
return { value: left.value === right.value };
case "!==":
return { value: left.value !== right.value };
case "<":
return { value: left.value < right.value };
case "<=":
return { value: left.value <= right.value };
case ">":
return { value: left.value > right.value };
case ">=":
return { value: left.value >= right.value };
case "<<":
return { value: left.value << right.value };
case ">>":
return { value: left.value >> right.value };