eslint-plugin-baseline-js 0.7.4 → 0.7.5

package/README.md

@@ -115,6 +115,11 @@ export default [
 
 
 ### Demo
+
+For type-level checks too, pair it with [`typescript-baseline-lib`](https://github.com/3ru/TypeScript-Baseline-lib-generator), which gives TypeScript a built-in lib selected by Baseline data.
+Try the [demo](https://github.com/3ru/baseline-checks-demo) to check JavaScript APIs with TypeScript and ESLint in your editor and CI.
+Its [example PR](https://github.com/3ru/baseline-checks-demo/pull/1) changes one line to use `Set.prototype.difference()` and intentionally fails both checks.
+
 <img width="963" height="192" alt="getYear is deprecated" src="https://github.com/user-attachments/assets/e04e4a5c-c104-4945-96d6-889a47b7bcde" />
 
 

package/dist/index.mjs

@@ -389,18 +389,33 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "alert"
 	},
+	{
+		"featureId": "alerts",
+		"kind": "callGlobal",
+		"name": "alert"
+	},
 	{
 		"featureId": "alerts",
 		"kind": "member",
 		"base": "window",
 		"prop": "confirm"
 	},
+	{
+		"featureId": "alerts",
+		"kind": "callGlobal",
+		"name": "confirm"
+	},
 	{
 		"featureId": "alerts",
 		"kind": "member",
 		"base": "window",
 		"prop": "prompt"
 	},
+	{
+		"featureId": "alerts",
+		"kind": "callGlobal",
+		"name": "prompt"
+	},
 	{
 		"featureId": "ambient-light",
 		"kind": "callGlobal",
@@ -1785,9 +1800,8 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "audio",
-		"kind": "instanceMember",
-		"iface": "HTMLAudioElement",
-		"prop": "Audio"
+		"kind": "newIdent",
+		"name": "Audio"
 	},
 	{
 		"featureId": "audio-session",
@@ -4035,7 +4049,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "compute-pressure",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "PressureObserver",
 		"prop": "knownSources"
 	},
@@ -7233,6 +7247,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "getDigitalGoodsService"
 	},
+	{
+		"featureId": "digital-goods",
+		"kind": "callGlobal",
+		"name": "getDigitalGoodsService"
+	},
 	{
 		"featureId": "dirname",
 		"kind": "instanceMember",
@@ -11671,6 +11690,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "fetchLater"
 	},
+	{
+		"featureId": "fetchlater",
+		"kind": "callGlobal",
+		"name": "fetchLater"
+	},
 	{
 		"featureId": "fieldset",
 		"kind": "callGlobal",
@@ -12001,18 +12025,33 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "showDirectoryPicker"
 	},
+	{
+		"featureId": "file-system-access",
+		"kind": "callGlobal",
+		"name": "showDirectoryPicker"
+	},
 	{
 		"featureId": "file-system-access",
 		"kind": "member",
 		"base": "window",
 		"prop": "showOpenFilePicker"
 	},
+	{
+		"featureId": "file-system-access",
+		"kind": "callGlobal",
+		"name": "showOpenFilePicker"
+	},
 	{
 		"featureId": "file-system-access",
 		"kind": "member",
 		"base": "window",
 		"prop": "showSaveFilePicker"
 	},
+	{
+		"featureId": "file-system-access",
+		"kind": "callGlobal",
+		"name": "showSaveFilePicker"
+	},
 	{
 		"featureId": "focus-events",
 		"kind": "instanceMember",
@@ -12715,6 +12754,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "requestResize"
 	},
+	{
+		"featureId": "frame-sizing",
+		"kind": "callGlobal",
+		"name": "requestResize"
+	},
 	{
 		"featureId": "fullscreen",
 		"kind": "instanceMember",
@@ -13265,6 +13309,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "getComputedStyle"
 	},
+	{
+		"featureId": "get-computed-style",
+		"kind": "callGlobal",
+		"name": "getComputedStyle"
+	},
 	{
 		"featureId": "getallrecords",
 		"kind": "instanceMember",
@@ -13423,7 +13472,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "highlight",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "CSS",
 		"prop": "highlights"
 	},
@@ -14469,9 +14518,8 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "img",
-		"kind": "instanceMember",
-		"iface": "HTMLImageElement",
-		"prop": "Image"
+		"kind": "newIdent",
+		"name": "Image"
 	},
 	{
 		"featureId": "img",
@@ -16607,6 +16655,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "queryLocalFonts"
 	},
+	{
+		"featureId": "local-fonts",
+		"kind": "callGlobal",
+		"name": "queryLocalFonts"
+	},
 	{
 		"featureId": "local-network-access",
 		"kind": "instanceMember",
@@ -17107,6 +17160,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "matchMedia"
 	},
+	{
+		"featureId": "matchmedia",
+		"kind": "callGlobal",
+		"name": "matchMedia"
+	},
 	{
 		"featureId": "mathml",
 		"kind": "callGlobal",
@@ -17682,7 +17740,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "media-source",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "MediaSource",
 		"prop": "canConstructInDedicatedWorker"
 	},
@@ -19389,13 +19447,13 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "notifications",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "Notification",
 		"prop": "maxActions"
 	},
 	{
 		"featureId": "notifications",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "Notification",
 		"prop": "permission"
 	},
@@ -21171,7 +21229,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "paint",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "CSS",
 		"prop": "paintWorklet"
 	},
@@ -21992,7 +22050,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "performance",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "PerformanceObserver",
 		"prop": "supportedEntryTypes"
 	},
@@ -22787,6 +22845,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "postMessage"
 	},
+	{
+		"featureId": "postmessage",
+		"kind": "callGlobal",
+		"name": "postMessage"
+	},
 	{
 		"featureId": "postmessage",
 		"kind": "instanceMember",
@@ -23045,6 +23108,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "print"
 	},
