corsa-oxlint 0.1.0

package/dist/rules/no_base_to_string.js

@@ -0,0 +1,66 @@
+import { calleePropertyName, isIdentifierNamed, isLiteralString, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { classifyTypeText, isStringLikeNode, splitTopLevelTypeText, typeTextsAtNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_base_to_string.ts
+const knownSafeObjectTypes = new Set([
+	"Date",
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"RegExp",
+	"SyntaxError",
+	"TypeError",
+	"URIError",
+	"URL",
+	"URLSearchParams"
+]);
+const noBaseToStringRule = createNativeRule("no-base-to-string", {
+	docs: { description: "Disallow stringifying values that fall back to Object.prototype.toString()." },
+	messages: { unexpected: "This value is stringified through its base Object#toString() representation." }
+}, (context) => ({
+	BinaryExpression(node) {
+		if (node.operator !== "+") return;
+		if (isLiteralString(node.left) || isStringLikeNode(context, node.left)) reportIfUnsafe(context, node.right);
+		if (isLiteralString(node.right) || isStringLikeNode(context, node.right)) reportIfUnsafe(context, node.left);
+	},
+	CallExpression(node) {
+		const [firstArgument] = node.arguments;
+		if (!firstArgument) return;
+		if (isIdentifierNamed(node.callee, "String")) {
+			reportIfUnsafe(context, firstArgument);
+			return;
+		}
+		if (calleePropertyName(node) === "toString") reportIfUnsafe(context, stripChainExpression(node.callee).object);
+	},
+	TemplateLiteral(node) {
+		for (const expression of node.expressions ?? []) reportIfUnsafe(context, expression);
+	}
+}));
+function reportIfUnsafe(context, node) {
+	if (!node || !isPossiblyBaseToString(context, node)) return;
+	context.report({
+		node,
+		messageId: "unexpected"
+	});
+}
+function isPossiblyBaseToString(context, node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "ArrayExpression" || current?.type === "ObjectExpression" || current?.type === "ArrowFunctionExpression" || current?.type === "FunctionExpression") return true;
+	const typeTexts = typeTextsAtNode(context, node);
+	if (typeTexts.length === 0) return false;
+	return typeTexts.some((text) => splitTopLevelTypeText(text, "|").some(isUnsafeStringifiedText));
+}
+function isUnsafeStringifiedText(text) {
+	const current = text.trim();
+	const kind = classifyTypeText(current);
+	if (kind === "string" || kind === "number" || kind === "bigint" || kind === "boolean" || kind === "nullish" || kind === "regexp") return false;
+	if (current === "symbol") return true;
+	if (knownSafeObjectTypes.has(current)) return false;
+	if (current === "object" || current === "Object" || current.startsWith("{") || current.endsWith("[]") || current.startsWith("[") || current.startsWith("Array<") || current.startsWith("ReadonlyArray<") || current.startsWith("Map<") || current.startsWith("ReadonlyMap<") || current.startsWith("Set<") || current.startsWith("ReadonlySet<") || current.startsWith("Record<") || current.startsWith("WeakMap<") || current.startsWith("WeakSet<") || current.startsWith("Promise<") || current.includes("=>")) return true;
+	return false;
+}
+//#endregion
+export { noBaseToStringRule };
+
+//# sourceMappingURL=no_base_to_string.js.map

package/dist/rules/no_base_to_string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_base_to_string.js","names":[],"sources":["../../ts/rules/no_base_to_string.ts"],"sourcesContent":["import {\n  calleePropertyName,\n  isIdentifierNamed,\n  isLiteralString,\n  stripChainExpression,\n} from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport {\n  classifyTypeText,\n  isStringLikeNode,\n  splitTopLevelTypeText,\n  typeTextsAtNode,\n} from \"./type_utils\";\n\nconst knownSafeObjectTypes = new Set([\n  \"Date\",\n  \"Error\",\n  \"EvalError\",\n  \"RangeError\",\n  \"ReferenceError\",\n  \"RegExp\",\n  \"SyntaxError\",\n  \"TypeError\",\n  \"URIError\",\n  \"URL\",\n  \"URLSearchParams\",\n]);\n\nexport const noBaseToStringRule = createNativeRule(\n  \"no-base-to-string\",\n  {\n    docs: {\n      description: \"Disallow stringifying values that fall back to Object.prototype.toString().\",\n    },\n    messages: {\n      unexpected: \"This value is stringified through its base Object#toString() representation.\",\n    },\n  },\n  (context) => ({\n    BinaryExpression(node: any) {\n      if (node.operator !== \"+\") {\n        return;\n      }\n      if (isLiteralString(node.left) || isStringLikeNode(context, node.left)) {\n        reportIfUnsafe(context, node.right);\n      }\n      if (isLiteralString(node.right) || isStringLikeNode(context, node.right)) {\n        reportIfUnsafe(context, node.left);\n      }\n    },\n    CallExpression(node: any) {\n      const [firstArgument] = node.arguments;\n      if (!firstArgument) {\n        return;\n      }\n      if (isIdentifierNamed(node.callee, \"String\")) {\n        reportIfUnsafe(context, firstArgument);\n        return;\n      }\n      if (calleePropertyName(node) === \"toString\") {\n        const callee = stripChainExpression(node.callee) as any;\n        reportIfUnsafe(context, callee.object);\n      }\n    },\n    TemplateLiteral(node: any) {\n      for (const expression of node.expressions ?? []) {\n        reportIfUnsafe(context, expression);\n      }\n    },\n  }),\n);\n\nfunction reportIfUnsafe(context: any, node: any): void {\n  if (!node || !isPossiblyBaseToString(context, node)) {\n    return;\n  }\n  context.report({\n    node,\n    messageId: \"unexpected\",\n  });\n}\n\nfunction isPossiblyBaseToString(context: any, node: any): boolean {\n  const current = stripChainExpression(node) as any;\n  if (\n    current?.type === \"ArrayExpression\" ||\n    current?.type === \"ObjectExpression\" ||\n    current?.type === \"ArrowFunctionExpression\" ||\n    current?.type === \"FunctionExpression\"\n  ) {\n    return true;\n  }\n  const typeTexts = typeTextsAtNode(context, node);\n  if (typeTexts.length === 0) {\n    return false;\n  }\n  return typeTexts.some((text) => splitTopLevelTypeText(text, \"|\").some(isUnsafeStringifiedText));\n}\n\nfunction isUnsafeStringifiedText(text: string): boolean {\n  const current = text.trim();\n  const kind = classifyTypeText(current);\n  if (\n    kind === \"string\" ||\n    kind === \"number\" ||\n    kind === \"bigint\" ||\n    kind === \"boolean\" ||\n    kind === \"nullish\" ||\n    kind === \"regexp\"\n  ) {\n    return false;\n  }\n  if (current === \"symbol\") {\n    return true;\n  }\n  if (knownSafeObjectTypes.has(current)) {\n    return false;\n  }\n  if (\n    current === \"object\" ||\n    current === \"Object\" ||\n    current.startsWith(\"{\") ||\n    current.endsWith(\"[]\") ||\n    current.startsWith(\"[\") ||\n    current.startsWith(\"Array<\") ||\n    current.startsWith(\"ReadonlyArray<\") ||\n    current.startsWith(\"Map<\") ||\n    current.startsWith(\"ReadonlyMap<\") ||\n    current.startsWith(\"Set<\") ||\n    current.startsWith(\"ReadonlySet<\") ||\n    current.startsWith(\"Record<\") ||\n    current.startsWith(\"WeakMap<\") ||\n    current.startsWith(\"WeakSet<\") ||\n    current.startsWith(\"Promise<\") ||\n    current.includes(\"=>\")\n  ) {\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;;;AAcA,MAAM,uBAAuB,IAAI,IAAI;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,MAAa,qBAAqB,iBAChC,qBACA;CACE,MAAM,EACJ,aAAa,+EACd;CACD,UAAU,EACR,YAAY,gFACb;CACF,GACA,aAAa;CACZ,iBAAiB,MAAW;AAC1B,MAAI,KAAK,aAAa,IACpB;AAEF,MAAI,gBAAgB,KAAK,KAAK,IAAI,iBAAiB,SAAS,KAAK,KAAK,CACpE,gBAAe,SAAS,KAAK,MAAM;AAErC,MAAI,gBAAgB,KAAK,MAAM,IAAI,iBAAiB,SAAS,KAAK,MAAM,CACtE,gBAAe,SAAS,KAAK,KAAK;;CAGtC,eAAe,MAAW;EACxB,MAAM,CAAC,iBAAiB,KAAK;AAC7B,MAAI,CAAC,cACH;AAEF,MAAI,kBAAkB,KAAK,QAAQ,SAAS,EAAE;AAC5C,kBAAe,SAAS,cAAc;AACtC;;AAEF,MAAI,mBAAmB,KAAK,KAAK,WAE/B,gBAAe,SADA,qBAAqB,KAAK,OAAO,CACjB,OAAO;;CAG1C,gBAAgB,MAAW;AACzB,OAAK,MAAM,cAAc,KAAK,eAAe,EAAE,CAC7C,gBAAe,SAAS,WAAW;;CAGxC,EACF;AAED,SAAS,eAAe,SAAc,MAAiB;AACrD,KAAI,CAAC,QAAQ,CAAC,uBAAuB,SAAS,KAAK,CACjD;AAEF,SAAQ,OAAO;EACb;EACA,WAAW;EACZ,CAAC;;AAGJ,SAAS,uBAAuB,SAAc,MAAoB;CAChE,MAAM,UAAU,qBAAqB,KAAK;AAC1C,KACE,SAAS,SAAS,qBAClB,SAAS,SAAS,sBAClB,SAAS,SAAS,6BAClB,SAAS,SAAS,qBAElB,QAAO;CAET,MAAM,YAAY,gBAAgB,SAAS,KAAK;AAChD,KAAI,UAAU,WAAW,EACvB,QAAO;AAET,QAAO,UAAU,MAAM,SAAS,sBAAsB,MAAM,IAAI,CAAC,KAAK,wBAAwB,CAAC;;AAGjG,SAAS,wBAAwB,MAAuB;CACtD,MAAM,UAAU,KAAK,MAAM;CAC3B,MAAM,OAAO,iBAAiB,QAAQ;AACtC,KACE,SAAS,YACT,SAAS,YACT,SAAS,YACT,SAAS,aACT,SAAS,aACT,SAAS,SAET,QAAO;AAET,KAAI,YAAY,SACd,QAAO;AAET,KAAI,qBAAqB,IAAI,QAAQ,CACnC,QAAO;AAET,KACE,YAAY,YACZ,YAAY,YACZ,QAAQ,WAAW,IAAI,IACvB,QAAQ,SAAS,KAAK,IACtB,QAAQ,WAAW,IAAI,IACvB,QAAQ,WAAW,SAAS,IAC5B,QAAQ,WAAW,iBAAiB,IACpC,QAAQ,WAAW,OAAO,IAC1B,QAAQ,WAAW,eAAe,IAClC,QAAQ,WAAW,OAAO,IAC1B,QAAQ,WAAW,eAAe,IAClC,QAAQ,WAAW,UAAU,IAC7B,QAAQ,WAAW,WAAW,IAC9B,QAAQ,WAAW,WAAW,IAC9B,QAAQ,WAAW,WAAW,IAC9B,QAAQ,SAAS,KAAK,CAEtB,QAAO;AAET,QAAO"}

