@stll/oxlint-plugin 0.0.1-placeholder.0

package/dist/index.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/index.ts
+const noAnyCastsPluginSpecifier = "@stll/oxlint-plugin/no-any-casts";
+const noDangerousTypeAssertionsPluginSpecifier = "@stll/oxlint-plugin/no-dangerous-type-assertions";
+const noPartialRecordSatisfiesPluginSpecifier = "@stll/oxlint-plugin/no-partial-record-satisfies";
+const noUnsafeInnerHtmlPluginSpecifier = "@stll/oxlint-plugin/no-unsafe-inner-html";
+const portableSafetyPluginSpecifiers = [
+	noAnyCastsPluginSpecifier,
+	noDangerousTypeAssertionsPluginSpecifier,
+	noPartialRecordSatisfiesPluginSpecifier,
+	noUnsafeInnerHtmlPluginSpecifier
+];
+const portableSafetyRules = {
+	"no-any-casts/no-any-casts": "error",
+	"no-dangerous-type-assertions/no-dangerous-type-assertions": "error",
+	"no-partial-record-satisfies/no-partial-record-satisfies": "error",
+	"no-unsafe-inner-html/no-unsafe-inner-html": "error"
+};
+//#endregion
+exports.noAnyCastsPluginSpecifier = noAnyCastsPluginSpecifier;
+exports.noDangerousTypeAssertionsPluginSpecifier = noDangerousTypeAssertionsPluginSpecifier;
+exports.noPartialRecordSatisfiesPluginSpecifier = noPartialRecordSatisfiesPluginSpecifier;
+exports.noUnsafeInnerHtmlPluginSpecifier = noUnsafeInnerHtmlPluginSpecifier;
+exports.portableSafetyPluginSpecifiers = portableSafetyPluginSpecifiers;
+exports.portableSafetyRules = portableSafetyRules;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { OxlintConfig } from \"oxlint\";\n\ntype JsPlugins = NonNullable<OxlintConfig[\"jsPlugins\"]>;\ntype Rules = NonNullable<OxlintConfig[\"rules\"]>;\n\nexport const noAnyCastsPluginSpecifier = \"@stll/oxlint-plugin/no-any-casts\";\nexport const noDangerousTypeAssertionsPluginSpecifier =\n  \"@stll/oxlint-plugin/no-dangerous-type-assertions\";\nexport const noPartialRecordSatisfiesPluginSpecifier =\n  \"@stll/oxlint-plugin/no-partial-record-satisfies\";\nexport const noUnsafeInnerHtmlPluginSpecifier =\n  \"@stll/oxlint-plugin/no-unsafe-inner-html\";\n\nexport const portableSafetyPluginSpecifiers = [\n  noAnyCastsPluginSpecifier,\n  noDangerousTypeAssertionsPluginSpecifier,\n  noPartialRecordSatisfiesPluginSpecifier,\n  noUnsafeInnerHtmlPluginSpecifier,\n] satisfies JsPlugins;\n\nexport const portableSafetyRules = {\n  \"no-any-casts/no-any-casts\": \"error\",\n  \"no-dangerous-type-assertions/no-dangerous-type-assertions\": \"error\",\n  \"no-partial-record-satisfies/no-partial-record-satisfies\": \"error\",\n  \"no-unsafe-inner-html/no-unsafe-inner-html\": \"error\",\n} satisfies Rules;\n"],"mappings":";;AAKA,MAAa,4BAA4B;AACzC,MAAa,2CACX;AACF,MAAa,0CACX;AACF,MAAa,mCACX;AAEF,MAAa,iCAAiC;CAC5C;CACA;CACA;CACA;AACF;AAEA,MAAa,sBAAsB;CACjC,6BAA6B;CAC7B,6DAA6D;CAC7D,2DAA2D;CAC3D,6CAA6C;AAC/C"}

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+//#region src/index.d.ts
+declare const noAnyCastsPluginSpecifier = "@stll/oxlint-plugin/no-any-casts";
+declare const noDangerousTypeAssertionsPluginSpecifier = "@stll/oxlint-plugin/no-dangerous-type-assertions";
+declare const noPartialRecordSatisfiesPluginSpecifier = "@stll/oxlint-plugin/no-partial-record-satisfies";
+declare const noUnsafeInnerHtmlPluginSpecifier = "@stll/oxlint-plugin/no-unsafe-inner-html";
+declare const portableSafetyPluginSpecifiers: string[];
+declare const portableSafetyRules: {
+  "no-any-casts/no-any-casts": "error";
+  "no-dangerous-type-assertions/no-dangerous-type-assertions": "error";
+  "no-partial-record-satisfies/no-partial-record-satisfies": "error";
+  "no-unsafe-inner-html/no-unsafe-inner-html": "error";
+};
+//#endregion
+export { noAnyCastsPluginSpecifier, noDangerousTypeAssertionsPluginSpecifier, noPartialRecordSatisfiesPluginSpecifier, noUnsafeInnerHtmlPluginSpecifier, portableSafetyPluginSpecifiers, portableSafetyRules };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+//#region src/index.d.ts
+declare const noAnyCastsPluginSpecifier = "@stll/oxlint-plugin/no-any-casts";
+declare const noDangerousTypeAssertionsPluginSpecifier = "@stll/oxlint-plugin/no-dangerous-type-assertions";
+declare const noPartialRecordSatisfiesPluginSpecifier = "@stll/oxlint-plugin/no-partial-record-satisfies";
+declare const noUnsafeInnerHtmlPluginSpecifier = "@stll/oxlint-plugin/no-unsafe-inner-html";
+declare const portableSafetyPluginSpecifiers: string[];
+declare const portableSafetyRules: {
+  "no-any-casts/no-any-casts": "error";
+  "no-dangerous-type-assertions/no-dangerous-type-assertions": "error";
+  "no-partial-record-satisfies/no-partial-record-satisfies": "error";
+  "no-unsafe-inner-html/no-unsafe-inner-html": "error";
+};
+//#endregion
+export { noAnyCastsPluginSpecifier, noDangerousTypeAssertionsPluginSpecifier, noPartialRecordSatisfiesPluginSpecifier, noUnsafeInnerHtmlPluginSpecifier, portableSafetyPluginSpecifiers, portableSafetyRules };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,21 @@
+//#region src/index.ts
+const noAnyCastsPluginSpecifier = "@stll/oxlint-plugin/no-any-casts";
+const noDangerousTypeAssertionsPluginSpecifier = "@stll/oxlint-plugin/no-dangerous-type-assertions";
+const noPartialRecordSatisfiesPluginSpecifier = "@stll/oxlint-plugin/no-partial-record-satisfies";
+const noUnsafeInnerHtmlPluginSpecifier = "@stll/oxlint-plugin/no-unsafe-inner-html";
+const portableSafetyPluginSpecifiers = [
+	noAnyCastsPluginSpecifier,
+	noDangerousTypeAssertionsPluginSpecifier,
+	noPartialRecordSatisfiesPluginSpecifier,
+	noUnsafeInnerHtmlPluginSpecifier
+];
+const portableSafetyRules = {
+	"no-any-casts/no-any-casts": "error",
+	"no-dangerous-type-assertions/no-dangerous-type-assertions": "error",
+	"no-partial-record-satisfies/no-partial-record-satisfies": "error",
+	"no-unsafe-inner-html/no-unsafe-inner-html": "error"
+};
+//#endregion
+export { noAnyCastsPluginSpecifier, noDangerousTypeAssertionsPluginSpecifier, noPartialRecordSatisfiesPluginSpecifier, noUnsafeInnerHtmlPluginSpecifier, portableSafetyPluginSpecifiers, portableSafetyRules };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { OxlintConfig } from \"oxlint\";\n\ntype JsPlugins = NonNullable<OxlintConfig[\"jsPlugins\"]>;\ntype Rules = NonNullable<OxlintConfig[\"rules\"]>;\n\nexport const noAnyCastsPluginSpecifier = \"@stll/oxlint-plugin/no-any-casts\";\nexport const noDangerousTypeAssertionsPluginSpecifier =\n  \"@stll/oxlint-plugin/no-dangerous-type-assertions\";\nexport const noPartialRecordSatisfiesPluginSpecifier =\n  \"@stll/oxlint-plugin/no-partial-record-satisfies\";\nexport const noUnsafeInnerHtmlPluginSpecifier =\n  \"@stll/oxlint-plugin/no-unsafe-inner-html\";\n\nexport const portableSafetyPluginSpecifiers = [\n  noAnyCastsPluginSpecifier,\n  noDangerousTypeAssertionsPluginSpecifier,\n  noPartialRecordSatisfiesPluginSpecifier,\n  noUnsafeInnerHtmlPluginSpecifier,\n] satisfies JsPlugins;\n\nexport const portableSafetyRules = {\n  \"no-any-casts/no-any-casts\": \"error\",\n  \"no-dangerous-type-assertions/no-dangerous-type-assertions\": \"error\",\n  \"no-partial-record-satisfies/no-partial-record-satisfies\": \"error\",\n  \"no-unsafe-inner-html/no-unsafe-inner-html\": \"error\",\n} satisfies Rules;\n"],"mappings":";AAKA,MAAa,4BAA4B;AACzC,MAAa,2CACX;AACF,MAAa,0CACX;AACF,MAAa,mCACX;AAEF,MAAa,iCAAiC;CAC5C;CACA;CACA;CACA;AACF;AAEA,MAAa,sBAAsB;CACjC,6BAA6B;CAC7B,6DAA6D;CAC7D,2DAA2D;CAC3D,6CAA6C;AAC/C"}

package/dist/no-any-casts.cjs

@@ -0,0 +1,30 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region src/no-any-casts.ts
+var no_any_casts_default = (0, require("@oxlint/plugins").eslintCompatPlugin)({
+	meta: { name: "no-any-casts" },
+	rules: { "no-any-casts": {
+		meta: {
+			type: "problem",
+			messages: { noAnyCast: "Avoid `as any` casts. They bypass branded IDs and discriminated-union narrowing. Narrow with a type guard, use `unknown` + a guard, or refactor the source so the cast isn't needed." }
+		},
+		createOnce(context) {
+			function check(node) {
+				if (node.typeAnnotation?.type === "TSAnyKeyword") context.report({
+					node,
+					messageId: "noAnyCast"
+				});
+			}
+			return {
+				TSAsExpression: check,
+				TSTypeAssertion: check
+			};
+		}
+	} }
+});
+//#endregion
+exports.default = no_any_casts_default;
+
+//# sourceMappingURL=no-any-casts.cjs.map

package/dist/no-any-casts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-any-casts.cjs","names":[],"sources":["../src/no-any-casts.ts"],"sourcesContent":["// Disallow `as any` and `<any>` casts.\n//\n// Distinct from `no-explicit-any` (which targets `: any` annotations\n// in declarations). This rule catches the cast form — typically\n// `value as any` or the laundering `value as any as Target` — which\n// bypasses brand checks, discriminated-union narrowing, and every\n// other safety the type system provides.\n\nimport { eslintCompatPlugin } from \"@oxlint/plugins\";\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-any-casts\" },\n  rules: {\n    \"no-any-casts\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noAnyCast:\n            \"Avoid `as any` casts. They bypass branded IDs and \" +\n            \"discriminated-union narrowing. Narrow with a type guard, \" +\n            \"use `unknown` + a guard, or refactor the source so the \" +\n            \"cast isn't needed.\",\n        },\n      },\n      createOnce(context) {\n        function check(node) {\n          if (node.typeAnnotation?.type === \"TSAnyKeyword\") {\n            context.report({ node, messageId: \"noAnyCast\" });\n          }\n        }\n        return {\n          TSAsExpression: check,\n          TSTypeAssertion: check,\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;;;;AAUA,IAAA,wBAAA,4BAAA,CAAA,CAAA,mBAAA,CAAkC;CAChC,MAAM,EAAE,MAAM,eAAe;CAC7B,OAAO,EACL,gBAAgB;EACd,MAAM;GACJ,MAAM;GACN,UAAU,EACR,WACE,uLAIJ;EACF;EACA,WAAW,SAAS;GAClB,SAAS,MAAM,MAAM;IACnB,IAAI,KAAK,gBAAgB,SAAS,gBAChC,QAAQ,OAAO;KAAE;KAAM,WAAW;IAAY,CAAC;GAEnD;GACA,OAAO;IACL,gBAAgB;IAChB,iBAAiB;GACnB;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-any-casts.d.cts

@@ -0,0 +1,4 @@
+//#region src/no-any-casts.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+export = _default;
+//# sourceMappingURL=no-any-casts.d.cts.map

package/dist/no-any-casts.d.mts

@@ -0,0 +1,5 @@
+//#region src/no-any-casts.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=no-any-casts.d.mts.map

package/dist/no-any-casts.mjs