+	{
+		"featureId": "print",
+		"kind": "callGlobal",
+		"name": "print"
+	},
 	{
 		"featureId": "print-events",
 		"kind": "member",
@@ -23250,7 +23318,7 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "push",
-		"kind": "callStatic",
+		"kind": "staticMember",
 		"base": "PushManager",
 		"prop": "supportedContentEncodings"
 	},
@@ -23816,12 +23884,22 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "cancelAnimationFrame"
 	},
+	{
+		"featureId": "request-animation-frame",
+		"kind": "callGlobal",
+		"name": "cancelAnimationFrame"
+	},
 	{
 		"featureId": "request-animation-frame",
 		"kind": "member",
 		"base": "window",
 		"prop": "requestAnimationFrame"
 	},
+	{
+		"featureId": "request-animation-frame",
+		"kind": "callGlobal",
+		"name": "requestAnimationFrame"
+	},
 	{
 		"featureId": "request-animation-frame-workers",
 		"kind": "instanceMember",
@@ -23875,12 +23953,22 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "cancelIdleCallback"
 	},
+	{
+		"featureId": "requestidlecallback",
+		"kind": "callGlobal",
+		"name": "cancelIdleCallback"
+	},
 	{
 		"featureId": "requestidlecallback",
 		"kind": "member",
 		"base": "window",
 		"prop": "requestIdleCallback"
 	},
+	{
+		"featureId": "requestidlecallback",
+		"kind": "callGlobal",
+		"name": "requestIdleCallback"
+	},
 	{
 		"featureId": "resize-observer",
 		"kind": "callGlobal",
@@ -24676,18 +24764,33 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "scroll"
 	},
+	{
+		"featureId": "scroll-elements",
+		"kind": "callGlobal",
+		"name": "scroll"
+	},
 	{
 		"featureId": "scroll-elements",
 		"kind": "member",
 		"base": "window",
 		"prop": "scrollBy"
 	},
+	{
+		"featureId": "scroll-elements",
+		"kind": "callGlobal",
+		"name": "scrollBy"
+	},
 	{
 		"featureId": "scroll-elements",
 		"kind": "member",
 		"base": "window",
 		"prop": "scrollTo"
 	},