package/dist/rules/no_floating_promises.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_floating_promises.d.ts
+declare const noFloatingPromisesRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noFloatingPromisesRule };
+//# sourceMappingURL=no_floating_promises.d.ts.map

package/dist/rules/no_floating_promises.js

@@ -0,0 +1,42 @@
+import { calleePropertyName, memberObject, nearestFunctionAncestors, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { isPromiseLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_floating_promises.ts
+const noFloatingPromisesRule = createNativeRule("no-floating-promises", {
+	docs: { description: "Require promises to be awaited or otherwise handled." },
+	hasSuggestions: true,
+	messages: { unexpected: "Promises must be awaited, returned, or explicitly ignored with void." }
+}, (context) => ({ ExpressionStatement(node) {
+	const expression = stripChainExpression(node.expression);
+	if (expression?.type === "UnaryExpression" && expression.operator === "void") return;
+	if (!isPromiseLikeNode(context, expression) || isHandled(expression)) return;
+	context.report({
+		node,
+		messageId: "unexpected",
+		suggest: buildSuggestions(context, node)
+	});
+} }));
+function isHandled(node) {
+	const current = stripChainExpression(node);
+	const propertyName = calleePropertyName(current);
+	if (!propertyName) return false;
+	if (propertyName === "catch") return current.arguments.length > 0;
+	if (propertyName === "then") return current.arguments.length > 1;
+	if (propertyName === "finally") return isHandled(memberObject(current.callee));
+	return false;
+}
+function buildSuggestions(context, node) {
+	const suggestions = [{
+		desc: "Prefix the expression with void.",
+		fix: (fixer) => fixer.insertTextBefore(node.expression, "void ")
+	}];
+	if (nearestFunctionAncestors(node, context.sourceCode)[0]?.async) suggestions.push({
+		desc: "Await the promise.",
+		fix: (fixer) => fixer.insertTextBefore(node.expression, "await ")
+	});
+	return suggestions;
+}
+//#endregion
+export { noFloatingPromisesRule };
+
+//# sourceMappingURL=no_floating_promises.js.map

package/dist/rules/no_floating_promises.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_floating_promises.js","names":[],"sources":["../../ts/rules/no_floating_promises.ts"],"sourcesContent":["import {\n  calleePropertyName,\n  memberObject,\n  nearestFunctionAncestors,\n  stripChainExpression,\n} from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { isPromiseLikeNode } from \"./type_utils\";\n\nexport const noFloatingPromisesRule = createNativeRule(\n  \"no-floating-promises\",\n  {\n    docs: {\n      description: \"Require promises to be awaited or otherwise handled.\",\n    },\n    hasSuggestions: true,\n    messages: {\n      unexpected: \"Promises must be awaited, returned, or explicitly ignored with void.\",\n    },\n  },\n  (context) => ({\n    ExpressionStatement(node: any) {\n      const expression = stripChainExpression(node.expression);\n      if (expression?.type === \"UnaryExpression\" && expression.operator === \"void\") {\n        return;\n      }\n      if (!isPromiseLikeNode(context, expression) || isHandled(expression)) {\n        return;\n      }\n      context.report({\n        node,\n        messageId: \"unexpected\",\n        suggest: buildSuggestions(context, node),\n      });\n    },\n  }),\n);\n\nfunction isHandled(node: any): boolean {\n  const current = stripChainExpression(node);\n  const propertyName = calleePropertyName(current);\n  if (!propertyName) {\n    return false;\n  }\n  if (propertyName === \"catch\") {\n    return current.arguments.length > 0;\n  }\n  if (propertyName === \"then\") {\n    return current.arguments.length > 1;\n  }\n  if (propertyName === \"finally\") {\n    return isHandled(memberObject(current.callee));\n  }\n  return false;\n}\n\nfunction buildSuggestions(context: any, node: any) {\n  const suggestions = [\n    {\n      desc: \"Prefix the expression with void.\",\n      fix: (fixer: any) => fixer.insertTextBefore(node.expression, \"void \"),\n    },\n  ];\n  const nearestFunction = nearestFunctionAncestors(node, context.sourceCode)[0];\n  if (nearestFunction?.async) {\n    suggestions.push({\n      desc: \"Await the promise.\",\n      fix: (fixer: any) => fixer.insertTextBefore(node.expression, \"await \"),\n    });\n  }\n  return suggestions;\n}\n"],"mappings":";;;;AASA,MAAa,yBAAyB,iBACpC,wBACA;CACE,MAAM,EACJ,aAAa,wDACd;CACD,gBAAgB;CAChB,UAAU,EACR,YAAY,wEACb;CACF,GACA,aAAa,EACZ,oBAAoB,MAAW;CAC7B,MAAM,aAAa,qBAAqB,KAAK,WAAW;AACxD,KAAI,YAAY,SAAS,qBAAqB,WAAW,aAAa,OACpE;AAEF,KAAI,CAAC,kBAAkB,SAAS,WAAW,IAAI,UAAU,WAAW,CAClE;AAEF,SAAQ,OAAO;EACb;EACA,WAAW;EACX,SAAS,iBAAiB,SAAS,KAAK;EACzC,CAAC;GAEL,EACF;AAED,SAAS,UAAU,MAAoB;CACrC,MAAM,UAAU,qBAAqB,KAAK;CAC1C,MAAM,eAAe,mBAAmB,QAAQ;AAChD,KAAI,CAAC,aACH,QAAO;AAET,KAAI,iBAAiB,QACnB,QAAO,QAAQ,UAAU,SAAS;AAEpC,KAAI,iBAAiB,OACnB,QAAO,QAAQ,UAAU,SAAS;AAEpC,KAAI,iBAAiB,UACnB,QAAO,UAAU,aAAa,QAAQ,OAAO,CAAC;AAEhD,QAAO;;AAGT,SAAS,iBAAiB,SAAc,MAAW;CACjD,MAAM,cAAc,CAClB;EACE,MAAM;EACN,MAAM,UAAe,MAAM,iBAAiB,KAAK,YAAY,QAAQ;EACtE,CACF;AAED,KADwB,yBAAyB,MAAM,QAAQ,WAAW,CAAC,IACtD,MACnB,aAAY,KAAK;EACf,MAAM;EACN,MAAM,UAAe,MAAM,iBAAiB,KAAK,YAAY,SAAS;EACvE,CAAC;AAEJ,QAAO"}