@@ -0,0 +1,27 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/no-any-casts.ts
+var no_any_casts_default = eslintCompatPlugin({
+	meta: { name: "no-any-casts" },
+	rules: { "no-any-casts": {
+		meta: {
+			type: "problem",
+			messages: { noAnyCast: "Avoid `as any` casts. They bypass branded IDs and discriminated-union narrowing. Narrow with a type guard, use `unknown` + a guard, or refactor the source so the cast isn't needed." }
+		},
+		createOnce(context) {
+			function check(node) {
+				if (node.typeAnnotation?.type === "TSAnyKeyword") context.report({
+					node,
+					messageId: "noAnyCast"
+				});
+			}
+			return {
+				TSAsExpression: check,
+				TSTypeAssertion: check
+			};
+		}
+	} }
+});
+//#endregion
+export { no_any_casts_default as default };
+
+//# sourceMappingURL=no-any-casts.mjs.map

package/dist/no-any-casts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-any-casts.mjs","names":[],"sources":["../src/no-any-casts.ts"],"sourcesContent":["// Disallow `as any` and `<any>` casts.\n//\n// Distinct from `no-explicit-any` (which targets `: any` annotations\n// in declarations). This rule catches the cast form — typically\n// `value as any` or the laundering `value as any as Target` — which\n// bypasses brand checks, discriminated-union narrowing, and every\n// other safety the type system provides.\n\nimport { eslintCompatPlugin } from \"@oxlint/plugins\";\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-any-casts\" },\n  rules: {\n    \"no-any-casts\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noAnyCast:\n            \"Avoid `as any` casts. They bypass branded IDs and \" +\n            \"discriminated-union narrowing. Narrow with a type guard, \" +\n            \"use `unknown` + a guard, or refactor the source so the \" +\n            \"cast isn't needed.\",\n        },\n      },\n      createOnce(context) {\n        function check(node) {\n          if (node.typeAnnotation?.type === \"TSAnyKeyword\") {\n            context.report({ node, messageId: \"noAnyCast\" });\n          }\n        }\n        return {\n          TSAsExpression: check,\n          TSTypeAssertion: check,\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;AAUA,IAAA,uBAAe,mBAAmB;CAChC,MAAM,EAAE,MAAM,eAAe;CAC7B,OAAO,EACL,gBAAgB;EACd,MAAM;GACJ,MAAM;GACN,UAAU,EACR,WACE,uLAIJ;EACF;EACA,WAAW,SAAS;GAClB,SAAS,MAAM,MAAM;IACnB,IAAI,KAAK,gBAAgB,SAAS,gBAChC,QAAQ,OAAO;KAAE;KAAM,WAAW;IAAY,CAAC;GAEnD;GACA,OAAO;IACL,gBAAgB;IAChB,iBAAiB;GACnB;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-dangerous-type-assertions.cjs

@@ -0,0 +1,40 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region src/no-dangerous-type-assertions.ts
+var no_dangerous_type_assertions_default = (0, require("@oxlint/plugins").eslintCompatPlugin)({
+	meta: { name: "no-dangerous-type-assertions" },
+	rules: { "no-dangerous-type-assertions": {
+		meta: {
+			type: "problem",
+			messages: { noObjectLiteralCast: "Don't cast an object literal with `as`. Type the binding (`const x: T = { ... }`) or use `satisfies T` so missing required fields fail typecheck." }
+		},
+		createOnce(context) {
+			function unwrapExpression(expression) {
+				let current = expression;
+				while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSTypeAssertion" || current?.type === "TSNonNullExpression" || current?.type === "TSSatisfiesExpression") current = current.expression;
+				return current;
+			}
+			function check(node) {
+				if (unwrapExpression(node.expression)?.type !== "ObjectExpression") return;
+				const ann = node.typeAnnotation;
+				if (!ann) return;
+				if (ann.type === "TSTypeReference" && ann.typeName?.type === "Identifier" && ann.typeName.name === "const") return;
+				if (ann.type === "TSAnyKeyword" || ann.type === "TSUnknownKeyword") return;
+				context.report({
+					node,
+					messageId: "noObjectLiteralCast"
+				});
+			}
+			return {
+				TSAsExpression: check,
+				TSTypeAssertion: check
+			};
+		}
+	} }
+});
+//#endregion
+exports.default = no_dangerous_type_assertions_default;
+
+//# sourceMappingURL=no-dangerous-type-assertions.cjs.map

package/dist/no-dangerous-type-assertions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-dangerous-type-assertions.cjs","names":[],"sources":["../src/no-dangerous-type-assertions.ts"],"sourcesContent":["// Disallow object-literal casts: `{...} as T`, `<T>{...}`.\n//\n// Casting an object literal to a type silently hides missing required\n// fields — the type system would otherwise catch the omission. Use a\n// typed binding (`const x: T = { ... }`) or `satisfies T` so missing\n// fields surface as type errors.\n//\n// Allows `as const` (legitimate widening control).\n// Allows `as any` / `as unknown` (those have dedicated rules / are\n// often used as the first step of an explicit launder).\n\nimport { eslintCompatPlugin } from \"@oxlint/plugins\";\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-dangerous-type-assertions\" },\n  rules: {\n    \"no-dangerous-type-assertions\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noObjectLiteralCast:\n            \"Don't cast an object literal with `as`. Type the binding \" +\n            \"(`const x: T = { ... }`) or use `satisfies T` so missing \" +\n            \"required fields fail typecheck.\",\n        },\n      },\n      createOnce(context) {\n        function unwrapExpression(expression) {\n          let current = expression;\n          while (\n            current?.type === \"ParenthesizedExpression\" ||\n            current?.type === \"TSAsExpression\" ||\n            current?.type === \"TSTypeAssertion\" ||\n            current?.type === \"TSNonNullExpression\" ||\n            current?.type === \"TSSatisfiesExpression\"\n          ) {\n            current = current.expression;\n          }\n          return current;\n        }\n\n        function check(node) {\n          const expression = unwrapExpression(node.expression);\n          if (expression?.type !== \"ObjectExpression\") {\n            return;\n          }\n          const ann = node.typeAnnotation;\n          if (!ann) {\n            return;\n          }\n          // Allow `as const`\n          if (\n            ann.type === \"TSTypeReference\" &&\n            ann.typeName?.type === \"Identifier\" &&\n            ann.typeName.name === \"const\"\n          ) {\n            return;\n          }\n          // `as any` and `as unknown` have their own rules / are\n          // typically the laundering step, not the final shape claim.\n          if (ann.type === \"TSAnyKeyword\" || ann.type === \"TSUnknownKeyword\") {\n            return;\n          }\n          context.report({ node, messageId: \"noObjectLiteralCast\" });\n        }\n        return {\n          TSAsExpression: check,\n          TSTypeAssertion: check,\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;;;;AAaA,IAAA,wCAAA,4BAAA,CAAA,CAAA,mBAAA,CAAkC;CAChC,MAAM,EAAE,MAAM,+BAA+B;CAC7C,OAAO,EACL,gCAAgC;EAC9B,MAAM;GACJ,MAAM;GACN,UAAU,EACR,qBACE,oJAGJ;EACF;EACA,WAAW,SAAS;GAClB,SAAS,iBAAiB,YAAY;IACpC,IAAI,UAAU;IACd,OACE,SAAS,SAAS,6BAClB,SAAS,SAAS,oBAClB,SAAS,SAAS,qBAClB,SAAS,SAAS,yBAClB,SAAS,SAAS,yBAElB,UAAU,QAAQ;IAEpB,OAAO;GACT;GAEA,SAAS,MAAM,MAAM;IAEnB,IADmB,iBAAiB,KAAK,UAC5B,CAAC,EAAE,SAAS,oBACvB;IAEF,MAAM,MAAM,KAAK;IACjB,IAAI,CAAC,KACH;IAGF,IACE,IAAI,SAAS,qBACb,IAAI,UAAU,SAAS,gBACvB,IAAI,SAAS,SAAS,SAEtB;IAIF,IAAI,IAAI,SAAS,kBAAkB,IAAI,SAAS,oBAC9C;IAEF,QAAQ,OAAO;KAAE;KAAM,WAAW;IAAsB,CAAC;GAC3D;GACA,OAAO;IACL,gBAAgB;IAChB,iBAAiB;GACnB;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-dangerous-type-assertions.d.cts

@@ -0,0 +1,4 @@
+//#region src/no-dangerous-type-assertions.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+export = _default;
+//# sourceMappingURL=no-dangerous-type-assertions.d.cts.map

package/dist/no-dangerous-type-assertions.d.mts

@@ -0,0 +1,5 @@
+//#region src/no-dangerous-type-assertions.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=no-dangerous-type-assertions.d.mts.map

package/dist/no-dangerous-type-assertions.mjs

@@ -0,0 +1,37 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/no-dangerous-type-assertions.ts
+var no_dangerous_type_assertions_default = eslintCompatPlugin({
+	meta: { name: "no-dangerous-type-assertions" },
+	rules: { "no-dangerous-type-assertions": {
+		meta: {
+			type: "problem",
+			messages: { noObjectLiteralCast: "Don't cast an object literal with `as`. Type the binding (`const x: T = { ... }`) or use `satisfies T` so missing required fields fail typecheck." }
+		},
+		createOnce(context) {
+			function unwrapExpression(expression) {
+				let current = expression;
+				while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSTypeAssertion" || current?.type === "TSNonNullExpression" || current?.type === "TSSatisfiesExpression") current = current.expression;
+				return current;
+			}
+			function check(node) {
+				if (unwrapExpression(node.expression)?.type !== "ObjectExpression") return;
+				const ann = node.typeAnnotation;
+				if (!ann) return;
+				if (ann.type === "TSTypeReference" && ann.typeName?.type === "Identifier" && ann.typeName.name === "const") return;
+				if (ann.type === "TSAnyKeyword" || ann.type === "TSUnknownKeyword") return;
+				context.report({
+					node,
+					messageId: "noObjectLiteralCast"
+				});
+			}
+			return {
+				TSAsExpression: check,
+				TSTypeAssertion: check
+			};
+		}
+	} }
+});
+//#endregion
+export { no_dangerous_type_assertions_default as default };
+
+//# sourceMappingURL=no-dangerous-type-assertions.mjs.map

package/dist/no-dangerous-type-assertions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-dangerous-type-assertions.mjs","names":[],"sources":["../src/no-dangerous-type-assertions.ts"],"sourcesContent":["// Disallow object-literal casts: `{...} as T`, `<T>{...}`.\n//\n// Casting an object literal to a type silently hides missing required\n// fields — the type system would otherwise catch the omission. Use a\n// typed binding (`const x: T = { ... }`) or `satisfies T` so missing\n// fields surface as type errors.\n//\n// Allows `as const` (legitimate widening control).\n// Allows `as any` / `as unknown` (those have dedicated rules / are\n// often used as the first step of an explicit launder).\n\nimport { eslintCompatPlugin } from \"@oxlint/plugins\";\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-dangerous-type-assertions\" },\n  rules: {\n    \"no-dangerous-type-assertions\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noObjectLiteralCast:\n            \"Don't cast an object literal with `as`. Type the binding \" +\n            \"(`const x: T = { ... }`) or use `satisfies T` so missing \" +\n            \"required fields fail typecheck.\",\n        },\n      },\n      createOnce(context) {\n        function unwrapExpression(expression) {\n          let current = expression;\n          while (\n            current?.type === \"ParenthesizedExpression\" ||\n            current?.type === \"TSAsExpression\" ||\n            current?.type === \"TSTypeAssertion\" ||\n            current?.type === \"TSNonNullExpression\" ||\n            current?.type === \"TSSatisfiesExpression\"\n          ) {\n            current = current.expression;\n          }\n          return current;\n        }\n\n        function check(node) {\n          const expression = unwrapExpression(node.expression);\n          if (expression?.type !== \"ObjectExpression\") {\n            return;\n          }\n          const ann = node.typeAnnotation;\n          if (!ann) {\n            return;\n          }\n          // Allow `as const`\n          if (\n            ann.type === \"TSTypeReference\" &&\n            ann.typeName?.type === \"Identifier\" &&\n            ann.typeName.name === \"const\"\n          ) {\n            return;\n          }\n          // `as any` and `as unknown` have their own rules / are\n          // typically the laundering step, not the final shape claim.\n          if (ann.type === \"TSAnyKeyword\" || ann.type === \"TSUnknownKeyword\") {\n            return;\n          }\n          context.report({ node, messageId: \"noObjectLiteralCast\" });\n        }\n        return {\n          TSAsExpression: check,\n          TSTypeAssertion: check,\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;AAaA,IAAA,uCAAe,mBAAmB;CAChC,MAAM,EAAE,MAAM,+BAA+B;CAC7C,OAAO,EACL,gCAAgC;EAC9B,MAAM;GACJ,MAAM;GACN,UAAU,EACR,qBACE,oJAGJ;EACF;EACA,WAAW,SAAS;GAClB,SAAS,iBAAiB,YAAY;IACpC,IAAI,UAAU;IACd,OACE,SAAS,SAAS,6BAClB,SAAS,SAAS,oBAClB,SAAS,SAAS,qBAClB,SAAS,SAAS,yBAClB,SAAS,SAAS,yBAElB,UAAU,QAAQ;IAEpB,OAAO;GACT;GAEA,SAAS,MAAM,MAAM;IAEnB,IADmB,iBAAiB,KAAK,UAC5B,CAAC,EAAE,SAAS,oBACvB;IAEF,MAAM,MAAM,KAAK;IACjB,IAAI,CAAC,KACH;IAGF,IACE,IAAI,SAAS,qBACb,IAAI,UAAU,SAAS,gBACvB,IAAI,SAAS,SAAS,SAEtB;IAIF,IAAI,IAAI,SAAS,kBAAkB,IAAI,SAAS,oBAC9C;IAEF,QAAQ,OAAO;KAAE;KAAM,WAAW;IAAsB,CAAC;GAC3D;GACA,OAAO;IACL,gBAAgB;IAChB,iBAAiB;GACnB;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-partial-record-satisfies.cjs