+	{
+		"featureId": "scroll-elements",
+		"kind": "callGlobal",
+		"name": "scrollTo"
+	},
 	{
 		"featureId": "scroll-elements",
 		"kind": "member",
@@ -24817,9 +24920,8 @@ const descriptors$1 = [
 	},
 	{
 		"featureId": "select",
-		"kind": "instanceMember",
-		"iface": "HTMLOptionElement",
-		"prop": "Option"
+		"kind": "newIdent",
+		"name": "Option"
 	},
 	{
 		"featureId": "select",
@@ -25461,6 +25563,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "getSelection"
 	},
+	{
+		"featureId": "selection-api",
+		"kind": "callGlobal",
+		"name": "getSelection"
+	},
 	{
 		"featureId": "serial",
 		"kind": "member",
@@ -26582,6 +26689,15 @@ const descriptors$1 = [
 		"iface": "SharedWorkerGlobalScope",
 		"prop": "name"
 	},
+	{
+		"featureId": "shared-workers-extended-lifetime",
+		"kind": "newWithOptions",
+		"name": "SharedWorker",
+		"objectArg": {
+			"index": 1,
+			"hasKeys": ["extendedLifetime"]
+		}
+	},
 	{
 		"featureId": "show-picker-input",
 		"kind": "instanceMember",
@@ -46460,6 +46576,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "close"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "close"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46478,6 +46599,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "focus"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "focus"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46526,12 +46652,22 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "moveBy"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "moveBy"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
 		"base": "window",
 		"prop": "moveTo"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "moveTo"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46544,6 +46680,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "open"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "open"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46574,12 +46715,22 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "resizeBy"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "resizeBy"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
 		"base": "window",
 		"prop": "resizeTo"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "resizeTo"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46628,6 +46779,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "stop"
 	},
+	{
+		"featureId": "window",
+		"kind": "callGlobal",
+		"name": "stop"
+	},
 	{
 		"featureId": "window",
 		"kind": "member",
@@ -46797,6 +46953,11 @@ const descriptors$1 = [
 		"base": "window",
 		"prop": "getScreenDetails"
 	},
+	{
+		"featureId": "window-management",
+		"kind": "callGlobal",
+		"name": "getScreenDetails"
+	},
 	{
 		"featureId": "writingsuggestions",
 		"kind": "instanceMember",
@@ -64093,360 +64254,294 @@ function isBeyondBaseline(featureId, baseline) {
 	return false;
 }
 //#endregion
-//#region src/utils/listeners.ts
-/**
-* Merge one or more source listener maps into an existing map.
-* This preserves execution order (existing listeners run before new ones)
-* while keeping the original object reference intact.
-*/
-function mergeRuleListeners(target, ...sources) {
-	const dest = target;
-	for (const source of sources) {
-		if (!source) continue;
-		for (const [event, handler] of Object.entries(source)) {
-			const prev = target[event];
-			if (!prev) {
-				dest[event] = handler;
-				continue;
-			}
-			const next = handler;
-			dest[event] = function merged(...args) {
-				prev.apply(this, args);
-				next.apply(this, args);
-			};
-		}
-	}
-	return target;
-}
-//#endregion
 //#region src/util/ast.ts
-/**
-* Checks if an identifier refers to the global (not shadowed by a local declaration).
-* Unlike isUnboundIdentifier, this treats global built-ins (like Atomics, structuredClone)
-* as allowed, while still respecting explicit global declarations that shadow them.
-*
-* @param context - The ESLint rule context
-* @param name - The identifier name to check
-* @param parentNode - The parent node (CallExpression or MemberExpression)
-*/
-function isGlobalNotShadowed(context, name, parentNode) {
-	function findVariable(scope, varName) {
-		const bySet = scope.set?.get?.(varName);
-		if (bySet) return {
-			found: true,
-			variable: bySet
-		};
-		if (Array.isArray(scope.variables)) {
-			const byVars = scope.variables.find((v) => v?.name === varName);
-			if (byVars) return {
-				found: true,
-				variable: byVars
-			};
-		}
-		if (scope.set?.has?.(varName)) return { found: true };
-		return { found: false };
-	}
-	const sourceCode = context.sourceCode;
-	if (!sourceCode?.getScope) return true;
-	let current = sourceCode.getScope(parentNode);
-	while (current) {
-		const s = current;
-		const { found, variable } = findVariable(s, name);
-		if (found) {
-			if (s.type !== "global") return false;
-			const defs = variable?.defs;
-			if (Array.isArray(defs) && defs.length > 0) return false;
-			return true;
-		}
-		current = s.upper || null;
+/** Built-in globals have no definitions; explicit declarations shadow them. */
+function isGlobalNotShadowed(context, name, reference) {
+	let scope = context.sourceCode.getScope(reference);
+	while (scope) {
+		const variable = scope.set.get(name);
+		if (variable) return scope.type === "global" && variable.defs.length === 0;
+		scope = scope.upper;
 	}
 	return true;
 }
-function isGlobalBase(_context, node, baseName) {
-	if (!node) return false;
-	const id = node;
-	if (id.type === "Identifier" && id.name === baseName) return true;
-	const me = node;
-	if (me.type === "MemberExpression" && me.computed === false) {
-		const obj = me.object;
-		const prop = me.property;
-		if (!(obj?.type === "Identifier" && (obj.name === "window" || obj.name === "globalThis"))) return false;
-		return prop?.type === "Identifier" && prop.name === baseName;
+const GLOBAL_OBJECT_NAMES = /* @__PURE__ */ new Set([
+	"window",
+	"globalThis",
+	"self"
+]);
+function staticPropertyName(node, computed) {
+	if (!computed && node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+function stripChain(node) {
+	return node.type === "ChainExpression" ? node.expression : node;
+}
+function getStaticMemberName(node) {
+	const member = stripChain(node);
+	return member.type === "MemberExpression" ? staticPropertyName(member.property, member.computed) : null;
+}
+function globalObjectRoot(node) {
+	let current = stripChain(node);
+	while (current.type === "MemberExpression") {
+		const name = getStaticMemberName(current);
+		if (name === null || !GLOBAL_OBJECT_NAMES.has(name)) return null;
+		current = stripChain(current.object);
 	}
-	return false;
+	return current.type === "Identifier" && GLOBAL_OBJECT_NAMES.has(current.name) ? current.name : null;
 }
-function collectGlobalBaseRoots(node, baseName) {
-	const id = node;
-	if (id.type === "Identifier" && id.name === baseName) return [baseName];
-	const me = node;
-	if (me.type !== "MemberExpression" || me.computed) return [];
-	const obj = me.object;
-	const prop = me.property;
-	if (obj?.type !== "Identifier" || prop?.type !== "Identifier") return [];
-	if (prop.name !== baseName) return [];
-	if (obj.name === "window" || obj.name === "globalThis") return [obj.name];
-	return [];
+function globalBaseRoot(node, baseName) {
+	const base = stripChain(node);
+	if (base.type === "Identifier" && base.name === baseName) return baseName;
+	if (baseName === "window") {
+		const root = globalObjectRoot(base);
+		if (root !== null) return root;
+	}
+	if (base.type !== "MemberExpression" || getStaticMemberName(base) !== baseName) return null;
+	return globalObjectRoot(base.object);
 }
-function isGlobalBaseNotShadowed(context, node, baseName, parentNode) {
-	if (!isGlobalBase(context, node, baseName)) return false;
-	const roots = collectGlobalBaseRoots(node, baseName);
-	if (!roots.length) return false;
-	return roots.every((name) => isGlobalNotShadowed(context, name, parentNode));
+function isGlobalBaseNotShadowed(context, node, baseName, reference) {
+	const root = globalBaseRoot(node, baseName);
+	return root !== null && isGlobalNotShadowed(context, root, reference);
 }
-function isMemberWithProperty(node, propName) {
-	const me = node;
-	if (!me || me.type !== "MemberExpression" || me.computed) return false;
-	const prop = me.property;
-	return prop?.type === "Identifier" && prop.name === propName;
+function isMemberWithProperty(node, name) {
+	return getStaticMemberName(node) === name;
 }
-function stripChain(node) {
-	const n = node;
-	if (n && n.type === "ChainExpression") return n.expression;
-	return node;
+function getMemberPropertyNode(node) {
+	const member = stripChain(node);
+	return member.type === "MemberExpression" ? member.property : null;
 }
 function getCallStringArg(call, index) {
-	const a = (call.arguments || [])[index];
-	if (!a) return null;
-	if (a.type === "Literal" && typeof a.value === "string") return a.value;
-	return null;
+	const argument = call.arguments[index];
+	return argument?.type === "Literal" && typeof argument.value === "string" ? argument.value : null;
 }
 function getCallObjectArg(call, index) {
-	const a = (call.arguments || [])[index];
-	if (!a) return null;
-	if (a.type === "ObjectExpression") return a;
-	return null;
+	const argument = call.arguments[index];
+	return argument?.type === "ObjectExpression" ? argument : null;
 }
-function objectHasKey(obj, key) {
-	const o = obj;
-	if (!o || o.type !== "ObjectExpression") return false;
-	for (const p of o.properties || []) {
-		const prop = p;
-		if (prop.type !== "Property") continue;
-		if (prop.computed) continue;
-		const k = prop.key;
-		if (k?.type === "Identifier" && k.name === key) return true;
-		if (k?.type === "Literal" && k.value === key) return true;
-	}
-	return false;
+function objectHasKey(object, key) {
+	return object.properties.some((property) => property.type === "Property" && staticPropertyName(property.key, property.computed) === key);
 }
-function objectHasKeyWithValues(obj, cfg) {
-	const o = obj;
-	if (!o || o.type !== "ObjectExpression") return false;
-	for (const p of o.properties || []) {
-		const prop = p;
-		if (prop.type !== "Property") continue;
-		if (prop.computed) continue;
-		const k = prop.key;
-		if (!(k?.type === "Identifier" && k.name === cfg.key || k?.type === "Literal" && k.value === cfg.key)) continue;
-		if (!cfg.values || cfg.values.length === 0) return true;
-		const v = prop.value;
-		if (v?.type === "Literal" && cfg.values.includes(String(v.value))) return true;
+function objectHasKeyWithValues(object, config) {
+	for (let index = object.properties.length - 1; index >= 0; index--) {
+		const property = object.properties[index];
+		if (property.type !== "Property") return false;
+		const key = staticPropertyName(property.key, property.computed);
+		if (key === null && property.computed && property.key.type !== "Literal") return false;
+		if (key !== config.key) continue;
+		if (!config.values?.length) return true;
+		return property.value.type === "Literal" && config.values.includes(String(property.value.value));
 	}
 	return false;
 }
-function isCallOfMember(node, prop) {
-	const n = stripChain(node);
-	if (!n || n.type !== "CallExpression") return false;
-	const callee = n.callee;
-	return isMemberWithProperty(callee, prop);
+function isCallOfMember(node, property) {
+	const call = stripChain(node);
+	return call.type === "CallExpression" && getStaticMemberName(call.callee) === property;
+}
+//#endregion
+//#region src/util/typed-parser-services.ts
+function getTypedParserServices(context) {
+	const services = context.sourceCode.parserServices;
+	if (!services?.program || !services.esTreeNodeToTSNodeMap) return void 0;
+	return {
+		program: services.program,
+		esTreeNodeToTSNodeMap: services.esTreeNodeToTSNodeMap
+	};
 }
 //#endregion
 //#region src/rules/feature-usage/detectors/safe-args.ts
-function matchesObjectArg(obj, d) {
-	if (!obj) return false;
-	if (d.hasKeys?.length) {
-		for (const k of d.hasKeys) if (!objectHasKey(obj, k)) return false;
-	}
-	if (d.keyValues?.length) {
-		for (const kv of d.keyValues) if (!objectHasKeyWithValues(obj, kv)) return false;
-	}
+function matchesObjectArg(object, descriptor) {
+	if (!object) return false;
+	for (const key of descriptor.hasKeys ?? []) if (!objectHasKey(object, key)) return false;
+	for (const keyValue of descriptor.keyValues ?? []) if (!objectHasKeyWithValues(object, keyValue)) return false;
 	return true;
 }
-function addCallMemberWithArgsDetector(_context, d, report) {
-	const handler = (node) => {
-		const callee = node.callee;
-		if (!callee || callee.type !== "MemberExpression") return;
-		const propNode = callee.property;
-		if ((propNode?.type === "Identifier" ? propNode.name : propNode?.type === "Literal" ? String(propNode.value) : void 0) !== d.prop) return;
-		if (d.viaCall?.prop) {
-			const recv = callee.object;
-			if (!isCallOfMember(recv, d.viaCall.prop)) return;
-		}
-		if (d.stringArg) {
-			const s = getCallStringArg(node, d.stringArg.index);
-			if (!s || !d.stringArg.values.includes(s)) return;
-		}
-		if (d.objectArg) {
-			const obj = getCallObjectArg(node, d.objectArg.index);
-			if (!obj) return;
-			if (!matchesObjectArg(obj, d.objectArg)) return;
-		}
-		report(node, d.featureId);
-	};
-	return { CallExpression: handler };
+function addCallMemberWithArgsDetector(_context, descriptor, report) {
+	return { CallExpression(node) {
+		const callee = stripChain(node.callee);
+		if (callee.type !== "MemberExpression" || getStaticMemberName(callee) !== descriptor.prop) return;
+		if (descriptor.viaCall?.prop && !isCallOfMember(callee.object, descriptor.viaCall.prop)) return;
+		if (descriptor.stringArg) {
+			const argument = getCallStringArg(node, descriptor.stringArg.index);
+			if (!argument || !descriptor.stringArg.values.includes(argument)) return;
+		}
+		if (descriptor.objectArg && !matchesObjectArg(getCallObjectArg(node, descriptor.objectArg.index), descriptor.objectArg)) return;
+		report(node, descriptor.featureId);
+	} };
 }
-function addNewWithOptionsDetector(context, d, report) {
-	const handler = (node) => {
-		const callee = node.callee;
-		if (callee?.type !== "Identifier" || callee.name !== d.name) return;
-		if (!isGlobalBaseNotShadowed(context, callee, d.name, node)) return;
-		const obj = getCallObjectArg(node, d.objectArg.index);
-		if (!obj) return;
-		if (d.objectArg.hasKeys?.length) {
-			for (const k of d.objectArg.hasKeys) if (!objectHasKey(obj, k)) return;
-		}
-		if (d.objectArg.keyValues?.length) {
-			for (const kv of d.objectArg.keyValues) if (!objectHasKeyWithValues(obj, kv)) return;
-		}
-		report(callee, d.featureId);
-	};
-	return { NewExpression: handler };
+function addNewWithOptionsDetector(context, descriptor, report) {
+	return { NewExpression(node) {
+		const callee = stripChain(node.callee);
+		if (!isGlobalBaseNotShadowed(context, callee, descriptor.name, node)) return;
+		if (!matchesObjectArg(getCallObjectArg(node, descriptor.objectArg.index), descriptor.objectArg)) return;
+		report(getMemberPropertyNode(callee) ?? callee, descriptor.featureId);
+	} };
 }
 //#endregion
 //#region src/rules/feature-usage/detectors/safe-core.ts
-function addNewIdentDetector(context, d, report) {
-	const name = d.name;
-	const featureId = d.featureId;
-	const handler = (node) => {
-		const callee = node.callee;
-		if (callee?.type === "Identifier" && callee.name === name && isGlobalBaseNotShadowed(context, callee, name, node)) report(callee, featureId);
-	};
-	return { NewExpression: handler };
+function addNewIdentDetector(context, descriptor, report) {
+	const { name, featureId } = descriptor;
+	return { NewExpression(node) {
+		const callee = stripChain(node.callee);
+		if (isGlobalBaseNotShadowed(context, callee, name, node)) report(getMemberPropertyNode(callee) ?? callee, featureId);
+	} };
 }
-function addNewMemberDetector(context, d, report) {
-	const { base, prop, featureId } = d;
-	const handler = (node) => {
-		const callee = node.callee;
-		if (isMemberWithProperty(callee, prop) && isGlobalBaseNotShadowed(context, callee.object, base, node)) report(callee.property, featureId);
-	};
-	return { NewExpression: handler };
+function addNewMemberDetector(context, descriptor, report) {
+	const { base, prop, featureId } = descriptor;
+	return { NewExpression(node) {
+		const callee = stripChain(node.callee);
+		if (callee.type === "MemberExpression" && getStaticMemberName(callee) === prop && isGlobalBaseNotShadowed(context, callee.object, base, node)) report(callee.property, featureId);
+	} };
 }
-function addCallStaticDetector(context, d, report) {
-	const { base, prop, featureId } = d;
-	const handler = (node) => {
-		const callee = node.callee;
-		if (isMemberWithProperty(callee, prop) && isGlobalBaseNotShadowed(context, callee.object, base, node)) report(callee.property, featureId);
-	};
-	return { CallExpression: handler };
+function addCallStaticDetector(context, descriptor, report) {
+	const { base, prop, featureId } = descriptor;
+	return { CallExpression(node) {
+		const callee = stripChain(node.callee);
+		if (callee.type === "MemberExpression" && getStaticMemberName(callee) === prop && isGlobalBaseNotShadowed(context, callee.object, base, node)) report(callee.property, featureId);
+	} };
 }
-function addCallGlobalDetector(context, d, report) {
-	const { name, featureId } = d;
-	const handler = (node) => {
-		const callee = node.callee;
-		if (callee?.type === "Identifier" && callee.name === name && isGlobalBaseNotShadowed(context, callee, name, node)) report(callee, featureId);
-	};
-	return { CallExpression: handler };
+function addCallGlobalDetector(context, descriptor, report) {
+	const { name, featureId } = descriptor;
+	return { CallExpression(node) {
+		const callee = stripChain(node.callee);
+		if (isGlobalBaseNotShadowed(context, callee, name, node)) report(getMemberPropertyNode(callee) ?? callee, featureId);
+	} };
 }
-function addMemberDetector(context, d, report) {
-	const { base, prop, featureId } = d;
-	const handler = (node) => {
-		if (isMemberWithProperty(node, prop) && isGlobalBaseNotShadowed(context, node.object, base, node)) report(node.property, featureId);
-	};
-	return { MemberExpression: handler };
+function addMemberDetector(context, descriptor, report) {
+	const { base, prop, featureId } = descriptor;
+	return { MemberExpression(node) {
+		if (getStaticMemberName(node) === prop && isGlobalBaseNotShadowed(context, node.object, base, node)) report(node.property, featureId);
+	} };
 }
-function addStaticMemberDetector(context, d, report) {
-	return addMemberDetector(context, d, report);
+function addStaticMemberDetector(context, descriptor, report) {
+	return addMemberDetector(context, descriptor, report);
 }
 //#endregion
 //#region src/rules/feature-usage/detectors/typed-instance-member.ts
 function addTypedInstanceMemberDetector(context, d, report) {
 	const { iface, prop, featureId } = d;
-	const ctxLike = context;
-	const services = ctxLike.parserServices || ctxLike.sourceCode?.parserServices || {};
-	const checker = services.program?.getTypeChecker?.();
-	if (!checker || !services.esTreeNodeToTSNodeMap) return {};
-	const checkerOk = checker;
-	const tsMap = services.esTreeNodeToTSNodeMap;
-	const tsMapGet = tsMap.get;
-	if (typeof tsMapGet !== "function") return {};
-	const getTsNode = tsMapGet.bind(tsMap);
-	const typeAtLocation = checkerOk.getTypeAtLocation;
-	if (typeof typeAtLocation !== "function") return {};
-	const getTypeAtLocation = typeAtLocation.bind(checkerOk);
-	const propertyOfType = checkerOk.getPropertyOfType;
-	if (typeof propertyOfType !== "function") return {};
-	const getPropertyOfType = propertyOfType.bind(checkerOk);
-	function getBaseTypes(t) {
-		const type = t;
-		return type.getBaseTypes?.() || type.baseTypes || type.target?.getBaseTypes?.() || type.target?.baseTypes || [];
+	const services = getTypedParserServices(context);
+	if (!services) return {};
+	const checker = services.program.getTypeChecker();
+	function getBaseTypes(type) {
+		const bases = type.getBaseTypes();
+		if (bases) return bases;
+		if (isTypeReference(type)) return type.target.getBaseTypes() ?? [];
+		return [];
 	}
-	function typeMatches(t) {
-		if (!t) return false;
-		const withTypes = t;
-		if (Array.isArray(withTypes.types)) return withTypes.types.some((tt) => typeMatches(tt));
-		const withSym = t;
-		const name = (withSym.symbol || withSym.aliasSymbol || withSym.getSymbol?.())?.name;
+	function typeMatches(type, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(type)) return false;
+		seen.add(type);
+		if (type.isUnionOrIntersection()) return type.types.some((part) => typeMatches(part, seen));
+		const name = (type.getSymbol() ?? type.aliasSymbol)?.getName();
 		if (name === iface || name?.endsWith(`.${iface}`)) return true;
-		const baseTypes = getBaseTypes(checkerOk.getApparentType?.(t) || t);
-		if (baseTypes?.length) {
-			if (baseTypes.some((bt) => bt.symbol?.name === iface)) return true;
-			for (const bt of baseTypes) {
-				const bt2 = getBaseTypes(bt);
-				if (Array.isArray(bt2) && bt2.some((b2) => b2.symbol?.name === iface)) return true;
-			}
-		}
-		return false;
+		const apparent = checker.getApparentType(type);
+		if (apparent !== type && typeMatches(apparent, seen)) return true;
+		const constraint = checker.getBaseConstraintOfType(type);
+		if (constraint && constraint !== type && typeMatches(constraint, seen)) return true;
+		return getBaseTypes(type).some((base) => typeMatches(base, seen));
 	}
 	const handler = (node) => {
 		if (!isMemberWithProperty(node, prop)) return;
-		const obj = node.object;
-		const tsNode = getTsNode(obj);
+		const tsNode = services.esTreeNodeToTSNodeMap.get(node.object);
 		if (!tsNode) return;
-		const type = getTypeAtLocation(tsNode);
-		if (!type) return;
-		if (!!!getPropertyOfType(type, prop)) return;
+		const type = checker.getNonNullableType(checker.getTypeAtLocation(tsNode));
+		if (!checker.getPropertyOfType(type, prop)) return;
 		if (typeMatches(type)) report(node.property, featureId);
 	};
 	return { MemberExpression: handler };
 }
+function isTypeReference(type) {
+	return "target" in type;
+}
 //#endregion
 //#region src/rules/feature-usage/builder.ts
 function buildListeners(context, opt) {
-	const listeners = {};
-	const ctxLike = context;
-	const services = ctxLike.parserServices || ctxLike.sourceCode?.parserServices || {};
-	const checker = services.program?.getTypeChecker?.();
-	const useTyped = !!opt.typed && !!checker && !!services.esTreeNodeToTSNodeMap;
+	const calls = /* @__PURE__ */ new Map();
+	const constructions = /* @__PURE__ */ new Map();
+	const members = /* @__PURE__ */ new Map();
+	function addHandler(handlers, name, handler) {
+		if (!handler) return;
+		const bucket = handlers.get(name);
+		if (bucket) bucket.push(handler);
+		else handlers.set(name, [handler]);
+	}
+	function calleeName(callee) {
+		const node = stripChain(callee);
+		return node.type === "Identifier" ? node.name : getStaticMemberName(node);
+	}
+	const reportedFeatures = /* @__PURE__ */ new WeakMap();
+	const useTyped = !!opt.typed && !!getTypedParserServices(context);
 	for (const d of opt.descriptors) {
 		function report(node) {
+			let features = reportedFeatures.get(node);
+			if (features?.has(d.featureId)) return;
+			if (!features) {
+				features = /* @__PURE__ */ new Set();
+				reportedFeatures.set(node, features);
+			}
+			features.add(d.featureId);
 			opt.report(node, d);
 		}
 		switch (d.kind) {
 			case "newIdent":
-				mergeRuleListeners(listeners, addNewIdentDetector(context, d, report));
+				addHandler(constructions, d.name, addNewIdentDetector(context, d, report).NewExpression);
 				break;
 			case "newMember":
-				mergeRuleListeners(listeners, addNewMemberDetector(context, d, report));
+				addHandler(constructions, d.prop, addNewMemberDetector(context, d, report).NewExpression);
 				break;
 			case "callStatic":
-				mergeRuleListeners(listeners, addCallStaticDetector(context, d, report));
+				addHandler(calls, d.prop, addCallStaticDetector(context, d, report).CallExpression);
 				break;
 			case "callGlobal":
-				mergeRuleListeners(listeners, addCallGlobalDetector(context, d, report));
+				addHandler(calls, d.name, addCallGlobalDetector(context, d, report).CallExpression);
 				break;
 			case "member":
-				mergeRuleListeners(listeners, addMemberDetector(context, d, report));
+				addHandler(members, d.prop, addMemberDetector(context, d, report).MemberExpression);
 				break;
 			case "staticMember":
-				mergeRuleListeners(listeners, addStaticMemberDetector(context, d, report));
+				addHandler(members, d.prop, addStaticMemberDetector(context, d, report).MemberExpression);
 				break;
 			case "instanceMember":
-				if (useTyped) mergeRuleListeners(listeners, addTypedInstanceMemberDetector(context, d, report));
+				if (useTyped) addHandler(members, d.prop, addTypedInstanceMemberDetector(context, d, report).MemberExpression);
 				break;
 			case "callMemberWithArgs":
-				mergeRuleListeners(listeners, addCallMemberWithArgsDetector(context, d, report));
+				addHandler(calls, d.prop, addCallMemberWithArgsDetector(context, d, report).CallExpression);
 				break;
-			case "newWithOptions": mergeRuleListeners(listeners, addNewWithOptionsDetector(context, d, report));
+			case "newWithOptions":
+				addHandler(constructions, d.name, addNewWithOptionsDetector(context, d, report).NewExpression);
+				break;
+			default: throw new Error(`Unsupported descriptor: ${JSON.stringify(d)}`);
 		}
 	}
-	return listeners;
+	return {
+		CallExpression(node) {
+			const name = calleeName(node.callee);
+			if (name === null) return;
+			for (const handler of calls.get(name) ?? []) handler(node);
+		},
+		NewExpression(node) {
+			const name = calleeName(node.callee);
+			if (name === null) return;
+			for (const handler of constructions.get(name) ?? []) handler(node);
+		},
+		MemberExpression(node) {
+			const name = getStaticMemberName(node);
+			if (name === null) return;
+			for (const handler of members.get(name) ?? []) handler(node);
+		}
+	};
 }
 //#endregion
 //#region src/rules/no-atomics-pause/index.ts
 const rule$5 = {
 	meta: {
 		type: "problem",
-		docs: { description: "disallow Atomics.pause() usage" },
+		docs: {
+			description: "disallow Atomics.pause() usage",
+			url: "https://baselinejs.vercel.app/docs/config#standalone-rules"
+		},
 		messages: { forbidden: "Atomics.pause is not allowed." },
 		schema: []
 	},
@@ -64460,13 +64555,12 @@ const rule$5 = {
 		return {
 			CallExpression(node) {
 				const callee = node.callee;
-				if (callee && callee.type === "MemberExpression" && callee.computed === false && isGlobalBaseNotShadowed(context, callee.object, "Atomics", node) && callee.property?.type === "Identifier" && callee.property?.name === "pause") report(callee.property);
+				if (callee.type === "MemberExpression" && callee.computed === false && isGlobalBaseNotShadowed(context, callee.object, "Atomics", node) && callee.property.type === "Identifier" && callee.property.name === "pause") report(callee.property);
 			},
 			MemberExpression(node) {
-				const m = node;
-				const parent = m.parent;
-				if (parent?.type === "CallExpression" && parent.callee === node) return;
-				if (m.computed === false && isGlobalBaseNotShadowed(context, m.object, "Atomics", node) && m.property?.type === "Identifier" && m.property?.name === "pause") report(m.property);
+				const parent = node.parent;
+				if (parent.type === "CallExpression" && parent.callee === node) return;
+				if (node.computed === false && isGlobalBaseNotShadowed(context, node.object, "Atomics", node) && node.property.type === "Identifier" && node.property.name === "pause") report(node.property);
 			}
 		};
 	}
@@ -64476,7 +64570,10 @@ const rule$5 = {
 const rule$4 = {
 	meta: {
 		type: "problem",
-		docs: { description: "disallow BigInt64Array/BigUint64Array usage" },
+		docs: {
+			description: "disallow BigInt64Array/BigUint64Array usage",
+			url: "https://baselinejs.vercel.app/docs/config#standalone-rules"
+		},
 		messages: { forbidden: "BigInt64Array/BigUint64Array are not allowed." },
 		schema: []
 	},
@@ -64494,16 +64591,13 @@ const rule$4 = {
 		}
 		return {
 			NewExpression(node) {
-				const n = node;
-				if (resolveBigIntArrayBase(n.callee, node)) report(n.callee);
+				if (resolveBigIntArrayBase(node.callee, node)) report(node.callee);
 			},
 			CallExpression(node) {
-				const n = node;
-				if (resolveBigIntArrayBase(n.callee, node)) report(n.callee);
+				if (resolveBigIntArrayBase(node.callee, node)) report(node.callee);
 			},
 			MemberExpression(node) {
-				const m = node;
-				if (resolveBigIntArrayBase(m.object, node)) report(m.object);
+				if (resolveBigIntArrayBase(node.object, node)) report(node.object);
 			}
 		};
 	}
@@ -64513,7 +64607,10 @@ const rule$4 = {
 const rule$3 = {
 	meta: {
 		type: "problem",
-		docs: { description: "disallow Function#caller and Function#arguments" },
+		docs: {
+			description: "disallow Function#caller and Function#arguments",
+			url: "https://baselinejs.vercel.app/docs/config#standalone-rules"
+		},
 		messages: { forbidden: "Function.caller/Function.arguments are forbidden." },
 		schema: []
 	},
@@ -64540,7 +64637,10 @@ const rule$3 = {
 const rule$2 = {
 	meta: {
 		type: "problem",
-		docs: { description: "disallow Math.sumPrecise() usage" },
+		docs: {
+			description: "disallow Math.sumPrecise() usage",
+			url: "https://baselinejs.vercel.app/docs/config#standalone-rules"
+		},
 		messages: { forbidden: "Math.sumPrecise is not allowed." },
 		schema: []
 	},
@@ -64554,13 +64654,12 @@ const rule$2 = {
 		return {
 			CallExpression(node) {
 				const callee = node.callee;
-				if (callee && callee.type === "MemberExpression" && callee.computed === false && isGlobalBaseNotShadowed(context, callee.object, "Math", node) && callee.property?.type === "Identifier" && callee.property?.name === "sumPrecise") report(callee.property);
+				if (callee.type === "MemberExpression" && callee.computed === false && isGlobalBaseNotShadowed(context, callee.object, "Math", node) && callee.property.type === "Identifier" && callee.property.name === "sumPrecise") report(callee.property);
 			},
 			MemberExpression(node) {
-				const m = node;
-				const parent = m.parent;
-				if (parent?.type === "CallExpression" && parent.callee === node) return;
-				if (m.computed === false && isGlobalBaseNotShadowed(context, m.object, "Math", node) && m.property?.type === "Identifier" && m.property?.name === "sumPrecise") report(m.property);
+				const parent = node.parent;
+				if (parent.type === "CallExpression" && parent.callee === node) return;
+				if (node.computed === false && isGlobalBaseNotShadowed(context, node.object, "Math", node) && node.property.type === "Identifier" && node.property.name === "sumPrecise") report(node.property);
 			}
 		};
 	}
@@ -64570,7 +64669,10 @@ const rule$2 = {
 const rule$1 = {
 	meta: {
 		type: "problem",
-		docs: { description: "disallow Temporal API usage" },
+		docs: {
+			description: "disallow Temporal API usage",
+			url: "https://baselinejs.vercel.app/docs/config#standalone-rules"
+		},
 		messages: { forbidden: "Temporal API usage is not allowed." },
 		schema: []
 	},
@@ -64583,18 +64685,17 @@ const rule$1 = {
 		}
 		return {
 			MemberExpression(node) {
-				const m = node;
-				const parent = m.parent;
-				if (parent?.type === "NewExpression" && parent.callee === node) return;
-				if (m.computed === false && isGlobalBaseNotShadowed(context, m.object, "Temporal", node)) report(m.object);
+				const parent = node.parent;
+				if (parent.type === "NewExpression" && parent.callee === node) return;
+				if (node.computed === false && isGlobalBaseNotShadowed(context, node.object, "Temporal", node)) report(node.object);
 			},
 			NewExpression(node) {
-				const n = node;
-				if (n.callee?.type === "Identifier") {
-					if (isGlobalBaseNotShadowed(context, n.callee, "Temporal", node)) report(n.callee);
+				const callee = node.callee;
+				if (callee.type === "Identifier") {
+					if (isGlobalBaseNotShadowed(context, callee, "Temporal", node)) report(callee);
 					return;
 				}
-				if (n.callee?.type === "MemberExpression" && isGlobalBaseNotShadowed(context, n.callee.object, "Temporal", node)) report(n.callee.object);
+				if (callee.type === "MemberExpression" && isGlobalBaseNotShadowed(context, callee.object, "Temporal", node)) report(callee.object);
 			}
 		};
 	}
@@ -64687,6 +64788,32 @@ function listResolverPlugins() {
 	return Object.keys(registry).sort();
 }
 //#endregion
+//#region src/utils/listeners.ts
+/**
+* Merge one or more source listener maps into an existing map.
+* This preserves execution order (existing listeners run before new ones)
+* while keeping the original object reference intact.
+*/
+function mergeRuleListeners(target, ...sources) {
+	const dest = target;
+	for (const source of sources) {
+		if (!source) continue;
+		for (const [event, handler] of Object.entries(source)) {
+			const prev = target[event];
+			if (!prev) {
+				dest[event] = handler;
+				continue;
+			}
+			const next = handler;
+			dest[event] = function merged(...args) {
+				prev.apply(this, args);
+				next.apply(this, args);
+			};
+		}
+	}
+	return target;
+}
+//#endregion
 //#region src/orchestrator/messages.ts
 function baselineMessage(featureId, baseline, subject) {
 	const feature = getFeatureRecord(featureId);
@@ -64755,7 +64882,10 @@ registerSelfRules({
 const rule = {
 	meta: {
 		type: "problem",
-		docs: { description: "Enforce JS Baseline by delegating to underlying syntax rules (es-x)" },
+		docs: {
+			description: "Enforce JS Baseline by delegating to underlying syntax rules (es-x)",
+			url: "https://baselinejs.vercel.app/docs/config#rule-options"
+		},
 		schema: [{
 			type: "object",
 			properties: {
@@ -64922,31 +65052,24 @@ const rule = {
 			});
 			mergeRuleListeners(listeners, impl.create(delegateCtx));
 		}
-		let descriptors = getIncludedDescriptors({
-			webApis: includeWebApis,
-			jsBuiltins: includeJsBuiltins
-		});
-		if (matchIgnoreFeature) descriptors = descriptors.filter((d) => !matchIgnoreFeature(d.featureId));
-		descriptors = descriptors.filter((d) => isBeyondBaseline(d.featureId, baseline)).filter((d) => !mappedFeatureIds.has(d.featureId));
-		function resolveUseTypes(opt) {
-			if (!opt) return "off";
-			if (opt === true) return "off";
-			if (typeof opt === "object") {
-				const o = opt;
-				if (o.useTypes === "off" || o.useTypes === "auto" || o.useTypes === "require") return o.useTypes;
-				if (o.preset === "type-aware") return "require";
-				if (o.preset === "auto") return "auto";
-				return "off";
-			}
-			return "off";
-		}
-		const cx = ctx;
-		const ps = cx.parserServices || cx.sourceCode?.parserServices;
-		const typedAvailable = !!ps?.program && !!ps?.esTreeNodeToTSNodeMap;
+		function resolveUseTypes(option) {
+			if (option === false || option === true) return "off";
+			if (option.useTypes) return option.useTypes;
+			if (option.preset === "type-aware") return "require";
+			return option.preset === "auto" ? "auto" : "off";
+		}
+		const typedAvailable = getTypedParserServices(ctx) !== void 0;
 		const useTypesWeb = resolveUseTypes(includeWebApis);
 		const useTypesJs = resolveUseTypes(includeJsBuiltins);
-		const typedEnabled = (useTypesWeb === "require" || useTypesJs === "require" || useTypesWeb === "auto" || useTypesJs === "auto") && typedAvailable;
-		if (!typedEnabled) descriptors = descriptors.filter((d) => d.kind !== "instanceMember" && !d.typedOnly);
+		const typedWebEnabled = useTypesWeb !== "off" && typedAvailable;
+		const typedJsEnabled = useTypesJs !== "off" && typedAvailable;
+		const typedEnabled = typedWebEnabled || typedJsEnabled;
+		function getEnabledDescriptors(options, useTypes) {
+			return getIncludedDescriptors(options).filter((descriptor) => useTypes || descriptor.kind !== "instanceMember" && !descriptor.typedOnly);
+		}
+		let descriptors = [...getEnabledDescriptors({ webApis: includeWebApis }, typedWebEnabled), ...getEnabledDescriptors({ jsBuiltins: includeJsBuiltins }, typedJsEnabled)];
+		if (matchIgnoreFeature) descriptors = descriptors.filter((d) => !matchIgnoreFeature(d.featureId));
+		descriptors = descriptors.filter((d) => isBeyondBaseline(d.featureId, baseline)).filter((d) => !mappedFeatureIds.has(d.featureId));
 		if (descriptors.length > 0) mergeRuleListeners(listeners, buildListeners(ctx, {
 			descriptors,
 			typed: typedEnabled,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-baseline-js",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Enforce JavaScript Baseline (widely/newly/year) browser compatibility with a single ESLint rule. Prevent runtime errors by catching unsupported JavaScript features during development.",
   "license": "MIT",
   "type": "module",
@@ -45,6 +45,7 @@
     "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/git": "^11.0.1",
     "@types/eslint": "^9.6.1",
+    "@types/estree": "^1.0.9",
     "@types/node": "^26.6.3",
     "@typescript-eslint/parser": "^8.70.1",
     "eslint": "^10.11.0",
@@ -62,6 +63,11 @@
   "pnpm": {
     "overrides": {
       "vite": "7.3.6"
+    },
+    "auditConfig": {
+      "ignoreGhsas": [
+        "GHSA-vfj7-8cjw-p6xm"
+      ]
     }
   },
   "engines": {