package/dist/rules/no_for_in_array.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_for_in_array.d.ts
+declare const noForInArrayRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noForInArrayRule };
+//# sourceMappingURL=no_for_in_array.d.ts.map

package/dist/rules/no_for_in_array.js

@@ -0,0 +1,16 @@
+import { createNativeRule } from "./rule_creator.js";
+import { isArrayLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_for_in_array.ts
+const noForInArrayRule = createNativeRule("no-for-in-array", {
+	docs: { description: "Disallow for-in iteration over array-like values." },
+	messages: { unexpected: "Do not iterate over an array with a for-in loop." }
+}, (context) => ({ ForInStatement(node) {
+	if (isArrayLikeNode(context, node.right)) context.report({
+		node,
+		messageId: "unexpected"
+	});
+} }));
+//#endregion
+export { noForInArrayRule };
+
+//# sourceMappingURL=no_for_in_array.js.map

package/dist/rules/no_for_in_array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_for_in_array.js","names":[],"sources":["../../ts/rules/no_for_in_array.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { isArrayLikeNode } from \"./type_utils\";\n\nexport const noForInArrayRule = createNativeRule(\n  \"no-for-in-array\",\n  {\n    docs: {\n      description: \"Disallow for-in iteration over array-like values.\",\n    },\n    messages: {\n      unexpected: \"Do not iterate over an array with a for-in loop.\",\n    },\n  },\n  (context) => ({\n    ForInStatement(node: any) {\n      if (isArrayLikeNode(context, node.right)) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n"],"mappings":";;;AAGA,MAAa,mBAAmB,iBAC9B,mBACA;CACE,MAAM,EACJ,aAAa,qDACd;CACD,UAAU,EACR,YAAY,oDACb;CACF,GACA,aAAa,EACZ,eAAe,MAAW;AACxB,KAAI,gBAAgB,SAAS,KAAK,MAAM,CACtC,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAGtD,EACF"}

package/dist/rules/no_implied_eval.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_implied_eval.d.ts
+declare const noImpliedEvalRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noImpliedEvalRule };
+//# sourceMappingURL=no_implied_eval.d.ts.map

package/dist/rules/no_implied_eval.js