@@ -0,0 +1,45 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_utils = require("./utils.cjs");
+let _oxlint_plugins = require("@oxlint/plugins");
+//#region src/no-partial-record-satisfies.ts
+const unwrapReadonlyType = (typeNode) => {
+	if (typeNode?.type === "TSTypeReference" && require_utils.isIdentifier(typeNode.typeName, "Readonly")) return typeNode.typeArguments?.params?.at(0) ?? null;
+	return typeNode;
+};
+const isPartialRecordType = (typeNode) => {
+	const outer = unwrapReadonlyType(typeNode);
+	if (outer?.type !== "TSTypeReference" || !require_utils.isIdentifier(outer.typeName, "Partial")) return false;
+	const inner = unwrapReadonlyType(outer.typeArguments?.params?.at(0) ?? null);
+	return inner?.type === "TSTypeReference" && require_utils.isIdentifier(inner.typeName, "Record");
+};
+const isObjectLiteralExpression = (node) => {
+	if (node?.type === "ObjectExpression") return true;
+	if (node?.type === "TSAsExpression" && node.typeAnnotation?.type === "TSTypeReference" && require_utils.isIdentifier(node.typeAnnotation.typeName, "const")) return isObjectLiteralExpression(node.expression);
+	return false;
+};
+var no_partial_record_satisfies_default = (0, _oxlint_plugins.eslintCompatPlugin)({
+	meta: { name: "no-partial-record-satisfies" },
+	rules: { "no-partial-record-satisfies": {
+		meta: {
+			type: "problem",
+			messages: { noPartialRecordSatisfies: "Don't pin an object literal with `satisfies Partial<Record<...>>` — Partial cancels the totality check satisfies would otherwise give you, so a union member can silently fall through. Make the record total (explicit 'none'/false/null per member), narrow the key union, or add an eslint-disable naming what absence means for genuinely sparse data." }
+		},
+		createOnce(context) {
+			return { TSSatisfiesExpression(node) {
+				if (!isPartialRecordType(node.typeAnnotation)) return;
+				if (!isObjectLiteralExpression(node.expression)) return;
+				context.report({
+					node,
+					messageId: "noPartialRecordSatisfies"
+				});
+			} };
+		}
+	} }
+});
+//#endregion
+exports.default = no_partial_record_satisfies_default;
+
+//# sourceMappingURL=no-partial-record-satisfies.cjs.map

package/dist/no-partial-record-satisfies.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-partial-record-satisfies.cjs","names":["isIdentifier"],"sources":["../src/no-partial-record-satisfies.ts"],"sourcesContent":["import { eslintCompatPlugin } from \"@oxlint/plugins\";\n// Ban `<object literal> satisfies Partial<Record<Union, T>>` (with or\n// without a leading `as const`).\n//\n// A const object literal pinned with `satisfies` against a `Record` keyed by\n// a union declares itself the classification of every union member —\n// `satisfies` fails typecheck the moment a new member is added and left\n// unhandled. Wrapping that `Record` in `Partial` cancels the guarantee: a\n// missing member typechecks silently, so the literal can drift out of sync\n// with the union with no compiler signal. That silent-drift surface can cause\n// a classification-table bug when a newly added member falls through a\n// `Partial<Record<...>>` lookup instead of failing typecheck.\n//\n// `Readonly<...>` wrapping either side (`Readonly<Partial<Record<...>>>` or\n// `Partial<Readonly<Record<...>>>`) is unwrapped before the check, since it\n// changes mutability, not totality.\n//\n// Only the `satisfies` expression on an object literal is flagged. Plain\n// type-annotation positions (`const x: Partial<Record<...>> = {...}`),\n// function parameters, and variable/return type annotations are exempt:\n// those are legitimate uses (override inputs, accumulators, genuinely sparse\n// data) and carry no compiler guarantee of totality to lose.\n//\n// Flagged:\n//   const x = {\n//     a: 1,\n//   } as const satisfies Partial<Record<Union, number>>;\n//   const y = { a: 1 } satisfies Partial<Record<Union, number>>;\n//   const z = {\n//     a: 1,\n//   } as const satisfies Readonly<Partial<Record<Union, number>>>;\n//\n// Allowed:\n//   const x = {\n//     a: 1,\n//   } as const satisfies Record<Union, number>;\n//   const fn = (overrides: Partial<Record<Union, number>>) => overrides;\n//   let acc: Partial<Record<Union, number>> = {};\n//   type Sparse = Partial<Record<Union, number>>;\n//\n// Fix by making the record total over the union — an explicit \"none\" /\n// `false` / `null` value for members where nothing applies forces a new\n// union member to be classified before it typechecks. If only a subset of\n// the union is ever relevant, derive a narrower union for the keys instead\n// of falling back to `Partial`. For genuinely sparse data where absence has\n// documented meaning (e.g. an unbounded key space), add an eslint-disable\n// with a comment naming what absence means.\n\nimport { isIdentifier } from \"./utils.ts\";\n\nconst unwrapReadonlyType = (typeNode) => {\n  if (\n    typeNode?.type === \"TSTypeReference\" &&\n    isIdentifier(typeNode.typeName, \"Readonly\")\n  ) {\n    return typeNode.typeArguments?.params?.at(0) ?? null;\n  }\n  return typeNode;\n};\n\n// Matches `Partial<Record<...>>`, unwrapping a `Readonly<...>` wrapper on\n// either the outer (`Readonly<Partial<Record<...>>>`) or inner\n// (`Partial<Readonly<Record<...>>>`) type.\nconst isPartialRecordType = (typeNode) => {\n  const outer = unwrapReadonlyType(typeNode);\n  if (\n    outer?.type !== \"TSTypeReference\" ||\n    !isIdentifier(outer.typeName, \"Partial\")\n  ) {\n    return false;\n  }\n  const inner = unwrapReadonlyType(outer.typeArguments?.params?.at(0) ?? null);\n  return (\n    inner?.type === \"TSTypeReference\" && isIdentifier(inner.typeName, \"Record\")\n  );\n};\n\n// Matches an object literal, or an object literal wrapped in `as const`.\nconst isObjectLiteralExpression = (node) => {\n  if (node?.type === \"ObjectExpression\") {\n    return true;\n  }\n  if (\n    node?.type === \"TSAsExpression\" &&\n    node.typeAnnotation?.type === \"TSTypeReference\" &&\n    isIdentifier(node.typeAnnotation.typeName, \"const\")\n  ) {\n    return isObjectLiteralExpression(node.expression);\n  }\n  return false;\n};\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-partial-record-satisfies\" },\n  rules: {\n    \"no-partial-record-satisfies\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noPartialRecordSatisfies:\n            \"Don't pin an object literal with `satisfies Partial<Record<...>>` \" +\n            \"— Partial cancels the totality check satisfies would otherwise \" +\n            \"give you, so a union member can silently fall through. Make the \" +\n            \"record total (explicit 'none'/false/null per member), narrow the \" +\n            \"key union, or add an eslint-disable naming what absence means \" +\n            \"for genuinely sparse data.\",\n        },\n      },\n      createOnce(context) {\n        return {\n          TSSatisfiesExpression(node) {\n            if (!isPartialRecordType(node.typeAnnotation)) {\n              return;\n            }\n            if (!isObjectLiteralExpression(node.expression)) {\n              return;\n            }\n            context.report({ node, messageId: \"noPartialRecordSatisfies\" });\n          },\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;;;;;;AAkDA,MAAM,sBAAsB,aAAa;CACvC,IACE,UAAU,SAAS,qBACnBA,cAAAA,aAAa,SAAS,UAAU,UAAU,GAE1C,OAAO,SAAS,eAAe,QAAQ,GAAG,CAAC,KAAK;CAElD,OAAO;AACT;AAKA,MAAM,uBAAuB,aAAa;CACxC,MAAM,QAAQ,mBAAmB,QAAQ;CACzC,IACE,OAAO,SAAS,qBAChB,CAACA,cAAAA,aAAa,MAAM,UAAU,SAAS,GAEvC,OAAO;CAET,MAAM,QAAQ,mBAAmB,MAAM,eAAe,QAAQ,GAAG,CAAC,KAAK,IAAI;CAC3E,OACE,OAAO,SAAS,qBAAqBA,cAAAA,aAAa,MAAM,UAAU,QAAQ;AAE9E;AAGA,MAAM,6BAA6B,SAAS;CAC1C,IAAI,MAAM,SAAS,oBACjB,OAAO;CAET,IACE,MAAM,SAAS,oBACf,KAAK,gBAAgB,SAAS,qBAC9BA,cAAAA,aAAa,KAAK,eAAe,UAAU,OAAO,GAElD,OAAO,0BAA0B,KAAK,UAAU;CAElD,OAAO;AACT;AAEA,IAAA,uCAAA,GAAA,gBAAA,mBAAA,CAAkC;CAChC,MAAM,EAAE,MAAM,8BAA8B;CAC5C,OAAO,EACL,+BAA+B;EAC7B,MAAM;GACJ,MAAM;GACN,UAAU,EACR,0BACE,6VAMJ;EACF;EACA,WAAW,SAAS;GAClB,OAAO,EACL,sBAAsB,MAAM;IAC1B,IAAI,CAAC,oBAAoB,KAAK,cAAc,GAC1C;IAEF,IAAI,CAAC,0BAA0B,KAAK,UAAU,GAC5C;IAEF,QAAQ,OAAO;KAAE;KAAM,WAAW;IAA2B,CAAC;GAChE,EACF;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-partial-record-satisfies.d.cts

@@ -0,0 +1,4 @@
+//#region src/no-partial-record-satisfies.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+export = _default;
+//# sourceMappingURL=no-partial-record-satisfies.d.cts.map

package/dist/no-partial-record-satisfies.d.mts

@@ -0,0 +1,5 @@
+//#region src/no-partial-record-satisfies.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=no-partial-record-satisfies.d.mts.map

package/dist/no-partial-record-satisfies.mjs

@@ -0,0 +1,41 @@
+import { r as isIdentifier } from "./utils.mjs";
+import { eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/no-partial-record-satisfies.ts
+const unwrapReadonlyType = (typeNode) => {
+	if (typeNode?.type === "TSTypeReference" && isIdentifier(typeNode.typeName, "Readonly")) return typeNode.typeArguments?.params?.at(0) ?? null;
+	return typeNode;
+};
+const isPartialRecordType = (typeNode) => {
+	const outer = unwrapReadonlyType(typeNode);
+	if (outer?.type !== "TSTypeReference" || !isIdentifier(outer.typeName, "Partial")) return false;
+	const inner = unwrapReadonlyType(outer.typeArguments?.params?.at(0) ?? null);
+	return inner?.type === "TSTypeReference" && isIdentifier(inner.typeName, "Record");
+};
+const isObjectLiteralExpression = (node) => {
+	if (node?.type === "ObjectExpression") return true;
+	if (node?.type === "TSAsExpression" && node.typeAnnotation?.type === "TSTypeReference" && isIdentifier(node.typeAnnotation.typeName, "const")) return isObjectLiteralExpression(node.expression);
+	return false;
+};
+var no_partial_record_satisfies_default = eslintCompatPlugin({
+	meta: { name: "no-partial-record-satisfies" },
+	rules: { "no-partial-record-satisfies": {
+		meta: {
+			type: "problem",
+			messages: { noPartialRecordSatisfies: "Don't pin an object literal with `satisfies Partial<Record<...>>` — Partial cancels the totality check satisfies would otherwise give you, so a union member can silently fall through. Make the record total (explicit 'none'/false/null per member), narrow the key union, or add an eslint-disable naming what absence means for genuinely sparse data." }
+		},
+		createOnce(context) {
+			return { TSSatisfiesExpression(node) {
+				if (!isPartialRecordType(node.typeAnnotation)) return;
+				if (!isObjectLiteralExpression(node.expression)) return;
+				context.report({
+					node,
+					messageId: "noPartialRecordSatisfies"
+				});
+			} };
+		}
+	} }
+});
+//#endregion
+export { no_partial_record_satisfies_default as default };
+
+//# sourceMappingURL=no-partial-record-satisfies.mjs.map

package/dist/no-partial-record-satisfies.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-partial-record-satisfies.mjs","names":[],"sources":["../src/no-partial-record-satisfies.ts"],"sourcesContent":["import { eslintCompatPlugin } from \"@oxlint/plugins\";\n// Ban `<object literal> satisfies Partial<Record<Union, T>>` (with or\n// without a leading `as const`).\n//\n// A const object literal pinned with `satisfies` against a `Record` keyed by\n// a union declares itself the classification of every union member —\n// `satisfies` fails typecheck the moment a new member is added and left\n// unhandled. Wrapping that `Record` in `Partial` cancels the guarantee: a\n// missing member typechecks silently, so the literal can drift out of sync\n// with the union with no compiler signal. That silent-drift surface can cause\n// a classification-table bug when a newly added member falls through a\n// `Partial<Record<...>>` lookup instead of failing typecheck.\n//\n// `Readonly<...>` wrapping either side (`Readonly<Partial<Record<...>>>` or\n// `Partial<Readonly<Record<...>>>`) is unwrapped before the check, since it\n// changes mutability, not totality.\n//\n// Only the `satisfies` expression on an object literal is flagged. Plain\n// type-annotation positions (`const x: Partial<Record<...>> = {...}`),\n// function parameters, and variable/return type annotations are exempt:\n// those are legitimate uses (override inputs, accumulators, genuinely sparse\n// data) and carry no compiler guarantee of totality to lose.\n//\n// Flagged:\n//   const x = {\n//     a: 1,\n//   } as const satisfies Partial<Record<Union, number>>;\n//   const y = { a: 1 } satisfies Partial<Record<Union, number>>;\n//   const z = {\n//     a: 1,\n//   } as const satisfies Readonly<Partial<Record<Union, number>>>;\n//\n// Allowed:\n//   const x = {\n//     a: 1,\n//   } as const satisfies Record<Union, number>;\n//   const fn = (overrides: Partial<Record<Union, number>>) => overrides;\n//   let acc: Partial<Record<Union, number>> = {};\n//   type Sparse = Partial<Record<Union, number>>;\n//\n// Fix by making the record total over the union — an explicit \"none\" /\n// `false` / `null` value for members where nothing applies forces a new\n// union member to be classified before it typechecks. If only a subset of\n// the union is ever relevant, derive a narrower union for the keys instead\n// of falling back to `Partial`. For genuinely sparse data where absence has\n// documented meaning (e.g. an unbounded key space), add an eslint-disable\n// with a comment naming what absence means.\n\nimport { isIdentifier } from \"./utils.ts\";\n\nconst unwrapReadonlyType = (typeNode) => {\n  if (\n    typeNode?.type === \"TSTypeReference\" &&\n    isIdentifier(typeNode.typeName, \"Readonly\")\n  ) {\n    return typeNode.typeArguments?.params?.at(0) ?? null;\n  }\n  return typeNode;\n};\n\n// Matches `Partial<Record<...>>`, unwrapping a `Readonly<...>` wrapper on\n// either the outer (`Readonly<Partial<Record<...>>>`) or inner\n// (`Partial<Readonly<Record<...>>>`) type.\nconst isPartialRecordType = (typeNode) => {\n  const outer = unwrapReadonlyType(typeNode);\n  if (\n    outer?.type !== \"TSTypeReference\" ||\n    !isIdentifier(outer.typeName, \"Partial\")\n  ) {\n    return false;\n  }\n  const inner = unwrapReadonlyType(outer.typeArguments?.params?.at(0) ?? null);\n  return (\n    inner?.type === \"TSTypeReference\" && isIdentifier(inner.typeName, \"Record\")\n  );\n};\n\n// Matches an object literal, or an object literal wrapped in `as const`.\nconst isObjectLiteralExpression = (node) => {\n  if (node?.type === \"ObjectExpression\") {\n    return true;\n  }\n  if (\n    node?.type === \"TSAsExpression\" &&\n    node.typeAnnotation?.type === \"TSTypeReference\" &&\n    isIdentifier(node.typeAnnotation.typeName, \"const\")\n  ) {\n    return isObjectLiteralExpression(node.expression);\n  }\n  return false;\n};\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-partial-record-satisfies\" },\n  rules: {\n    \"no-partial-record-satisfies\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          noPartialRecordSatisfies:\n            \"Don't pin an object literal with `satisfies Partial<Record<...>>` \" +\n            \"— Partial cancels the totality check satisfies would otherwise \" +\n            \"give you, so a union member can silently fall through. Make the \" +\n            \"record total (explicit 'none'/false/null per member), narrow the \" +\n            \"key union, or add an eslint-disable naming what absence means \" +\n            \"for genuinely sparse data.\",\n        },\n      },\n      createOnce(context) {\n        return {\n          TSSatisfiesExpression(node) {\n            if (!isPartialRecordType(node.typeAnnotation)) {\n              return;\n            }\n            if (!isObjectLiteralExpression(node.expression)) {\n              return;\n            }\n            context.report({ node, messageId: \"noPartialRecordSatisfies\" });\n          },\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;;AAkDA,MAAM,sBAAsB,aAAa;CACvC,IACE,UAAU,SAAS,qBACnB,aAAa,SAAS,UAAU,UAAU,GAE1C,OAAO,SAAS,eAAe,QAAQ,GAAG,CAAC,KAAK;CAElD,OAAO;AACT;AAKA,MAAM,uBAAuB,aAAa;CACxC,MAAM,QAAQ,mBAAmB,QAAQ;CACzC,IACE,OAAO,SAAS,qBAChB,CAAC,aAAa,MAAM,UAAU,SAAS,GAEvC,OAAO;CAET,MAAM,QAAQ,mBAAmB,MAAM,eAAe,QAAQ,GAAG,CAAC,KAAK,IAAI;CAC3E,OACE,OAAO,SAAS,qBAAqB,aAAa,MAAM,UAAU,QAAQ;AAE9E;AAGA,MAAM,6BAA6B,SAAS;CAC1C,IAAI,MAAM,SAAS,oBACjB,OAAO;CAET,IACE,MAAM,SAAS,oBACf,KAAK,gBAAgB,SAAS,qBAC9B,aAAa,KAAK,eAAe,UAAU,OAAO,GAElD,OAAO,0BAA0B,KAAK,UAAU;CAElD,OAAO;AACT;AAEA,IAAA,sCAAe,mBAAmB;CAChC,MAAM,EAAE,MAAM,8BAA8B;CAC5C,OAAO,EACL,+BAA+B;EAC7B,MAAM;GACJ,MAAM;GACN,UAAU,EACR,0BACE,6VAMJ;EACF;EACA,WAAW,SAAS;GAClB,OAAO,EACL,sBAAsB,MAAM;IAC1B,IAAI,CAAC,oBAAoB,KAAK,cAAc,GAC1C;IAEF,IAAI,CAAC,0BAA0B,KAAK,UAAU,GAC5C;IAEF,QAAQ,OAAO;KAAE;KAAM,WAAW;IAA2B,CAAC;GAChE,EACF;EACF;CACF,EACF;AACF,CAAC"}

package/dist/no-unsafe-inner-html.cjs

@@ -0,0 +1,123 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_utils = require("./utils.cjs");
+let _oxlint_plugins = require("@oxlint/plugins");
+//#region src/no-unsafe-inner-html.ts
+const HTML_SANITIZER_LEAF_RE = /^(?:escape(?:html|xml)|sanitize(?:html|dom)|purify(?:html|dom)|dompurify)$/iu;
+const DOM_PURIFY_RE = /^dompurify$/iu;
+const SANITIZER_RESULT_MEMBERS = /* @__PURE__ */ new Set([
+	"value",
+	"data",
+	"html"
+]);
+const ESCAPE_HATCH_RE = /^\s*safe-html:/u;
+const isComment = (value) => typeof value === "object" && value !== null && typeof value.value === "string" && typeof value.loc === "object" && value.loc !== null;
+const isJsxIdentifier = (node, name) => typeof node === "object" && node !== null && node.type === "JSXIdentifier" && node.name === name;
+const isHtmlSanitizerCalleeName = (dotted) => {
+	const parts = dotted.split(".");
+	const leaf = parts.at(-1);
+	if (leaf === void 0) return false;
+	if (HTML_SANITIZER_LEAF_RE.test(leaf)) return true;
+	const objectName = parts.at(-2);
+	return leaf === "sanitize" && DOM_PURIFY_RE.test(objectName ?? "");
+};
+const isSanitizerCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	const dotted = require_utils.getCalleeName(node.callee);
+	return dotted !== null && isHtmlSanitizerCalleeName(dotted);
+};
+const isProvenSafeValue = (node) => {
+	if (!node || typeof node.type !== "string") return false;
+	if (node.type === "Literal" && typeof node.value === "string") return true;
+	if (node.type === "TemplateLiteral") return Array.isArray(node.expressions) && node.expressions.every(isProvenSafeValue);
+	if (isSanitizerCall(node)) return true;
+	if (node.type === "MemberExpression" && node.computed === false && isProvenSafeMemberLeaf(node)) return true;
+	return false;
+};
+const isProvenSafeMemberLeaf = (node) => {
+	const propertyName = require_utils.getPropertyName(node.property);
+	if (propertyName === null || !SANITIZER_RESULT_MEMBERS.has(propertyName)) return false;
+	return isSanitizerCall(node.object);
+};
+const isDangerouslySetInnerHtmlValue = (property) => {
+	if (require_utils.getPropertyName(property.key) !== "__html") return false;
+	const objectExpression = property.parent;
+	if (objectExpression?.type !== "ObjectExpression") return false;
+	let current = objectExpression.parent;
+	while (current?.type === "TSAsExpression" || current?.type === "TSSatisfiesExpression") current = current.parent;
+	if (current?.type !== "JSXExpressionContainer") return false;
+	const attribute = current.parent;
+	return attribute?.type === "JSXAttribute" && isJsxIdentifier(attribute.name, "dangerouslySetInnerHTML");
+};
+var no_unsafe_inner_html_default = (0, _oxlint_plugins.eslintCompatPlugin)({
+	meta: { name: "no-unsafe-inner-html" },
+	rules: { "no-unsafe-inner-html": {
+		meta: {
+			type: "problem",
+			messages: {
+				unsafeInnerHtml: "Raw HTML injected into the DOM must come from a provably sanitized/escaped value: a static string, an HTML/DOM sanitize/escape call (or its .value/.data/.html result). Wrap the value in a sanitizer, or add a `// safe-html: <reason naming the sanitizer/source>` comment on the line directly above if it is escaped at its source.",
+				unsafeInnerHtmlSpread: "Do not spread an object into dangerouslySetInnerHTML. Keep `__html` inline so this rule can prove the HTML value is sanitized or escaped."
+			}
+		},
+		createOnce(context) {
+			const escapeHatchLines = /* @__PURE__ */ new Set();
+			const recordEscapeHatches = (node) => {
+				const comments = node && Array.isArray(node.comments) ? node.comments.filter(isComment) : [];
+				for (const comment of comments) if (ESCAPE_HATCH_RE.test(comment.value)) escapeHatchLines.add(comment.loc.end.line);
+			};
+			const hasEscapeHatchAbove = (node) => escapeHatchLines.has(node.loc.start.line - 1);
+			const reportIfUnsafe = (node) => {
+				if (isProvenSafeValue(node)) return;
+				if (hasEscapeHatchAbove(node)) return;
+				context.report({
+					node,
+					messageId: "unsafeInnerHtml"
+				});
+			};
+			const reportPayloadSpreads = (objectNode) => {
+				for (const property of objectNode.properties) {
+					if (property?.type !== "SpreadElement") continue;
+					context.report({
+						node: property,
+						messageId: "unsafeInnerHtmlSpread"
+					});
+				}
+			};
+			return {
+				before() {
+					escapeHatchLines.clear();
+				},
+				Program(node) {
+					recordEscapeHatches(node);
+				},
+				JSXAttribute(node) {
+					if (!isJsxIdentifier(node.name, "dangerouslySetInnerHTML")) return;
+					const value = node.value;
+					if (value?.type !== "JSXExpressionContainer") return;
+					if (!value.expression) return;
+					const expression = require_utils.unwrapExpression(value.expression);
+					if (expression?.type === "ObjectExpression") {
+						reportPayloadSpreads(expression);
+						return;
+					}
+					reportIfUnsafe(value.expression);
+				},
+				Property(node) {
+					if (!isDangerouslySetInnerHtmlValue(node)) return;
+					reportIfUnsafe(node.value);
+				},
+				AssignmentExpression(node) {
+					const target = node.left;
+					if (target.type !== "MemberExpression" || target.computed !== false || !require_utils.isIdentifier(target.property, "innerHTML")) return;
+					reportIfUnsafe(node.right);
+				}
+			};
+		}
+	} }
+});
+//#endregion
+exports.default = no_unsafe_inner_html_default;
+
+//# sourceMappingURL=no-unsafe-inner-html.cjs.map