@@ -0,0 +1,35 @@
+import { isIdentifierNamed, isLiteralString, memberPropertyName, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { isStringLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_implied_eval.ts
+const impliedEvalNames = new Set([
+	"execScript",
+	"setInterval",
+	"setTimeout"
+]);
+const noImpliedEvalRule = createNativeRule("no-implied-eval", {
+	docs: { description: "Disallow string-based dynamic code execution APIs." },
+	messages: { unexpected: "Do not pass a string to an implied eval API." }
+}, (context) => ({
+	CallExpression(node) {
+		const callee = stripChainExpression(node.callee);
+		const calleeName = memberPropertyName(callee) ?? (callee?.type === "Identifier" ? callee.name : void 0);
+		if (!calleeName || !impliedEvalNames.has(calleeName)) return;
+		const [firstArgument] = node.arguments;
+		if (firstArgument && !firstArgument.type?.includes("Function") && (isLiteralString(firstArgument) || isStringLikeNode(context, firstArgument))) context.report({
+			node,
+			messageId: "unexpected"
+		});
+	},
+	NewExpression(node) {
+		if (!isIdentifierNamed(node.callee, "Function")) return;
+		if (node.arguments.some((argument) => isLiteralString(argument))) context.report({
+			node,
+			messageId: "unexpected"
+		});
+	}
+}));
+//#endregion
+export { noImpliedEvalRule };
+
+//# sourceMappingURL=no_implied_eval.js.map

package/dist/rules/no_implied_eval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_implied_eval.js","names":[],"sources":["../../ts/rules/no_implied_eval.ts"],"sourcesContent":["import {\n  isIdentifierNamed,\n  isLiteralString,\n  memberPropertyName,\n  stripChainExpression,\n} from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { isStringLikeNode } from \"./type_utils\";\n\nconst impliedEvalNames = new Set([\"execScript\", \"setInterval\", \"setTimeout\"]);\n\nexport const noImpliedEvalRule = createNativeRule(\n  \"no-implied-eval\",\n  {\n    docs: {\n      description: \"Disallow string-based dynamic code execution APIs.\",\n    },\n    messages: {\n      unexpected: \"Do not pass a string to an implied eval API.\",\n    },\n  },\n  (context) => ({\n    CallExpression(node: any) {\n      const callee = stripChainExpression(node.callee);\n      const calleeName =\n        memberPropertyName(callee) ?? (callee?.type === \"Identifier\" ? callee.name : undefined);\n      if (!calleeName || !impliedEvalNames.has(calleeName)) {\n        return;\n      }\n      const [firstArgument] = node.arguments;\n      if (\n        firstArgument &&\n        !firstArgument.type?.includes(\"Function\") &&\n        (isLiteralString(firstArgument) || isStringLikeNode(context, firstArgument))\n      ) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n    NewExpression(node: any) {\n      if (!isIdentifierNamed(node.callee, \"Function\")) {\n        return;\n      }\n      if (node.arguments.some((argument: any) => isLiteralString(argument))) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n"],"mappings":";;;;AASA,MAAM,mBAAmB,IAAI,IAAI;CAAC;CAAc;CAAe;CAAa,CAAC;AAE7E,MAAa,oBAAoB,iBAC/B,mBACA;CACE,MAAM,EACJ,aAAa,sDACd;CACD,UAAU,EACR,YAAY,gDACb;CACF,GACA,aAAa;CACZ,eAAe,MAAW;EACxB,MAAM,SAAS,qBAAqB,KAAK,OAAO;EAChD,MAAM,aACJ,mBAAmB,OAAO,KAAK,QAAQ,SAAS,eAAe,OAAO,OAAO,KAAA;AAC/E,MAAI,CAAC,cAAc,CAAC,iBAAiB,IAAI,WAAW,CAClD;EAEF,MAAM,CAAC,iBAAiB,KAAK;AAC7B,MACE,iBACA,CAAC,cAAc,MAAM,SAAS,WAAW,KACxC,gBAAgB,cAAc,IAAI,iBAAiB,SAAS,cAAc,EAE3E,SAAQ,OAAO;GAAE;GAAM,WAAW;GAAc,CAAC;;CAGrD,cAAc,MAAW;AACvB,MAAI,CAAC,kBAAkB,KAAK,QAAQ,WAAW,CAC7C;AAEF,MAAI,KAAK,UAAU,MAAM,aAAkB,gBAAgB,SAAS,CAAC,CACnE,SAAQ,OAAO;GAAE;GAAM,WAAW;GAAc,CAAC;;CAGtD,EACF"}

package/dist/rules/no_mixed_enums.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_mixed_enums.d.ts
+declare const noMixedEnumsRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noMixedEnumsRule };
+//# sourceMappingURL=no_mixed_enums.d.ts.map

package/dist/rules/no_mixed_enums.js