package/dist/no-unsafe-inner-html.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsafe-inner-html.cjs","names":["getCalleeName","getPropertyName","unwrapExpression","isIdentifier"],"sources":["../src/no-unsafe-inner-html.ts"],"sourcesContent":["import { eslintCompatPlugin } from \"@oxlint/plugins\";\n// Forbid injecting un-proven HTML into the DOM.\n//\n// Raw HTML may only reach the DOM from a value that is provably sanitized or\n// escaped. This precise guard can replace a blanket `react/no-danger` rule:\n// approved sanitizer calls remain usable while unescaped stored or user input\n// cannot flow into `__html` or `el.innerHTML` unnoticed.\n//\n// Two sinks share one allowlist:\n//   • JSX `__html` property of a `dangerouslySetInnerHTML` object literal\n//     (report on the value expression).\n//   • `AssignmentExpression` whose LHS is a non-computed `.innerHTML`\n//     MemberExpression (report on the RHS).\n//\n// A value is allowed when it is:\n//   • a string Literal or TemplateLiteral whose interpolations are all\n//     independently proven safe (static markup, no raw injection), OR\n//   • a CallExpression whose callee is an HTML/DOM sanitizer or escaper\n//     (`escapeHtml`, `escapeXml`, `sanitizeHtml`, `sanitizeDom`,\n//     `DOMPurify.sanitize`), including a `.value` / `.data` / `.html`-style\n//     member read OFF such a call (some sanitizers return `{ value }`), OR\n//   • carries an explicit `// safe-html:` escape-hatch comment on the line\n//     directly above the sink (loc adjacency, like suppression-hygiene.ts).\n//\n// A value is NOT auto-allowed just because the identifier is named\n// `html` / `content` / `headline` / `body` — those are the sinks, not\n// proof of safety. Prove safety at the source or annotate with a reason.\n//\n// Flagged:\n//   <div dangerouslySetInnerHTML={{ __html: userInput }} />\n//   <div dangerouslySetInnerHTML={{ __html: hit.headline }} />   // unless annotated\n//   el.innerHTML = html;                                         // unless annotated\n//   el.innerHTML = data.body;\n//\n// Allowed:\n//   <div dangerouslySetInnerHTML={{ __html: sanitizeHtml(x) }} />\n//   <div dangerouslySetInnerHTML={{ __html: `<b>${escapeXml(n)}</b>` }} />\n//   <div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(x) }} />\n//   el.innerHTML = \"\";\n//   el.innerHTML = \"&nbsp;\";\n//   // safe-html: escaped by escapeAndHighlight()\n//   <div dangerouslySetInnerHTML={{ __html: hit.headline }} />\n\nimport {\n  getCalleeName,\n  getPropertyName,\n  isIdentifier,\n  unwrapExpression,\n} from \"./utils.ts\";\n\n// Callee names that prove the value was run through an HTML/DOM sanitizer or\n// escaper. Keep this narrow: `escapeRegex()` and `sanitizeFilename()` are not\n// HTML-safe.\nconst HTML_SANITIZER_LEAF_RE =\n  /^(?:escape(?:html|xml)|sanitize(?:html|dom)|purify(?:html|dom)|dompurify)$/iu;\n\nconst DOM_PURIFY_RE = /^dompurify$/iu;\n\n// Members that some sanitizers expose on their result object\n// (`sanitizeHtml(x).value`, `sanitizeHtml(x).html`). Reading one of these OFF a\n// sanitizer call is still proven-safe.\nconst SANITIZER_RESULT_MEMBERS = new Set([\"value\", \"data\", \"html\"]);\n\nconst ESCAPE_HATCH_RE = /^\\s*safe-html:/u;\n\nconst isComment = (value) =>\n  typeof value === \"object\" &&\n  value !== null &&\n  typeof value.value === \"string\" &&\n  typeof value.loc === \"object\" &&\n  value.loc !== null;\n\nconst isJsxIdentifier = (node, name) =>\n  typeof node === \"object\" &&\n  node !== null &&\n  node.type === \"JSXIdentifier\" &&\n  node.name === name;\n\nconst isHtmlSanitizerCalleeName = (dotted) => {\n  const parts = dotted.split(\".\");\n  const leaf = parts.at(-1);\n  if (leaf === undefined) {\n    return false;\n  }\n  if (HTML_SANITIZER_LEAF_RE.test(leaf)) {\n    return true;\n  }\n  const objectName = parts.at(-2);\n  return leaf === \"sanitize\" && DOM_PURIFY_RE.test(objectName ?? \"\");\n};\n\nconst isSanitizerCall = (node) => {\n  if (node.type !== \"CallExpression\") {\n    return false;\n  }\n  const dotted = getCalleeName(node.callee);\n  return dotted !== null && isHtmlSanitizerCalleeName(dotted);\n};\n\n// A value is proven safe by its own shape (independent of any comment):\n// static string, or the result of a sanitizer call (directly, or via a\n// `.value`/`.data`/`.html` accessor off the call).\nconst isProvenSafeValue = (node) => {\n  if (!node || typeof node.type !== \"string\") {\n    return false;\n  }\n  if (node.type === \"Literal\" && typeof node.value === \"string\") {\n    return true;\n  }\n  if (node.type === \"TemplateLiteral\") {\n    return (\n      Array.isArray(node.expressions) &&\n      node.expressions.every(isProvenSafeValue)\n    );\n  }\n  if (isSanitizerCall(node)) {\n    return true;\n  }\n  // `sanitize(x).value`, `purify(x).html` — a result accessor off a call.\n  if (\n    node.type === \"MemberExpression\" &&\n    node.computed === false &&\n    isProvenSafeMemberLeaf(node)\n  ) {\n    return true;\n  }\n  return false;\n};\n\nconst isProvenSafeMemberLeaf = (node) => {\n  const propertyName = getPropertyName(node.property);\n  if (propertyName === null || !SANITIZER_RESULT_MEMBERS.has(propertyName)) {\n    return false;\n  }\n  return isSanitizerCall(node.object);\n};\n\nconst isDangerouslySetInnerHtmlValue = (property) => {\n  if (getPropertyName(property.key) !== \"__html\") {\n    return false;\n  }\n  const objectExpression = property.parent;\n  if (objectExpression?.type !== \"ObjectExpression\") {\n    return false;\n  }\n\n  let current = objectExpression.parent;\n  while (\n    current?.type === \"TSAsExpression\" ||\n    current?.type === \"TSSatisfiesExpression\"\n  ) {\n    current = current.parent;\n  }\n\n  if (current?.type !== \"JSXExpressionContainer\") {\n    return false;\n  }\n  const attribute = current.parent;\n  return (\n    attribute?.type === \"JSXAttribute\" &&\n    isJsxIdentifier(attribute.name, \"dangerouslySetInnerHTML\")\n  );\n};\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-unsafe-inner-html\" },\n  rules: {\n    \"no-unsafe-inner-html\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          unsafeInnerHtml:\n            \"Raw HTML injected into the DOM must come from a provably \" +\n            \"sanitized/escaped value: a static string, an HTML/DOM \" +\n            \"sanitize/escape call (or its .value/.data/.html result). \" +\n            \"Wrap the value in a sanitizer, or add a `// safe-html: <reason \" +\n            \"naming the sanitizer/source>` comment on the line directly above \" +\n            \"if it is escaped at its source.\",\n          unsafeInnerHtmlSpread:\n            \"Do not spread an object into dangerouslySetInnerHTML. Keep \" +\n            \"`__html` inline so this rule can prove the HTML value is \" +\n            \"sanitized or escaped.\",\n        },\n      },\n      createOnce(context) {\n        const escapeHatchLines = new Set();\n\n        const recordEscapeHatches = (node) => {\n          const comments =\n            node && Array.isArray(node.comments)\n              ? node.comments.filter(isComment)\n              : [];\n          for (const comment of comments) {\n            if (ESCAPE_HATCH_RE.test(comment.value)) {\n              escapeHatchLines.add(comment.loc.end.line);\n            }\n          }\n        };\n\n        // The escape-hatch comment sits on the line directly above the\n        // reported node's first line. Sink expressions inside JSX object\n        // literals span multiple lines, so anchor on the node's start line.\n        const hasEscapeHatchAbove = (node) =>\n          escapeHatchLines.has(node.loc.start.line - 1);\n\n        const reportIfUnsafe = (node) => {\n          if (isProvenSafeValue(node)) {\n            return;\n          }\n          if (hasEscapeHatchAbove(node)) {\n            return;\n          }\n          context.report({ node, messageId: \"unsafeInnerHtml\" });\n        };\n\n        const reportPayloadSpreads = (objectNode) => {\n          for (const property of objectNode.properties) {\n            if (property?.type !== \"SpreadElement\") {\n              continue;\n            }\n            context.report({\n              node: property,\n              messageId: \"unsafeInnerHtmlSpread\",\n            });\n          }\n        };\n\n        return {\n          before() {\n            escapeHatchLines.clear();\n          },\n          Program(node) {\n            recordEscapeHatches(node);\n          },\n\n          // Reject hoisted payloads such as\n          // `dangerouslySetInnerHTML={payload}`. Keeping the `__html` object\n          // inline lets this rule inspect the actual HTML expression.\n          JSXAttribute(node) {\n            if (!isJsxIdentifier(node.name, \"dangerouslySetInnerHTML\")) {\n              return;\n            }\n            const value = node.value;\n            if (value?.type !== \"JSXExpressionContainer\") {\n              return;\n            }\n            if (!value.expression) {\n              return;\n            }\n            const expression = unwrapExpression(value.expression);\n            if (expression?.type === \"ObjectExpression\") {\n              reportPayloadSpreads(expression);\n              return;\n            }\n            reportIfUnsafe(value.expression);\n          },\n\n          // Sink 1: `dangerouslySetInnerHTML={{ __html: <expr> }}`.\n          Property(node) {\n            if (!isDangerouslySetInnerHtmlValue(node)) {\n              return;\n            }\n            reportIfUnsafe(node.value);\n          },\n\n          // Sink 2: `<el>.innerHTML = <expr>` (non-computed member LHS).\n          AssignmentExpression(node) {\n            const target = node.left;\n            if (\n              target.type !== \"MemberExpression\" ||\n              target.computed !== false ||\n              !isIdentifier(target.property, \"innerHTML\")\n            ) {\n              return;\n            }\n            reportIfUnsafe(node.right);\n          },\n        };\n      },\n    },\n  },\n});\n"],"mappings":"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"}

package/dist/no-unsafe-inner-html.d.cts

@@ -0,0 +1,4 @@
+//#region src/no-unsafe-inner-html.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+export = _default;
+//# sourceMappingURL=no-unsafe-inner-html.d.cts.map

package/dist/no-unsafe-inner-html.d.mts

@@ -0,0 +1,5 @@
+//#region src/no-unsafe-inner-html.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=no-unsafe-inner-html.d.mts.map

package/dist/no-unsafe-inner-html.mjs

@@ -0,0 +1,119 @@
+import { i as unwrapExpression, n as getPropertyName, r as isIdentifier, t as getCalleeName } from "./utils.mjs";
+import { eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/no-unsafe-inner-html.ts
+const HTML_SANITIZER_LEAF_RE = /^(?:escape(?:html|xml)|sanitize(?:html|dom)|purify(?:html|dom)|dompurify)$/iu;
+const DOM_PURIFY_RE = /^dompurify$/iu;
+const SANITIZER_RESULT_MEMBERS = /* @__PURE__ */ new Set([
+	"value",
+	"data",
+	"html"
+]);
+const ESCAPE_HATCH_RE = /^\s*safe-html:/u;
+const isComment = (value) => typeof value === "object" && value !== null && typeof value.value === "string" && typeof value.loc === "object" && value.loc !== null;
+const isJsxIdentifier = (node, name) => typeof node === "object" && node !== null && node.type === "JSXIdentifier" && node.name === name;
+const isHtmlSanitizerCalleeName = (dotted) => {
+	const parts = dotted.split(".");
+	const leaf = parts.at(-1);
+	if (leaf === void 0) return false;
+	if (HTML_SANITIZER_LEAF_RE.test(leaf)) return true;
+	const objectName = parts.at(-2);
+	return leaf === "sanitize" && DOM_PURIFY_RE.test(objectName ?? "");
+};
+const isSanitizerCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	const dotted = getCalleeName(node.callee);
+	return dotted !== null && isHtmlSanitizerCalleeName(dotted);
+};
+const isProvenSafeValue = (node) => {
+	if (!node || typeof node.type !== "string") return false;
+	if (node.type === "Literal" && typeof node.value === "string") return true;
+	if (node.type === "TemplateLiteral") return Array.isArray(node.expressions) && node.expressions.every(isProvenSafeValue);
+	if (isSanitizerCall(node)) return true;
+	if (node.type === "MemberExpression" && node.computed === false && isProvenSafeMemberLeaf(node)) return true;
+	return false;
+};
+const isProvenSafeMemberLeaf = (node) => {
+	const propertyName = getPropertyName(node.property);
+	if (propertyName === null || !SANITIZER_RESULT_MEMBERS.has(propertyName)) return false;
+	return isSanitizerCall(node.object);
+};
+const isDangerouslySetInnerHtmlValue = (property) => {
+	if (getPropertyName(property.key) !== "__html") return false;
+	const objectExpression = property.parent;
+	if (objectExpression?.type !== "ObjectExpression") return false;
+	let current = objectExpression.parent;
+	while (current?.type === "TSAsExpression" || current?.type === "TSSatisfiesExpression") current = current.parent;
+	if (current?.type !== "JSXExpressionContainer") return false;
+	const attribute = current.parent;
+	return attribute?.type === "JSXAttribute" && isJsxIdentifier(attribute.name, "dangerouslySetInnerHTML");
+};
+var no_unsafe_inner_html_default = eslintCompatPlugin({
+	meta: { name: "no-unsafe-inner-html" },
+	rules: { "no-unsafe-inner-html": {
+		meta: {
+			type: "problem",
+			messages: {
+				unsafeInnerHtml: "Raw HTML injected into the DOM must come from a provably sanitized/escaped value: a static string, an HTML/DOM sanitize/escape call (or its .value/.data/.html result). Wrap the value in a sanitizer, or add a `// safe-html: <reason naming the sanitizer/source>` comment on the line directly above if it is escaped at its source.",
+				unsafeInnerHtmlSpread: "Do not spread an object into dangerouslySetInnerHTML. Keep `__html` inline so this rule can prove the HTML value is sanitized or escaped."
+			}
+		},
+		createOnce(context) {
+			const escapeHatchLines = /* @__PURE__ */ new Set();
+			const recordEscapeHatches = (node) => {
+				const comments = node && Array.isArray(node.comments) ? node.comments.filter(isComment) : [];
+				for (const comment of comments) if (ESCAPE_HATCH_RE.test(comment.value)) escapeHatchLines.add(comment.loc.end.line);
+			};
+			const hasEscapeHatchAbove = (node) => escapeHatchLines.has(node.loc.start.line - 1);
+			const reportIfUnsafe = (node) => {
+				if (isProvenSafeValue(node)) return;
+				if (hasEscapeHatchAbove(node)) return;
+				context.report({
+					node,
+					messageId: "unsafeInnerHtml"
+				});
+			};
+			const reportPayloadSpreads = (objectNode) => {
+				for (const property of objectNode.properties) {
+					if (property?.type !== "SpreadElement") continue;
+					context.report({
+						node: property,
+						messageId: "unsafeInnerHtmlSpread"
+					});
+				}
+			};
+			return {
+				before() {
+					escapeHatchLines.clear();
+				},
+				Program(node) {
+					recordEscapeHatches(node);
+				},
+				JSXAttribute(node) {
+					if (!isJsxIdentifier(node.name, "dangerouslySetInnerHTML")) return;
+					const value = node.value;
+					if (value?.type !== "JSXExpressionContainer") return;
+					if (!value.expression) return;
+					const expression = unwrapExpression(value.expression);
+					if (expression?.type === "ObjectExpression") {
+						reportPayloadSpreads(expression);
+						return;
+					}
+					reportIfUnsafe(value.expression);
+				},
+				Property(node) {
+					if (!isDangerouslySetInnerHtmlValue(node)) return;
+					reportIfUnsafe(node.value);
+				},
+				AssignmentExpression(node) {
+					const target = node.left;
+					if (target.type !== "MemberExpression" || target.computed !== false || !isIdentifier(target.property, "innerHTML")) return;
+					reportIfUnsafe(node.right);
+				}
+			};
+		}
+	} }
+});
+//#endregion
+export { no_unsafe_inner_html_default as default };
+
+//# sourceMappingURL=no-unsafe-inner-html.mjs.map

package/dist/no-unsafe-inner-html.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsafe-inner-html.mjs","names":[],"sources":["../src/no-unsafe-inner-html.ts"],"sourcesContent":["import { eslintCompatPlugin } from \"@oxlint/plugins\";\n// Forbid injecting un-proven HTML into the DOM.\n//\n// Raw HTML may only reach the DOM from a value that is provably sanitized or\n// escaped. This precise guard can replace a blanket `react/no-danger` rule:\n// approved sanitizer calls remain usable while unescaped stored or user input\n// cannot flow into `__html` or `el.innerHTML` unnoticed.\n//\n// Two sinks share one allowlist:\n//   • JSX `__html` property of a `dangerouslySetInnerHTML` object literal\n//     (report on the value expression).\n//   • `AssignmentExpression` whose LHS is a non-computed `.innerHTML`\n//     MemberExpression (report on the RHS).\n//\n// A value is allowed when it is:\n//   • a string Literal or TemplateLiteral whose interpolations are all\n//     independently proven safe (static markup, no raw injection), OR\n//   • a CallExpression whose callee is an HTML/DOM sanitizer or escaper\n//     (`escapeHtml`, `escapeXml`, `sanitizeHtml`, `sanitizeDom`,\n//     `DOMPurify.sanitize`), including a `.value` / `.data` / `.html`-style\n//     member read OFF such a call (some sanitizers return `{ value }`), OR\n//   • carries an explicit `// safe-html:` escape-hatch comment on the line\n//     directly above the sink (loc adjacency, like suppression-hygiene.ts).\n//\n// A value is NOT auto-allowed just because the identifier is named\n// `html` / `content` / `headline` / `body` — those are the sinks, not\n// proof of safety. Prove safety at the source or annotate with a reason.\n//\n// Flagged:\n//   <div dangerouslySetInnerHTML={{ __html: userInput }} />\n//   <div dangerouslySetInnerHTML={{ __html: hit.headline }} />   // unless annotated\n//   el.innerHTML = html;                                         // unless annotated\n//   el.innerHTML = data.body;\n//\n// Allowed:\n//   <div dangerouslySetInnerHTML={{ __html: sanitizeHtml(x) }} />\n//   <div dangerouslySetInnerHTML={{ __html: `<b>${escapeXml(n)}</b>` }} />\n//   <div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(x) }} />\n//   el.innerHTML = \"\";\n//   el.innerHTML = \"&nbsp;\";\n//   // safe-html: escaped by escapeAndHighlight()\n//   <div dangerouslySetInnerHTML={{ __html: hit.headline }} />\n\nimport {\n  getCalleeName,\n  getPropertyName,\n  isIdentifier,\n  unwrapExpression,\n} from \"./utils.ts\";\n\n// Callee names that prove the value was run through an HTML/DOM sanitizer or\n// escaper. Keep this narrow: `escapeRegex()` and `sanitizeFilename()` are not\n// HTML-safe.\nconst HTML_SANITIZER_LEAF_RE =\n  /^(?:escape(?:html|xml)|sanitize(?:html|dom)|purify(?:html|dom)|dompurify)$/iu;\n\nconst DOM_PURIFY_RE = /^dompurify$/iu;\n\n// Members that some sanitizers expose on their result object\n// (`sanitizeHtml(x).value`, `sanitizeHtml(x).html`). Reading one of these OFF a\n// sanitizer call is still proven-safe.\nconst SANITIZER_RESULT_MEMBERS = new Set([\"value\", \"data\", \"html\"]);\n\nconst ESCAPE_HATCH_RE = /^\\s*safe-html:/u;\n\nconst isComment = (value) =>\n  typeof value === \"object\" &&\n  value !== null &&\n  typeof value.value === \"string\" &&\n  typeof value.loc === \"object\" &&\n  value.loc !== null;\n\nconst isJsxIdentifier = (node, name) =>\n  typeof node === \"object\" &&\n  node !== null &&\n  node.type === \"JSXIdentifier\" &&\n  node.name === name;\n\nconst isHtmlSanitizerCalleeName = (dotted) => {\n  const parts = dotted.split(\".\");\n  const leaf = parts.at(-1);\n  if (leaf === undefined) {\n    return false;\n  }\n  if (HTML_SANITIZER_LEAF_RE.test(leaf)) {\n    return true;\n  }\n  const objectName = parts.at(-2);\n  return leaf === \"sanitize\" && DOM_PURIFY_RE.test(objectName ?? \"\");\n};\n\nconst isSanitizerCall = (node) => {\n  if (node.type !== \"CallExpression\") {\n    return false;\n  }\n  const dotted = getCalleeName(node.callee);\n  return dotted !== null && isHtmlSanitizerCalleeName(dotted);\n};\n\n// A value is proven safe by its own shape (independent of any comment):\n// static string, or the result of a sanitizer call (directly, or via a\n// `.value`/`.data`/`.html` accessor off the call).\nconst isProvenSafeValue = (node) => {\n  if (!node || typeof node.type !== \"string\") {\n    return false;\n  }\n  if (node.type === \"Literal\" && typeof node.value === \"string\") {\n    return true;\n  }\n  if (node.type === \"TemplateLiteral\") {\n    return (\n      Array.isArray(node.expressions) &&\n      node.expressions.every(isProvenSafeValue)\n    );\n  }\n  if (isSanitizerCall(node)) {\n    return true;\n  }\n  // `sanitize(x).value`, `purify(x).html` — a result accessor off a call.\n  if (\n    node.type === \"MemberExpression\" &&\n    node.computed === false &&\n    isProvenSafeMemberLeaf(node)\n  ) {\n    return true;\n  }\n  return false;\n};\n\nconst isProvenSafeMemberLeaf = (node) => {\n  const propertyName = getPropertyName(node.property);\n  if (propertyName === null || !SANITIZER_RESULT_MEMBERS.has(propertyName)) {\n    return false;\n  }\n  return isSanitizerCall(node.object);\n};\n\nconst isDangerouslySetInnerHtmlValue = (property) => {\n  if (getPropertyName(property.key) !== \"__html\") {\n    return false;\n  }\n  const objectExpression = property.parent;\n  if (objectExpression?.type !== \"ObjectExpression\") {\n    return false;\n  }\n\n  let current = objectExpression.parent;\n  while (\n    current?.type === \"TSAsExpression\" ||\n    current?.type === \"TSSatisfiesExpression\"\n  ) {\n    current = current.parent;\n  }\n\n  if (current?.type !== \"JSXExpressionContainer\") {\n    return false;\n  }\n  const attribute = current.parent;\n  return (\n    attribute?.type === \"JSXAttribute\" &&\n    isJsxIdentifier(attribute.name, \"dangerouslySetInnerHTML\")\n  );\n};\n\nexport default eslintCompatPlugin({\n  meta: { name: \"no-unsafe-inner-html\" },\n  rules: {\n    \"no-unsafe-inner-html\": {\n      meta: {\n        type: \"problem\",\n        messages: {\n          unsafeInnerHtml:\n            \"Raw HTML injected into the DOM must come from a provably \" +\n            \"sanitized/escaped value: a static string, an HTML/DOM \" +\n            \"sanitize/escape call (or its .value/.data/.html result). \" +\n            \"Wrap the value in a sanitizer, or add a `// safe-html: <reason \" +\n            \"naming the sanitizer/source>` comment on the line directly above \" +\n            \"if it is escaped at its source.\",\n          unsafeInnerHtmlSpread:\n            \"Do not spread an object into dangerouslySetInnerHTML. Keep \" +\n            \"`__html` inline so this rule can prove the HTML value is \" +\n            \"sanitized or escaped.\",\n        },\n      },\n      createOnce(context) {\n        const escapeHatchLines = new Set();\n\n        const recordEscapeHatches = (node) => {\n          const comments =\n            node && Array.isArray(node.comments)\n              ? node.comments.filter(isComment)\n              : [];\n          for (const comment of comments) {\n            if (ESCAPE_HATCH_RE.test(comment.value)) {\n              escapeHatchLines.add(comment.loc.end.line);\n            }\n          }\n        };\n\n        // The escape-hatch comment sits on the line directly above the\n        // reported node's first line. Sink expressions inside JSX object\n        // literals span multiple lines, so anchor on the node's start line.\n        const hasEscapeHatchAbove = (node) =>\n          escapeHatchLines.has(node.loc.start.line - 1);\n\n        const reportIfUnsafe = (node) => {\n          if (isProvenSafeValue(node)) {\n            return;\n          }\n          if (hasEscapeHatchAbove(node)) {\n            return;\n          }\n          context.report({ node, messageId: \"unsafeInnerHtml\" });\n        };\n\n        const reportPayloadSpreads = (objectNode) => {\n          for (const property of objectNode.properties) {\n            if (property?.type !== \"SpreadElement\") {\n              continue;\n            }\n            context.report({\n              node: property,\n              messageId: \"unsafeInnerHtmlSpread\",\n            });\n          }\n        };\n\n        return {\n          before() {\n            escapeHatchLines.clear();\n          },\n          Program(node) {\n            recordEscapeHatches(node);\n          },\n\n          // Reject hoisted payloads such as\n          // `dangerouslySetInnerHTML={payload}`. Keeping the `__html` object\n          // inline lets this rule inspect the actual HTML expression.\n          JSXAttribute(node) {\n            if (!isJsxIdentifier(node.name, \"dangerouslySetInnerHTML\")) {\n              return;\n            }\n            const value = node.value;\n            if (value?.type !== \"JSXExpressionContainer\") {\n              return;\n            }\n            if (!value.expression) {\n              return;\n            }\n            const expression = unwrapExpression(value.expression);\n            if (expression?.type === \"ObjectExpression\") {\n              reportPayloadSpreads(expression);\n              return;\n            }\n            reportIfUnsafe(value.expression);\n          },\n\n          // Sink 1: `dangerouslySetInnerHTML={{ __html: <expr> }}`.\n          Property(node) {\n            if (!isDangerouslySetInnerHtmlValue(node)) {\n              return;\n            }\n            reportIfUnsafe(node.value);\n          },\n\n          // Sink 2: `<el>.innerHTML = <expr>` (non-computed member LHS).\n          AssignmentExpression(node) {\n            const target = node.left;\n            if (\n              target.type !== \"MemberExpression\" ||\n              target.computed !== false ||\n              !isIdentifier(target.property, \"innerHTML\")\n            ) {\n              return;\n            }\n            reportIfUnsafe(node.right);\n          },\n        };\n      },\n    },\n  },\n});\n"],"mappings":";;;AAqDA,MAAM,yBACJ;AAEF,MAAM,gBAAgB;AAKtB,MAAM,2CAA2B,IAAI,IAAI;CAAC;CAAS;CAAQ;AAAM,CAAC;AAElE,MAAM,kBAAkB;AAExB,MAAM,aAAa,UACjB,OAAO,UAAU,YACjB,UAAU,QACV,OAAO,MAAM,UAAU,YACvB,OAAO,MAAM,QAAQ,YACrB,MAAM,QAAQ;AAEhB,MAAM,mBAAmB,MAAM,SAC7B,OAAO,SAAS,YAChB,SAAS,QACT,KAAK,SAAS,mBACd,KAAK,SAAS;AAEhB,MAAM,6BAA6B,WAAW;CAC5C,MAAM,QAAQ,OAAO,MAAM,GAAG;CAC9B,MAAM,OAAO,MAAM,GAAG,EAAE;CACxB,IAAI,SAAS,KAAA,GACX,OAAO;CAET,IAAI,uBAAuB,KAAK,IAAI,GAClC,OAAO;CAET,MAAM,aAAa,MAAM,GAAG,EAAE;CAC9B,OAAO,SAAS,cAAc,cAAc,KAAK,cAAc,EAAE;AACnE;AAEA,MAAM,mBAAmB,SAAS;CAChC,IAAI,KAAK,SAAS,kBAChB,OAAO;CAET,MAAM,SAAS,cAAc,KAAK,MAAM;CACxC,OAAO,WAAW,QAAQ,0BAA0B,MAAM;AAC5D;AAKA,MAAM,qBAAqB,SAAS;CAClC,IAAI,CAAC,QAAQ,OAAO,KAAK,SAAS,UAChC,OAAO;CAET,IAAI,KAAK,SAAS,aAAa,OAAO,KAAK,UAAU,UACnD,OAAO;CAET,IAAI,KAAK,SAAS,mBAChB,OACE,MAAM,QAAQ,KAAK,WAAW,KAC9B,KAAK,YAAY,MAAM,iBAAiB;CAG5C,IAAI,gBAAgB,IAAI,GACtB,OAAO;CAGT,IACE,KAAK,SAAS,sBACd,KAAK,aAAa,SAClB,uBAAuB,IAAI,GAE3B,OAAO;CAET,OAAO;AACT;AAEA,MAAM,0BAA0B,SAAS;CACvC,MAAM,eAAe,gBAAgB,KAAK,QAAQ;CAClD,IAAI,iBAAiB,QAAQ,CAAC,yBAAyB,IAAI,YAAY,GACrE,OAAO;CAET,OAAO,gBAAgB,KAAK,MAAM;AACpC;AAEA,MAAM,kCAAkC,aAAa;CACnD,IAAI,gBAAgB,SAAS,GAAG,MAAM,UACpC,OAAO;CAET,MAAM,mBAAmB,SAAS;CAClC,IAAI,kBAAkB,SAAS,oBAC7B,OAAO;CAGT,IAAI,UAAU,iBAAiB;CAC/B,OACE,SAAS,SAAS,oBAClB,SAAS,SAAS,yBAElB,UAAU,QAAQ;CAGpB,IAAI,SAAS,SAAS,0BACpB,OAAO;CAET,MAAM,YAAY,QAAQ;CAC1B,OACE,WAAW,SAAS,kBACpB,gBAAgB,UAAU,MAAM,yBAAyB;AAE7D;AAEA,IAAA,+BAAe,mBAAmB;CAChC,MAAM,EAAE,MAAM,uBAAuB;CACrC,OAAO,EACL,wBAAwB;EACtB,MAAM;GACJ,MAAM;GACN,UAAU;IACR,iBACE;IAMF,uBACE;GAGJ;EACF;EACA,WAAW,SAAS;GAClB,MAAM,mCAAmB,IAAI,IAAI;GAEjC,MAAM,uBAAuB,SAAS;IACpC,MAAM,WACJ,QAAQ,MAAM,QAAQ,KAAK,QAAQ,IAC/B,KAAK,SAAS,OAAO,SAAS,IAC9B,CAAC;IACP,KAAK,MAAM,WAAW,UACpB,IAAI,gBAAgB,KAAK,QAAQ,KAAK,GACpC,iBAAiB,IAAI,QAAQ,IAAI,IAAI,IAAI;GAG/C;GAKA,MAAM,uBAAuB,SAC3B,iBAAiB,IAAI,KAAK,IAAI,MAAM,OAAO,CAAC;GAE9C,MAAM,kBAAkB,SAAS;IAC/B,IAAI,kBAAkB,IAAI,GACxB;IAEF,IAAI,oBAAoB,IAAI,GAC1B;IAEF,QAAQ,OAAO;KAAE;KAAM,WAAW;IAAkB,CAAC;GACvD;GAEA,MAAM,wBAAwB,eAAe;IAC3C,KAAK,MAAM,YAAY,WAAW,YAAY;KAC5C,IAAI,UAAU,SAAS,iBACrB;KAEF,QAAQ,OAAO;MACb,MAAM;MACN,WAAW;KACb,CAAC;IACH;GACF;GAEA,OAAO;IACL,SAAS;KACP,iBAAiB,MAAM;IACzB;IACA,QAAQ,MAAM;KACZ,oBAAoB,IAAI;IAC1B;IAKA,aAAa,MAAM;KACjB,IAAI,CAAC,gBAAgB,KAAK,MAAM,yBAAyB,GACvD;KAEF,MAAM,QAAQ,KAAK;KACnB,IAAI,OAAO,SAAS,0BAClB;KAEF,IAAI,CAAC,MAAM,YACT;KAEF,MAAM,aAAa,iBAAiB,MAAM,UAAU;KACpD,IAAI,YAAY,SAAS,oBAAoB;MAC3C,qBAAqB,UAAU;MAC/B;KACF;KACA,eAAe,MAAM,UAAU;IACjC;IAGA,SAAS,MAAM;KACb,IAAI,CAAC,+BAA+B,IAAI,GACtC;KAEF,eAAe,KAAK,KAAK;IAC3B;IAGA,qBAAqB,MAAM;KACzB,MAAM,SAAS,KAAK;KACpB,IACE,OAAO,SAAS,sBAChB,OAAO,aAAa,SACpB,CAAC,aAAa,OAAO,UAAU,WAAW,GAE1C;KAEF,eAAe,KAAK,KAAK;IAC3B;GACF;EACF;CACF,EACF;AACF,CAAC"}