@@ -0,0 +1,41 @@
+import { createNativeRule } from "./rule_creator.js";
+import { isNumberLikeNode, isStringLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_mixed_enums.ts
+const noMixedEnumsRule = createNativeRule("no-mixed-enums", {
+	docs: { description: "Disallow mixing string and numeric enum members." },
+	messages: { mixed: "Mixing number and string enums can be confusing." }
+}, (context) => ({ TSEnumDeclaration(node) {
+	const members = enumMembersOf(node);
+	if (members.length === 0) return;
+	const desiredKind = enumMemberKind(context, members[0]);
+	if (desiredKind === "unknown") return;
+	for (const member of members) {
+		const currentKind = enumMemberKind(context, member);
+		if (currentKind === "unknown") return;
+		if (currentKind !== desiredKind) {
+			context.report({
+				node: member.initializer ?? member,
+				messageId: "mixed"
+			});
+			return;
+		}
+	}
+} }));
+function enumMembersOf(node) {
+	return node.body?.members ?? node.members ?? [];
+}
+function enumMemberKind(context, member) {
+	const initializer = member.initializer;
+	if (!initializer) return "number";
+	if (initializer.type === "Literal") {
+		if (typeof initializer.value === "number") return "number";
+		if (typeof initializer.value === "string") return "string";
+	}
+	if (isStringLikeNode(context, initializer)) return "string";
+	if (isNumberLikeNode(context, initializer)) return "number";
+	return "unknown";
+}
+//#endregion
+export { noMixedEnumsRule };
+
+//# sourceMappingURL=no_mixed_enums.js.map

package/dist/rules/no_mixed_enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_mixed_enums.js","names":[],"sources":["../../ts/rules/no_mixed_enums.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { isNumberLikeNode, isStringLikeNode } from \"./type_utils\";\n\nexport const noMixedEnumsRule = createNativeRule(\n  \"no-mixed-enums\",\n  {\n    docs: {\n      description: \"Disallow mixing string and numeric enum members.\",\n    },\n    messages: {\n      mixed: \"Mixing number and string enums can be confusing.\",\n    },\n  },\n  (context) => ({\n    TSEnumDeclaration(node: any) {\n      const members = enumMembersOf(node);\n      if (members.length === 0) {\n        return;\n      }\n      const desiredKind = enumMemberKind(context, members[0]);\n      if (desiredKind === \"unknown\") {\n        return;\n      }\n      for (const member of members) {\n        const currentKind = enumMemberKind(context, member);\n        if (currentKind === \"unknown\") {\n          return;\n        }\n        if (currentKind !== desiredKind) {\n          context.report({\n            node: member.initializer ?? member,\n            messageId: \"mixed\",\n          });\n          return;\n        }\n      }\n    },\n  }),\n);\n\nfunction enumMembersOf(node: any): readonly any[] {\n  return node.body?.members ?? node.members ?? [];\n}\n\nfunction enumMemberKind(context: any, member: any): \"number\" | \"string\" | \"unknown\" {\n  const initializer = member.initializer;\n  if (!initializer) {\n    return \"number\";\n  }\n  if (initializer.type === \"Literal\") {\n    if (typeof initializer.value === \"number\") {\n      return \"number\";\n    }\n    if (typeof initializer.value === \"string\") {\n      return \"string\";\n    }\n  }\n  if (isStringLikeNode(context, initializer)) {\n    return \"string\";\n  }\n  if (isNumberLikeNode(context, initializer)) {\n    return \"number\";\n  }\n  return \"unknown\";\n}\n"],"mappings":";;;AAGA,MAAa,mBAAmB,iBAC9B,kBACA;CACE,MAAM,EACJ,aAAa,oDACd;CACD,UAAU,EACR,OAAO,oDACR;CACF,GACA,aAAa,EACZ,kBAAkB,MAAW;CAC3B,MAAM,UAAU,cAAc,KAAK;AACnC,KAAI,QAAQ,WAAW,EACrB;CAEF,MAAM,cAAc,eAAe,SAAS,QAAQ,GAAG;AACvD,KAAI,gBAAgB,UAClB;AAEF,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,cAAc,eAAe,SAAS,OAAO;AACnD,MAAI,gBAAgB,UAClB;AAEF,MAAI,gBAAgB,aAAa;AAC/B,WAAQ,OAAO;IACb,MAAM,OAAO,eAAe;IAC5B,WAAW;IACZ,CAAC;AACF;;;GAIP,EACF;AAED,SAAS,cAAc,MAA2B;AAChD,QAAO,KAAK,MAAM,WAAW,KAAK,WAAW,EAAE;;AAGjD,SAAS,eAAe,SAAc,QAA8C;CAClF,MAAM,cAAc,OAAO;AAC3B,KAAI,CAAC,YACH,QAAO;AAET,KAAI,YAAY,SAAS,WAAW;AAClC,MAAI,OAAO,YAAY,UAAU,SAC/B,QAAO;AAET,MAAI,OAAO,YAAY,UAAU,SAC/B,QAAO;;AAGX,KAAI,iBAAiB,SAAS,YAAY,CACxC,QAAO;AAET,KAAI,iBAAiB,SAAS,YAAY,CACxC,QAAO;AAET,QAAO"}

package/dist/rules/no_unsafe_assignment.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_assignment.d.ts
+declare const noUnsafeAssignmentRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noUnsafeAssignmentRule };
+//# sourceMappingURL=no_unsafe_assignment.d.ts.map

package/dist/rules/no_unsafe_assignment.js

@@ -0,0 +1,41 @@
+import { createNativeRule } from "./rule_creator.js";
+import { typeTextsAtNode } from "./type_utils.js";
+import { isUnsafeAssignment } from "@corsa-bind/napi";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_assignment.ts
+const noUnsafeAssignmentRule = createNativeRule("no-unsafe-assignment", {
+	docs: { description: "Disallow assigning any-typed values to more specific targets." },
+	messages: { unsafe: "Unsafe assignment of an any-typed value." }
+}, (context) => ({
+	AssignmentExpression(node) {
+		if (node.operator !== "=") return;
+		reportIfUnsafe(context, node.right, typeTextsAtNode(context, node.left), node);
+	},
+	PropertyDefinition(node) {
+		if (!node.value) return;
+		reportIfUnsafe(context, node.value, targetTypeTextsForNode(context, node), node);
+	},
+	VariableDeclarator(node) {
+		if (!node.init) return;
+		reportIfUnsafe(context, node.init, targetTypeTextsForNode(context, node.id), node);
+	}
+}));
+function reportIfUnsafe(context, sourceNode, targetTypeTexts, reportNode) {
+	if (!isUnsafeAssignment({
+		sourceTypeTexts: typeTextsAtNode(context, sourceNode),
+		targetTypeTexts
+	})) return;
+	context.report({
+		node: reportNode,
+		messageId: "unsafe"
+	});
+}
+function targetTypeTextsForNode(context, node) {
+	const annotation = node?.typeAnnotation?.typeAnnotation ?? node?.typeAnnotation;
+	if (!annotation) return [];
+	const text = context.sourceCode.getText(annotation);
+	return text ? [text] : [];
+}
+//#endregion
+export { noUnsafeAssignmentRule };
+
+//# sourceMappingURL=no_unsafe_assignment.js.map