package/dist/utils.cjs

@@ -0,0 +1,54 @@
+//#region src/utils.ts
+const isAstNode = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && "range" in node;
+const isIdentifier = (node, name) => {
+	if (!isAstNode(node) || node.type !== "Identifier") return false;
+	if (typeof node.name !== "string") return false;
+	return name === void 0 || node.name === name;
+};
+const isStringLiteral = (node) => isAstNode(node) && node.type === "Literal" && typeof node.value === "string";
+const getPropertyName = (node) => {
+	if (isIdentifier(node)) return node.name;
+	if (isStringLiteral(node)) return node.value;
+	return null;
+};
+const getCalleeName = (callee) => {
+	if (isIdentifier(callee)) return callee.name;
+	if (!isAstNode(callee) || callee.type !== "MemberExpression") return null;
+	if (callee.computed !== false) return null;
+	const objectName = getCalleeName(callee.object);
+	const propertyName = getPropertyName(callee.property);
+	if (propertyName === null) return null;
+	return objectName === null ? propertyName : `${objectName}.${propertyName}`;
+};
+const unwrapExpression = (node) => {
+	if (!isAstNode(node)) return null;
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ChainExpression") return unwrapExpression(node.expression);
+	return node;
+};
+//#endregion
+Object.defineProperty(exports, "getCalleeName", {
+	enumerable: true,
+	get: function() {
+		return getCalleeName;
+	}
+});
+Object.defineProperty(exports, "getPropertyName", {
+	enumerable: true,
+	get: function() {
+		return getPropertyName;
+	}
+});
+Object.defineProperty(exports, "isIdentifier", {
+	enumerable: true,
+	get: function() {
+		return isIdentifier;
+	}
+});
+Object.defineProperty(exports, "unwrapExpression", {
+	enumerable: true,
+	get: function() {
+		return unwrapExpression;
+	}
+});
+
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["// Shared AST helpers for the rules in this folder.\n//\n// Oxlint plugin AST nodes are passed in untyped. Each helper narrows from\n// `unknown` so rule files can call them without per-call type ceremony or\n// shared type-import boilerplate.\n\nimport type { Ranged } from \"@oxlint/plugins\";\n\nexport type AstNode = Ranged & { type: string } & Record<string, unknown>;\n\ntype FilenameContext = {\n  filename?: string;\n  getFilename?: () => string;\n};\n\nexport const filenameForContext = (context: FilenameContext): string =>\n  (context.filename ?? context.getFilename?.() ?? \"\").replaceAll(\"\\\\\", \"/\");\n\nexport const isAstNode = (node: unknown): node is AstNode =>\n  typeof node === \"object\" &&\n  node !== null &&\n  \"type\" in node &&\n  typeof (node as { type: unknown }).type === \"string\" &&\n  \"range\" in node;\n\nexport const isIdentifier = (\n  node: unknown,\n  name?: string,\n): node is AstNode & { type: \"Identifier\"; name: string } => {\n  if (!isAstNode(node) || node.type !== \"Identifier\") {\n    return false;\n  }\n  if (typeof node.name !== \"string\") {\n    return false;\n  }\n  return name === undefined || node.name === name;\n};\n\nexport const isStringLiteral = (\n  node: unknown,\n): node is AstNode & { type: \"Literal\"; value: string } =>\n  isAstNode(node) && node.type === \"Literal\" && typeof node.value === \"string\";\n\n// Resolve the static name of a Property or MemberExpression key:\n// Identifier.name or string-Literal.value. Returns null for computed keys\n// driven by a non-literal expression.\nexport const getPropertyName = (node: unknown): string | null => {\n  if (isIdentifier(node)) {\n    return node.name;\n  }\n  if (isStringLiteral(node)) {\n    return node.value;\n  }\n  return null;\n};\n\n// Match `<object>.<property>` member access where both halves are\n// Identifiers and the access is not computed.\nexport const isMemberAccess = (\n  node: unknown,\n  object: string,\n  property: string,\n): boolean =>\n  isAstNode(node) &&\n  node.type === \"MemberExpression\" &&\n  node.computed === false &&\n  isIdentifier(node.object, object) &&\n  isIdentifier(node.property, property);\n\n// Match `CallExpression` whose callee is an Identifier with the given name.\nexport const isCallTo = (node: unknown, name: string): boolean =>\n  isAstNode(node) &&\n  node.type === \"CallExpression\" &&\n  isIdentifier(node.callee, name);\n\n// Resolve the dot-notation name of a callee: an Identifier, or a\n// non-computed MemberExpression chain (e.g. `t.String`, `Schema.is`,\n// `process.stderr.write`). Returns null when the chain is computed\n// or the property name itself can't be resolved.\n//\n// If the chain is rooted at a non-Identifier expression (e.g. `foo().bar`),\n// returns the bare property name (\"bar\") rather than null. Callers that\n// match the result against a fixed allowlist must consider whether they\n// need to distinguish `foo().createSafeHandler` from `createSafeHandler`.\nexport const getCalleeName = (callee: unknown): string | null => {\n  if (isIdentifier(callee)) {\n    return callee.name;\n  }\n  if (!isAstNode(callee) || callee.type !== \"MemberExpression\") {\n    return null;\n  }\n  if (callee.computed !== false) {\n    return null;\n  }\n  const objectName = getCalleeName(callee.object);\n  const propertyName = getPropertyName(callee.property);\n  if (propertyName === null) {\n    return null;\n  }\n  return objectName === null ? propertyName : `${objectName}.${propertyName}`;\n};\n\n// Peel TS-only wrapping nodes so a shape check sees the underlying\n// expression. Returns the original node when no wrapping is present.\nexport const unwrapExpression = (node: unknown): AstNode | null => {\n  if (!isAstNode(node)) {\n    return null;\n  }\n  if (\n    node.type === \"TSAsExpression\" ||\n    node.type === \"TSSatisfiesExpression\" ||\n    node.type === \"ChainExpression\"\n  ) {\n    return unwrapExpression(node.expression);\n  }\n  return node;\n};\n\n// Resolve an ImportSpecifier's imported binding name (Identifier.name or\n// string-Literal.value). Returns null when the specifier shape is unexpected.\nexport const getImportedName = (specifier: unknown): string | null => {\n  if (!isAstNode(specifier) || specifier.type !== \"ImportSpecifier\") {\n    return null;\n  }\n  const imported = specifier.imported;\n  if (isIdentifier(imported)) {\n    return imported.name;\n  }\n  if (isStringLiteral(imported)) {\n    return imported.value;\n  }\n  return null;\n};\n\n// Resolve an ImportSpecifier's local binding name. This differs from\n// getImportedName for aliased imports such as `import { source as local }`.\nexport const getImportLocalName = (specifier: unknown): string | null => {\n  if (!isAstNode(specifier) || specifier.type !== \"ImportSpecifier\") {\n    return null;\n  }\n  return isIdentifier(specifier.local) ? specifier.local.name : null;\n};\n"],"mappings":";AAkBA,MAAa,aAAa,SACxB,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,OAAQ,KAA2B,SAAS,YAC5C,WAAW;AAEb,MAAa,gBACX,MACA,SAC2D;CAC3D,IAAI,CAAC,UAAU,IAAI,KAAK,KAAK,SAAS,cACpC,OAAO;CAET,IAAI,OAAO,KAAK,SAAS,UACvB,OAAO;CAET,OAAO,SAAS,KAAA,KAAa,KAAK,SAAS;AAC7C;AAEA,MAAa,mBACX,SAEA,UAAU,IAAI,KAAK,KAAK,SAAS,aAAa,OAAO,KAAK,UAAU;AAKtE,MAAa,mBAAmB,SAAiC;CAC/D,IAAI,aAAa,IAAI,GACnB,OAAO,KAAK;CAEd,IAAI,gBAAgB,IAAI,GACtB,OAAO,KAAK;CAEd,OAAO;AACT;AA8BA,MAAa,iBAAiB,WAAmC;CAC/D,IAAI,aAAa,MAAM,GACrB,OAAO,OAAO;CAEhB,IAAI,CAAC,UAAU,MAAM,KAAK,OAAO,SAAS,oBACxC,OAAO;CAET,IAAI,OAAO,aAAa,OACtB,OAAO;CAET,MAAM,aAAa,cAAc,OAAO,MAAM;CAC9C,MAAM,eAAe,gBAAgB,OAAO,QAAQ;CACpD,IAAI,iBAAiB,MACnB,OAAO;CAET,OAAO,eAAe,OAAO,eAAe,GAAG,WAAW,GAAG;AAC/D;AAIA,MAAa,oBAAoB,SAAkC;CACjE,IAAI,CAAC,UAAU,IAAI,GACjB,OAAO;CAET,IACE,KAAK,SAAS,oBACd,KAAK,SAAS,2BACd,KAAK,SAAS,mBAEd,OAAO,iBAAiB,KAAK,UAAU;CAEzC,OAAO;AACT"}

package/dist/utils.mjs

@@ -0,0 +1,31 @@
+//#region src/utils.ts
+const isAstNode = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && "range" in node;
+const isIdentifier = (node, name) => {
+	if (!isAstNode(node) || node.type !== "Identifier") return false;
+	if (typeof node.name !== "string") return false;
+	return name === void 0 || node.name === name;
+};
+const isStringLiteral = (node) => isAstNode(node) && node.type === "Literal" && typeof node.value === "string";
+const getPropertyName = (node) => {
+	if (isIdentifier(node)) return node.name;
+	if (isStringLiteral(node)) return node.value;
+	return null;
+};
+const getCalleeName = (callee) => {
+	if (isIdentifier(callee)) return callee.name;
+	if (!isAstNode(callee) || callee.type !== "MemberExpression") return null;
+	if (callee.computed !== false) return null;
+	const objectName = getCalleeName(callee.object);
+	const propertyName = getPropertyName(callee.property);
+	if (propertyName === null) return null;
+	return objectName === null ? propertyName : `${objectName}.${propertyName}`;
+};
+const unwrapExpression = (node) => {
+	if (!isAstNode(node)) return null;
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ChainExpression") return unwrapExpression(node.expression);
+	return node;
+};
+//#endregion
+export { unwrapExpression as i, getPropertyName as n, isIdentifier as r, getCalleeName as t };
+
+//# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["// Shared AST helpers for the rules in this folder.\n//\n// Oxlint plugin AST nodes are passed in untyped. Each helper narrows from\n// `unknown` so rule files can call them without per-call type ceremony or\n// shared type-import boilerplate.\n\nimport type { Ranged } from \"@oxlint/plugins\";\n\nexport type AstNode = Ranged & { type: string } & Record<string, unknown>;\n\ntype FilenameContext = {\n  filename?: string;\n  getFilename?: () => string;\n};\n\nexport const filenameForContext = (context: FilenameContext): string =>\n  (context.filename ?? context.getFilename?.() ?? \"\").replaceAll(\"\\\\\", \"/\");\n\nexport const isAstNode = (node: unknown): node is AstNode =>\n  typeof node === \"object\" &&\n  node !== null &&\n  \"type\" in node &&\n  typeof (node as { type: unknown }).type === \"string\" &&\n  \"range\" in node;\n\nexport const isIdentifier = (\n  node: unknown,\n  name?: string,\n): node is AstNode & { type: \"Identifier\"; name: string } => {\n  if (!isAstNode(node) || node.type !== \"Identifier\") {\n    return false;\n  }\n  if (typeof node.name !== \"string\") {\n    return false;\n  }\n  return name === undefined || node.name === name;\n};\n\nexport const isStringLiteral = (\n  node: unknown,\n): node is AstNode & { type: \"Literal\"; value: string } =>\n  isAstNode(node) && node.type === \"Literal\" && typeof node.value === \"string\";\n\n// Resolve the static name of a Property or MemberExpression key:\n// Identifier.name or string-Literal.value. Returns null for computed keys\n// driven by a non-literal expression.\nexport const getPropertyName = (node: unknown): string | null => {\n  if (isIdentifier(node)) {\n    return node.name;\n  }\n  if (isStringLiteral(node)) {\n    return node.value;\n  }\n  return null;\n};\n\n// Match `<object>.<property>` member access where both halves are\n// Identifiers and the access is not computed.\nexport const isMemberAccess = (\n  node: unknown,\n  object: string,\n  property: string,\n): boolean =>\n  isAstNode(node) &&\n  node.type === \"MemberExpression\" &&\n  node.computed === false &&\n  isIdentifier(node.object, object) &&\n  isIdentifier(node.property, property);\n\n// Match `CallExpression` whose callee is an Identifier with the given name.\nexport const isCallTo = (node: unknown, name: string): boolean =>\n  isAstNode(node) &&\n  node.type === \"CallExpression\" &&\n  isIdentifier(node.callee, name);\n\n// Resolve the dot-notation name of a callee: an Identifier, or a\n// non-computed MemberExpression chain (e.g. `t.String`, `Schema.is`,\n// `process.stderr.write`). Returns null when the chain is computed\n// or the property name itself can't be resolved.\n//\n// If the chain is rooted at a non-Identifier expression (e.g. `foo().bar`),\n// returns the bare property name (\"bar\") rather than null. Callers that\n// match the result against a fixed allowlist must consider whether they\n// need to distinguish `foo().createSafeHandler` from `createSafeHandler`.\nexport const getCalleeName = (callee: unknown): string | null => {\n  if (isIdentifier(callee)) {\n    return callee.name;\n  }\n  if (!isAstNode(callee) || callee.type !== \"MemberExpression\") {\n    return null;\n  }\n  if (callee.computed !== false) {\n    return null;\n  }\n  const objectName = getCalleeName(callee.object);\n  const propertyName = getPropertyName(callee.property);\n  if (propertyName === null) {\n    return null;\n  }\n  return objectName === null ? propertyName : `${objectName}.${propertyName}`;\n};\n\n// Peel TS-only wrapping nodes so a shape check sees the underlying\n// expression. Returns the original node when no wrapping is present.\nexport const unwrapExpression = (node: unknown): AstNode | null => {\n  if (!isAstNode(node)) {\n    return null;\n  }\n  if (\n    node.type === \"TSAsExpression\" ||\n    node.type === \"TSSatisfiesExpression\" ||\n    node.type === \"ChainExpression\"\n  ) {\n    return unwrapExpression(node.expression);\n  }\n  return node;\n};\n\n// Resolve an ImportSpecifier's imported binding name (Identifier.name or\n// string-Literal.value). Returns null when the specifier shape is unexpected.\nexport const getImportedName = (specifier: unknown): string | null => {\n  if (!isAstNode(specifier) || specifier.type !== \"ImportSpecifier\") {\n    return null;\n  }\n  const imported = specifier.imported;\n  if (isIdentifier(imported)) {\n    return imported.name;\n  }\n  if (isStringLiteral(imported)) {\n    return imported.value;\n  }\n  return null;\n};\n\n// Resolve an ImportSpecifier's local binding name. This differs from\n// getImportedName for aliased imports such as `import { source as local }`.\nexport const getImportLocalName = (specifier: unknown): string | null => {\n  if (!isAstNode(specifier) || specifier.type !== \"ImportSpecifier\") {\n    return null;\n  }\n  return isIdentifier(specifier.local) ? specifier.local.name : null;\n};\n"],"mappings":";AAkBA,MAAa,aAAa,SACxB,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,OAAQ,KAA2B,SAAS,YAC5C,WAAW;AAEb,MAAa,gBACX,MACA,SAC2D;CAC3D,IAAI,CAAC,UAAU,IAAI,KAAK,KAAK,SAAS,cACpC,OAAO;CAET,IAAI,OAAO,KAAK,SAAS,UACvB,OAAO;CAET,OAAO,SAAS,KAAA,KAAa,KAAK,SAAS;AAC7C;AAEA,MAAa,mBACX,SAEA,UAAU,IAAI,KAAK,KAAK,SAAS,aAAa,OAAO,KAAK,UAAU;AAKtE,MAAa,mBAAmB,SAAiC;CAC/D,IAAI,aAAa,IAAI,GACnB,OAAO,KAAK;CAEd,IAAI,gBAAgB,IAAI,GACtB,OAAO,KAAK;CAEd,OAAO;AACT;AA8BA,MAAa,iBAAiB,WAAmC;CAC/D,IAAI,aAAa,MAAM,GACrB,OAAO,OAAO;CAEhB,IAAI,CAAC,UAAU,MAAM,KAAK,OAAO,SAAS,oBACxC,OAAO;CAET,IAAI,OAAO,aAAa,OACtB,OAAO;CAET,MAAM,aAAa,cAAc,OAAO,MAAM;CAC9C,MAAM,eAAe,gBAAgB,OAAO,QAAQ;CACpD,IAAI,iBAAiB,MACnB,OAAO;CAET,OAAO,eAAe,OAAO,eAAe,GAAG,WAAW,GAAG;AAC/D;AAIA,MAAa,oBAAoB,SAAkC;CACjE,IAAI,CAAC,UAAU,IAAI,GACjB,OAAO;CAET,IACE,KAAK,SAAS,oBACd,KAAK,SAAS,2BACd,KAAK,SAAS,mBAEd,OAAO,iBAAiB,KAAK,UAAU;CAEzC,OAAO;AACT"}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@stll/oxlint-plugin",
+  "version": "0.0.1-placeholder.0",
+  "description": "Portable static-safety rules for Oxlint consumers.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stella/tooling.git",
+    "directory": "packages/oxlint-plugin"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": "./dist/index.mjs"
+    },
+    "./no-any-casts": {
+      "import": {
+        "types": "./dist/no-any-casts.d.mts",
+        "default": "./dist/no-any-casts.mjs"
+      },
+      "require": {
+        "types": "./dist/no-any-casts.d.cts",
+        "default": "./dist/no-any-casts.cjs"
+      },
+      "default": "./dist/no-any-casts.mjs"
+    },
+    "./no-dangerous-type-assertions": {
+      "import": {
+        "types": "./dist/no-dangerous-type-assertions.d.mts",
+        "default": "./dist/no-dangerous-type-assertions.mjs"
+      },
+      "require": {
+        "types": "./dist/no-dangerous-type-assertions.d.cts",
+        "default": "./dist/no-dangerous-type-assertions.cjs"
+      },
+      "default": "./dist/no-dangerous-type-assertions.mjs"
+    },
+    "./no-partial-record-satisfies": {
+      "import": {
+        "types": "./dist/no-partial-record-satisfies.d.mts",
+        "default": "./dist/no-partial-record-satisfies.mjs"
+      },
+      "require": {
+        "types": "./dist/no-partial-record-satisfies.d.cts",
+        "default": "./dist/no-partial-record-satisfies.cjs"
+      },
+      "default": "./dist/no-partial-record-satisfies.mjs"
+    },
+    "./no-unsafe-inner-html": {
+      "import": {
+        "types": "./dist/no-unsafe-inner-html.d.mts",
+        "default": "./dist/no-unsafe-inner-html.mjs"
+      },
+      "require": {
+        "types": "./dist/no-unsafe-inner-html.d.cts",
+        "default": "./dist/no-unsafe-inner-html.cjs"
+      },
+      "default": "./dist/no-unsafe-inner-html.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "format": "oxfmt ."
+  },
+  "devDependencies": {
+    "@oxlint/plugins": "1.75.0",
+    "@stll/typescript-config": "workspace:*",
+    "oxfmt": "0.48.0",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "@oxlint/plugins": ">=1.75.0 <2",
+    "oxlint": ">=1.75.0 <2"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  }
+}