package/dist/rules/no_unsafe_assignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_unsafe_assignment.js","names":[],"sources":["../../ts/rules/no_unsafe_assignment.ts"],"sourcesContent":["import { isUnsafeAssignment } from \"@corsa-bind/napi\";\n\nimport { createNativeRule } from \"./rule_creator\";\nimport { typeTextsAtNode } from \"./type_utils\";\n\nexport const noUnsafeAssignmentRule = createNativeRule(\n  \"no-unsafe-assignment\",\n  {\n    docs: {\n      description: \"Disallow assigning any-typed values to more specific targets.\",\n    },\n    messages: {\n      unsafe: \"Unsafe assignment of an any-typed value.\",\n    },\n  },\n  (context) => ({\n    AssignmentExpression(node: any) {\n      if (node.operator !== \"=\") {\n        return;\n      }\n      reportIfUnsafe(context, node.right, typeTextsAtNode(context, node.left), node);\n    },\n    PropertyDefinition(node: any) {\n      if (!node.value) {\n        return;\n      }\n      reportIfUnsafe(context, node.value, targetTypeTextsForNode(context, node), node);\n    },\n    VariableDeclarator(node: any) {\n      if (!node.init) {\n        return;\n      }\n      reportIfUnsafe(context, node.init, targetTypeTextsForNode(context, node.id), node);\n    },\n  }),\n);\n\nfunction reportIfUnsafe(\n  context: any,\n  sourceNode: any,\n  targetTypeTexts: readonly string[],\n  reportNode: any,\n): void {\n  const sourceTypeTexts = typeTextsAtNode(context, sourceNode);\n  if (\n    !isUnsafeAssignment({\n      sourceTypeTexts,\n      targetTypeTexts,\n    })\n  ) {\n    return;\n  }\n  context.report({\n    node: reportNode,\n    messageId: \"unsafe\",\n  });\n}\n\nfunction targetTypeTextsForNode(context: any, node: any): readonly string[] {\n  const annotation = node?.typeAnnotation?.typeAnnotation ?? node?.typeAnnotation;\n  if (!annotation) {\n    return [];\n  }\n  const text = context.sourceCode.getText(annotation);\n  return text ? [text] : [];\n}\n"],"mappings":";;;;AAKA,MAAa,yBAAyB,iBACpC,wBACA;CACE,MAAM,EACJ,aAAa,iEACd;CACD,UAAU,EACR,QAAQ,4CACT;CACF,GACA,aAAa;CACZ,qBAAqB,MAAW;AAC9B,MAAI,KAAK,aAAa,IACpB;AAEF,iBAAe,SAAS,KAAK,OAAO,gBAAgB,SAAS,KAAK,KAAK,EAAE,KAAK;;CAEhF,mBAAmB,MAAW;AAC5B,MAAI,CAAC,KAAK,MACR;AAEF,iBAAe,SAAS,KAAK,OAAO,uBAAuB,SAAS,KAAK,EAAE,KAAK;;CAElF,mBAAmB,MAAW;AAC5B,MAAI,CAAC,KAAK,KACR;AAEF,iBAAe,SAAS,KAAK,MAAM,uBAAuB,SAAS,KAAK,GAAG,EAAE,KAAK;;CAErF,EACF;AAED,SAAS,eACP,SACA,YACA,iBACA,YACM;AAEN,KACE,CAAC,mBAAmB;EAClB,iBAHoB,gBAAgB,SAAS,WAAW;EAIxD;EACD,CAAC,CAEF;AAEF,SAAQ,OAAO;EACb,MAAM;EACN,WAAW;EACZ,CAAC;;AAGJ,SAAS,uBAAuB,SAAc,MAA8B;CAC1E,MAAM,aAAa,MAAM,gBAAgB,kBAAkB,MAAM;AACjE,KAAI,CAAC,WACH,QAAO,EAAE;CAEX,MAAM,OAAO,QAAQ,WAAW,QAAQ,WAAW;AACnD,QAAO,OAAO,CAAC,KAAK,GAAG,EAAE"}

package/dist/rules/no_unsafe_return.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_return.d.ts
+declare const noUnsafeReturnRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noUnsafeReturnRule };
+//# sourceMappingURL=no_unsafe_return.d.ts.map

package/dist/rules/no_unsafe_return.js

@@ -0,0 +1,56 @@
+import { nearestFunctionAncestors } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { checkerFor, typeAtNode, typeTextsAtNode } from "./type_utils.js";
+import { isUnsafeReturn } from "@corsa-bind/napi";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_return.ts
+const callSignatureKind = 0;
+const noUnsafeReturnRule = createNativeRule("no-unsafe-return", {
+	docs: { description: "Disallow returning any-typed values from functions." },
+	messages: { unsafe: "Unsafe return of an any-typed value." }
+}, (context) => ({
+	ArrowFunctionExpression(node) {
+		if (node.body?.type === "BlockStatement") return;
+		reportIfUnsafeReturn(context, node.body, node);
+	},
+	ReturnStatement(node) {
+		if (!node.argument) return;
+		const [owner] = nearestFunctionAncestors(node, context.sourceCode);
+		if (!owner) return;
+		reportIfUnsafeReturn(context, node.argument, owner);
+	}
+}));
+function reportIfUnsafeReturn(context, expression, owner) {
+	if (!isUnsafeReturn({
+		sourceTypeTexts: typeTextsAtNode(context, expression),
+		targetTypeTexts: returnTypeTextsOfFunction(context, owner)
+	})) return;
+	context.report({
+		node: expression,
+		messageId: "unsafe"
+	});
+}
+function returnTypeTextsOfFunction(context, node) {
+	const explicitAnnotation = node.returnType?.typeAnnotation ?? node.returnType;
+	if (explicitAnnotation) {
+		const text = context.sourceCode.getText(explicitAnnotation);
+		if (text) return [text];
+	}
+	const checker = checkerFor(context);
+	const type = typeAtNode(context, node);
+	if (!type) return [];
+	const texts = /* @__PURE__ */ new Set();
+	for (const signature of checker.getSignaturesOfType(type, callSignatureKind)) {
+		const returnType = checker.getReturnTypeOfSignature(signature);
+		if (!returnType) continue;
+		for (const text of [...returnType.texts ?? [], checker.typeToString(returnType)]) if (text) texts.add(text);
+	}
+	const resolved = [...texts];
+	return resolved.every(isPermissiveTypeText) ? [] : resolved;
+}
+function isPermissiveTypeText(text) {
+	return text === "any" || text === "unknown" || text === "never";
+}
+//#endregion
+export { noUnsafeReturnRule };
+
+//# sourceMappingURL=no_unsafe_return.js.map

package/dist/rules/no_unsafe_return.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_unsafe_return.js","names":[],"sources":["../../ts/rules/no_unsafe_return.ts"],"sourcesContent":["import { isUnsafeReturn } from \"@corsa-bind/napi\";\n\nimport { nearestFunctionAncestors } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { checkerFor, typeAtNode, typeTextsAtNode } from \"./type_utils\";\n\nconst callSignatureKind = 0;\n\nexport const noUnsafeReturnRule = createNativeRule(\n  \"no-unsafe-return\",\n  {\n    docs: {\n      description: \"Disallow returning any-typed values from functions.\",\n    },\n    messages: {\n      unsafe: \"Unsafe return of an any-typed value.\",\n    },\n  },\n  (context) => ({\n    ArrowFunctionExpression(node: any) {\n      if (node.body?.type === \"BlockStatement\") {\n        return;\n      }\n      reportIfUnsafeReturn(context, node.body, node);\n    },\n    ReturnStatement(node: any) {\n      if (!node.argument) {\n        return;\n      }\n      const [owner] = nearestFunctionAncestors(node, context.sourceCode);\n      if (!owner) {\n        return;\n      }\n      reportIfUnsafeReturn(context, node.argument, owner);\n    },\n  }),\n);\n\nfunction reportIfUnsafeReturn(context: any, expression: any, owner: any): void {\n  const sourceTypeTexts = typeTextsAtNode(context, expression);\n  const targetTypeTexts = returnTypeTextsOfFunction(context, owner);\n  if (\n    !isUnsafeReturn({\n      sourceTypeTexts,\n      targetTypeTexts,\n    })\n  ) {\n    return;\n  }\n  context.report({\n    node: expression,\n    messageId: \"unsafe\",\n  });\n}\n\nfunction returnTypeTextsOfFunction(context: any, node: any): readonly string[] {\n  const explicitAnnotation = node.returnType?.typeAnnotation ?? node.returnType;\n  if (explicitAnnotation) {\n    const text = context.sourceCode.getText(explicitAnnotation);\n    if (text) {\n      return [text];\n    }\n  }\n\n  const checker = checkerFor(context);\n  const type = typeAtNode(context, node);\n  if (!type) {\n    return [];\n  }\n\n  const texts = new Set<string>();\n  for (const signature of checker.getSignaturesOfType(type, callSignatureKind)) {\n    const returnType = checker.getReturnTypeOfSignature(signature);\n    if (!returnType) {\n      continue;\n    }\n    for (const text of [...(returnType.texts ?? []), checker.typeToString(returnType)]) {\n      if (text) {\n        texts.add(text);\n      }\n    }\n  }\n\n  const resolved = [...texts];\n  return resolved.every(isPermissiveTypeText) ? [] : resolved;\n}\n\nfunction isPermissiveTypeText(text: string): boolean {\n  return text === \"any\" || text === \"unknown\" || text === \"never\";\n}\n"],"mappings":";;;;;AAMA,MAAM,oBAAoB;AAE1B,MAAa,qBAAqB,iBAChC,oBACA;CACE,MAAM,EACJ,aAAa,uDACd;CACD,UAAU,EACR,QAAQ,wCACT;CACF,GACA,aAAa;CACZ,wBAAwB,MAAW;AACjC,MAAI,KAAK,MAAM,SAAS,iBACtB;AAEF,uBAAqB,SAAS,KAAK,MAAM,KAAK;;CAEhD,gBAAgB,MAAW;AACzB,MAAI,CAAC,KAAK,SACR;EAEF,MAAM,CAAC,SAAS,yBAAyB,MAAM,QAAQ,WAAW;AAClE,MAAI,CAAC,MACH;AAEF,uBAAqB,SAAS,KAAK,UAAU,MAAM;;CAEtD,EACF;AAED,SAAS,qBAAqB,SAAc,YAAiB,OAAkB;AAG7E,KACE,CAAC,eAAe;EACd,iBAJoB,gBAAgB,SAAS,WAAW;EAKxD,iBAJoB,0BAA0B,SAAS,MAAM;EAK9D,CAAC,CAEF;AAEF,SAAQ,OAAO;EACb,MAAM;EACN,WAAW;EACZ,CAAC;;AAGJ,SAAS,0BAA0B,SAAc,MAA8B;CAC7E,MAAM,qBAAqB,KAAK,YAAY,kBAAkB,KAAK;AACnE,KAAI,oBAAoB;EACtB,MAAM,OAAO,QAAQ,WAAW,QAAQ,mBAAmB;AAC3D,MAAI,KACF,QAAO,CAAC,KAAK;;CAIjB,MAAM,UAAU,WAAW,QAAQ;CACnC,MAAM,OAAO,WAAW,SAAS,KAAK;AACtC,KAAI,CAAC,KACH,QAAO,EAAE;CAGX,MAAM,wBAAQ,IAAI,KAAa;AAC/B,MAAK,MAAM,aAAa,QAAQ,oBAAoB,MAAM,kBAAkB,EAAE;EAC5E,MAAM,aAAa,QAAQ,yBAAyB,UAAU;AAC9D,MAAI,CAAC,WACH;AAEF,OAAK,MAAM,QAAQ,CAAC,GAAI,WAAW,SAAS,EAAE,EAAG,QAAQ,aAAa,WAAW,CAAC,CAChF,KAAI,KACF,OAAM,IAAI,KAAK;;CAKrB,MAAM,WAAW,CAAC,GAAG,MAAM;AAC3B,QAAO,SAAS,MAAM,qBAAqB,GAAG,EAAE,GAAG;;AAGrD,SAAS,qBAAqB,MAAuB;AACnD,QAAO,SAAS,SAAS,SAAS,aAAa,SAAS"}

package/dist/rules/no_unsafe_unary_minus.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_unary_minus.d.ts
+declare const noUnsafeUnaryMinusRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noUnsafeUnaryMinusRule };
+//# sourceMappingURL=no_unsafe_unary_minus.d.ts.map

package/dist/rules/no_unsafe_unary_minus.js

@@ -0,0 +1,28 @@
+import { createNativeRule } from "./rule_creator.js";
+import { classifyTypeText, splitTypeText, typeTextsAtNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_unsafe_unary_minus.ts
+const noUnsafeUnaryMinusRule = createNativeRule("no-unsafe-unary-minus", {
+	docs: { description: "Disallow unary negation on non-number and non-bigint values." },
+	messages: { unaryMinus: "Argument of unary negation should be assignable to number | bigint." }
+}, (context) => ({ UnaryExpression(node) {
+	if (node.operator !== "-") return;
+	if (isSafeLiteral(node.argument)) return;
+	const typeTexts = typeTextsAtNode(context, node.argument);
+	if (typeTexts.length > 0 && typeTexts.every((text) => {
+		return splitTypeText(text).every((part) => {
+			const kind = classifyTypeText(part);
+			return kind === "any" || kind === "number" || kind === "bigint";
+		});
+	})) return;
+	context.report({
+		node,
+		messageId: "unaryMinus"
+	});
+} }));
+function isSafeLiteral(node) {
+	return node?.type === "Literal" && (typeof node.value === "number" || typeof node.bigint === "string");
+}
+//#endregion
+export { noUnsafeUnaryMinusRule };
+
+//# sourceMappingURL=no_unsafe_unary_minus.js.map

package/dist/rules/no_unsafe_unary_minus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_unsafe_unary_minus.js","names":[],"sources":["../../ts/rules/no_unsafe_unary_minus.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { classifyTypeText, splitTypeText, typeTextsAtNode } from \"./type_utils\";\n\nexport const noUnsafeUnaryMinusRule = createNativeRule(\n  \"no-unsafe-unary-minus\",\n  {\n    docs: {\n      description: \"Disallow unary negation on non-number and non-bigint values.\",\n    },\n    messages: {\n      unaryMinus: \"Argument of unary negation should be assignable to number | bigint.\",\n    },\n  },\n  (context) => ({\n    UnaryExpression(node: any) {\n      if (node.operator !== \"-\") {\n        return;\n      }\n      if (isSafeLiteral(node.argument)) {\n        return;\n      }\n      const typeTexts = typeTextsAtNode(context, node.argument);\n      if (\n        typeTexts.length > 0 &&\n        typeTexts.every((text) => {\n          return splitTypeText(text).every((part) => {\n            const kind = classifyTypeText(part);\n            return kind === \"any\" || kind === \"number\" || kind === \"bigint\";\n          });\n        })\n      ) {\n        return;\n      }\n      context.report({ node, messageId: \"unaryMinus\" });\n    },\n  }),\n);\n\nfunction isSafeLiteral(node: any): boolean {\n  return (\n    node?.type === \"Literal\" && (typeof node.value === \"number\" || typeof node.bigint === \"string\")\n  );\n}\n"],"mappings":";;;AAGA,MAAa,yBAAyB,iBACpC,yBACA;CACE,MAAM,EACJ,aAAa,gEACd;CACD,UAAU,EACR,YAAY,uEACb;CACF,GACA,aAAa,EACZ,gBAAgB,MAAW;AACzB,KAAI,KAAK,aAAa,IACpB;AAEF,KAAI,cAAc,KAAK,SAAS,CAC9B;CAEF,MAAM,YAAY,gBAAgB,SAAS,KAAK,SAAS;AACzD,KACE,UAAU,SAAS,KACnB,UAAU,OAAO,SAAS;AACxB,SAAO,cAAc,KAAK,CAAC,OAAO,SAAS;GACzC,MAAM,OAAO,iBAAiB,KAAK;AACnC,UAAO,SAAS,SAAS,SAAS,YAAY,SAAS;IACvD;GACF,CAEF;AAEF,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAEpD,EACF;AAED,SAAS,cAAc,MAAoB;AACzC,QACE,MAAM,SAAS,cAAc,OAAO,KAAK,UAAU,YAAY,OAAO,KAAK,WAAW"}

package/dist/rules/only_throw_error.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/only_throw_error.d.ts
+declare const onlyThrowErrorRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { onlyThrowErrorRule };
+//# sourceMappingURL=only_throw_error.d.ts.map

package/dist/rules/only_throw_error.js

@@ -0,0 +1,16 @@
+import { createNativeRule } from "./rule_creator.js";
+import { isErrorLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/only_throw_error.ts
+const onlyThrowErrorRule = createNativeRule("only-throw-error", {
+	docs: { description: "Require thrown values to be Error-like." },
+	messages: { unexpected: "Only Error-like values should be thrown." }
+}, (context) => ({ ThrowStatement(node) {
+	if (node.argument && !isErrorLikeNode(context, node.argument)) context.report({
+		node,
+		messageId: "unexpected"
+	});
+} }));
+//#endregion
+export { onlyThrowErrorRule };
+
+//# sourceMappingURL=only_throw_error.js.map

package/dist/rules/only_throw_error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"only_throw_error.js","names":[],"sources":["../../ts/rules/only_throw_error.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { isErrorLikeNode } from \"./type_utils\";\n\nexport const onlyThrowErrorRule = createNativeRule(\n  \"only-throw-error\",\n  {\n    docs: {\n      description: \"Require thrown values to be Error-like.\",\n    },\n    messages: {\n      unexpected: \"Only Error-like values should be thrown.\",\n    },\n  },\n  (context) => ({\n    ThrowStatement(node: any) {\n      if (node.argument && !isErrorLikeNode(context, node.argument)) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n"],"mappings":";;;AAGA,MAAa,qBAAqB,iBAChC,oBACA;CACE,MAAM,EACJ,aAAa,2CACd;CACD,UAAU,EACR,YAAY,4CACb;CACF,GACA,aAAa,EACZ,eAAe,MAAW;AACxB,KAAI,KAAK,YAAY,CAAC,gBAAgB,SAAS,KAAK,SAAS,CAC3D,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAGtD,EACF"}

package/dist/rules/prefer_find.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_find.d.ts
+declare const preferFindRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { preferFindRule };
+//# sourceMappingURL=prefer_find.d.ts.map

package/dist/rules/prefer_find.js

@@ -0,0 +1,25 @@
+import { calleePropertyName, memberObject, memberPropertyName } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_find.ts
+const preferFindRule = createNativeRule("prefer-find", {
+	docs: { description: "Prefer find over filtering and taking the first element." },
+	messages: { unexpected: "Use .find() instead of filtering and taking the first match." }
+}, (context) => ({
+	MemberExpression(node) {
+		if (memberPropertyName(node) === "0" && calleePropertyName(node.object) === "filter") context.report({
+			node,
+			messageId: "unexpected"
+		});
+	},
+	CallExpression(node) {
+		if (calleePropertyName(node) !== "at" || node.arguments[0]?.value !== 0) return;
+		if (calleePropertyName(memberObject(node.callee)) === "filter") context.report({
+			node,
+			messageId: "unexpected"
+		});
+	}
+}));
+//#endregion
+export { preferFindRule };
+
+//# sourceMappingURL=prefer_find.js.map

package/dist/rules/prefer_find.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer_find.js","names":[],"sources":["../../ts/rules/prefer_find.ts"],"sourcesContent":["import { calleePropertyName, memberObject, memberPropertyName } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\n\nexport const preferFindRule = createNativeRule(\n  \"prefer-find\",\n  {\n    docs: {\n      description: \"Prefer find over filtering and taking the first element.\",\n    },\n    messages: {\n      unexpected: \"Use .find() instead of filtering and taking the first match.\",\n    },\n  },\n  (context) => ({\n    MemberExpression(node: any) {\n      if (memberPropertyName(node) === \"0\" && calleePropertyName(node.object) === \"filter\") {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n    CallExpression(node: any) {\n      if (calleePropertyName(node) !== \"at\" || node.arguments[0]?.value !== 0) {\n        return;\n      }\n      if (calleePropertyName(memberObject(node.callee)) === \"filter\") {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n"],"mappings":";;;AAGA,MAAa,iBAAiB,iBAC5B,eACA;CACE,MAAM,EACJ,aAAa,4DACd;CACD,UAAU,EACR,YAAY,gEACb;CACF,GACA,aAAa;CACZ,iBAAiB,MAAW;AAC1B,MAAI,mBAAmB,KAAK,KAAK,OAAO,mBAAmB,KAAK,OAAO,KAAK,SAC1E,SAAQ,OAAO;GAAE;GAAM,WAAW;GAAc,CAAC;;CAGrD,eAAe,MAAW;AACxB,MAAI,mBAAmB,KAAK,KAAK,QAAQ,KAAK,UAAU,IAAI,UAAU,EACpE;AAEF,MAAI,mBAAmB,aAAa,KAAK,OAAO,CAAC,KAAK,SACpD,SAAQ,OAAO;GAAE;GAAM,WAAW;GAAc,CAAC;;CAGtD,EACF"}

package/dist/rules/prefer_includes.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_includes.d.ts
+declare const preferIncludesRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { preferIncludesRule };
+//# sourceMappingURL=prefer_includes.d.ts.map