@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_unicorn_prevent_abbreviations.go

@@ -0,0 +1,127 @@
+// unicorn/prevent-abbreviations: abbreviated identifier names (`err`,
+// `cb`, `ctx`, `idx`) are a project-wide readability tax — every
+// reader has to expand the shorthand mentally on the spot. The
+// upstream rule maintains a large allowlist + replacements map; this
+// MVP carries the most universal abbreviations only and fires on any
+// identifier whose lower-cased text matches one of them, in both
+// reference and declaration positions, so a `param` parameter and a
+// `void param` read are both reported.
+//
+// AST-only: visit every `Identifier`, lowercase the lexeme, look it up
+// in `unicornPreventAbbreviationsDictionary`. No scope analysis is
+// performed because the rule's diagnostic is about the *name*, not the
+// binding — every occurrence of `idx` is equally noisy.
+//
+// Hot-path budget: `KindIdentifier` is the most frequent AST kind in
+// any TypeScript program, so this Check is invoked tens-of-thousands
+// of times per file. A length pre-filter eliminates ~90 % of inputs
+// without touching memory (the longest dictionary entry is six
+// characters); an additional `isAllLowerASCII` check skips
+// `strings.ToLower`'s allocation for the common case of already-
+// lower-cased identifiers.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prevent-abbreviations.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// unicornPreventAbbreviationsDictionary is the MVP allowlist of
+// abbreviations that fire the rule. Lower-cased keys; the rule
+// case-folds the identifier before lookup. Intentionally conservative
+// — picks the abbreviations universally agreed across upstream
+// presets so the rule doesn't flap on neutral words.
+var unicornPreventAbbreviationsDictionary = map[string]struct{}{
+	"arr":    {},
+	"args":   {},
+	"attr":   {},
+	"btn":    {},
+	"cb":     {},
+	"cmd":    {},
+	"ctx":    {},
+	"db":     {},
+	"dest":   {},
+	"dir":    {},
+	"doc":    {},
+	"el":     {},
+	"elem":   {},
+	"env":    {},
+	"err":    {},
+	"evt":    {},
+	"fn":     {},
+	"func":   {},
+	"idx":    {},
+	"len":    {},
+	"lib":    {},
+	"mgr":    {},
+	"mod":    {},
+	"msg":    {},
+	"num":    {},
+	"obj":    {},
+	"opts":   {},
+	"param":  {},
+	"params": {},
+	"pkg":    {},
+	"prev":   {},
+	"prop":   {},
+	"props":  {},
+	"ref":    {},
+	"res":    {},
+	"ret":    {},
+	"src":    {},
+	"str":    {},
+	"tmp":    {},
+	"val":    {},
+	"var":    {},
+}
+
+// unicornPreventAbbreviationsMaxLen is the longest dictionary key
+// length. Any identifier longer than this cannot match — the Check
+// returns immediately without touching the dictionary.
+const unicornPreventAbbreviationsMaxLen = 6
+
+type unicornPreventAbbreviations struct{}
+
+func (unicornPreventAbbreviations) Name() string { return "unicorn/prevent-abbreviations" }
+func (unicornPreventAbbreviations) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornPreventAbbreviations) Check(ctx *Context, node *shimast.Node) {
+	name := identifierText(node)
+	if name == "" || len(name) > unicornPreventAbbreviationsMaxLen {
+		return
+	}
+	// Fast path: dictionary keys are pre-lowercased, so an
+	// already-lower-case identifier avoids `strings.ToLower`'s
+	// allocation entirely. The Check is invoked once per identifier
+	// in the file, so the saved allocations multiply.
+	lookup := name
+	if !isAllLowerASCII(name) {
+		lookup = strings.ToLower(name)
+	}
+	if _, ok := unicornPreventAbbreviationsDictionary[lookup]; !ok {
+		return
+	}
+	ctx.Report(node, "Prefer the long form over abbreviated identifiers (e.g. `error` over `err`).")
+}
+
+// isAllLowerASCII reports whether `s` is a non-empty ASCII string
+// whose every byte is a lower-case letter. Used by hot-path Checks
+// that look up an already-normalized dictionary — the result is
+// equivalent to `s == strings.ToLower(s)` for all-ASCII inputs but
+// avoids the lowercase allocation.
+func isAllLowerASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= 'A' && c <= 'Z' {
+			return false
+		}
+	}
+	return true
+}
+
+func init() {
+	Register(unicornPreventAbbreviations{})
+}

package/linthost/rules_unicorn_relative_url_style.go

@@ -0,0 +1,49 @@
+// unicorn/relative-url-style: `new URL("./foo", base)` and
+// `new URL("foo", base)` resolve identically, so the leading `./` is
+// noise. The rule normalizes on the "never leading `./`" style and
+// fires whenever a `new URL(…)` literal first argument starts with
+// `./`.
+//
+// AST-only: visit `KindNewExpression`, accept when the callee is the
+// bare `URL` identifier, and inspect the first argument — when it's a
+// string-shaped literal whose text starts with `./`, report the
+// argument node. Absolute URLs (`http://…`), schemeless protocol
+// references, and paths starting with `/` or `../` are untouched; only
+// the explicit `./` prefix is the redundant case the rule targets.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/relative-url-style.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornRelativeURLStyle struct{}
+
+func (unicornRelativeURLStyle) Name() string { return "unicorn/relative-url-style" }
+func (unicornRelativeURLStyle) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornRelativeURLStyle) Check(ctx *Context, node *shimast.Node) {
+	expr := node.AsNewExpression()
+	if expr == nil || identifierText(expr.Expression) != "URL" {
+		return
+	}
+	if expr.Arguments == nil || len(expr.Arguments.Nodes) == 0 {
+		return
+	}
+	arg := expr.Arguments.Nodes[0]
+	text := stringLiteralText(arg)
+	if text == "" {
+		return
+	}
+	if strings.HasPrefix(text, "./") {
+		ctx.Report(arg, "Drop the leading `./` from relative URLs passed to `new URL`.")
+	}
+}
+
+func init() {
+	Register(unicornRelativeURLStyle{})
+}

package/linthost/rules_unicorn_require_array_join_separator.go

@@ -0,0 +1,45 @@
+// unicorn/require-array-join-separator: `Array#join()` defaults its
+// separator to a comma when called with no arguments. Authors rarely
+// mean to rely on that — the implicit separator is locale-flavored in
+// related APIs (`Intl.ListFormat`) and the comma default is one of the
+// quieter sources of "why is this comma here?" diffs. The rule pushes
+// every call site to spell out the separator so the intent is in the
+// source.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.join` shape, and report when the call carries zero arguments. Any
+// explicit argument — empty string included — passes.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-array-join-separator.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireArrayJoinSeparator struct{}
+
+func (unicornRequireArrayJoinSeparator) Name() string {
+	return "unicorn/require-array-join-separator"
+}
+func (unicornRequireArrayJoinSeparator) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequireArrayJoinSeparator) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "join" {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+		return
+	}
+	ctx.Report(node, "Pass an explicit separator argument to `Array#join()`.")
+}
+
+func init() {
+	Register(unicornRequireArrayJoinSeparator{})
+}

package/linthost/rules_unicorn_require_module_attributes.go

@@ -0,0 +1,54 @@
+// unicorn/require-module-attributes: import / export `with { … }`
+// clauses carry semantic information (`type: "json"`, `type: "css"`).
+// Writing `with {}` with no entries serves no purpose and is almost
+// always a mistake. The rule fires when an import or export carries an
+// attributes clause with zero attribute entries.
+//
+// AST-only: visit `KindImportDeclaration` and `KindExportDeclaration`,
+// follow the `.Attributes` field (an `ImportAttributesNode`), descend
+// into its inner `ImportAttributes.Attributes` list, and report when
+// the list is present but empty. The clause-present-but-empty shape is
+// rare in practice but legal syntax, so a precise zero-entry check is
+// the right anchor.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-module-attributes.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireModuleAttributes struct{}
+
+func (unicornRequireModuleAttributes) Name() string {
+	return "unicorn/require-module-attributes"
+}
+func (unicornRequireModuleAttributes) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+}
+func (unicornRequireModuleAttributes) Check(ctx *Context, node *shimast.Node) {
+	var attrs *shimast.Node
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		if decl := node.AsImportDeclaration(); decl != nil {
+			attrs = decl.Attributes
+		}
+	case shimast.KindExportDeclaration:
+		if decl := node.AsExportDeclaration(); decl != nil {
+			attrs = decl.Attributes
+		}
+	}
+	if attrs == nil {
+		return
+	}
+	imp := attrs.AsImportAttributes()
+	if imp == nil {
+		return
+	}
+	if imp.Attributes != nil && len(imp.Attributes.Nodes) > 0 {
+		return
+	}
+	ctx.Report(node, "Import/export `with {}` should have at least one attribute.")
+}
+
+func init() {
+	Register(unicornRequireModuleAttributes{})
+}

package/linthost/rules_unicorn_require_module_specifiers.go

@@ -0,0 +1,55 @@
+// unicorn/require-module-specifiers: an `import "x"` with no bindings
+// or an `export {} from "x"` declares the module dependency without
+// pulling anything from it; both shapes are almost always either dead
+// imports left over from a refactor or accidental side-effect imports
+// that the author meant to bind. The rule asks for an explicit specifier
+// list so the dependency makes its purpose visible in the source.
+//
+// AST-only: visit every `ImportDeclaration` and `ExportDeclaration`.
+// Import side fires when the declaration has no `ImportClause` at all
+// (the side-effect form). Export side fires when the declaration has an
+// empty NamedExports `{}` (with or without a `from`).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-module-specifiers.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireModuleSpecifiers struct{}
+
+func (unicornRequireModuleSpecifiers) Name() string {
+	return "unicorn/require-module-specifiers"
+}
+func (unicornRequireModuleSpecifiers) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+}
+func (unicornRequireModuleSpecifiers) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		decl := node.AsImportDeclaration()
+		if decl == nil {
+			return
+		}
+		// `import "x"` parses with a nil ImportClause; any binding shape
+		// (`import x`, `import {a}`, `import * as ns`) installs a clause.
+		if decl.ImportClause == nil {
+			ctx.Report(node, "Empty import/export specifier list is not allowed.")
+		}
+	case shimast.KindExportDeclaration:
+		decl := node.AsExportDeclaration()
+		if decl == nil || decl.ExportClause == nil {
+			return
+		}
+		if decl.ExportClause.Kind != shimast.KindNamedExports {
+			return
+		}
+		named := decl.ExportClause.AsNamedExports()
+		if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+			return
+		}
+		ctx.Report(node, "Empty import/export specifier list is not allowed.")
+	}
+}
+
+func init() {
+	Register(unicornRequireModuleSpecifiers{})
+}

package/linthost/rules_unicorn_require_number_to_fixed_digits_argument.go

@@ -0,0 +1,43 @@
+// unicorn/require-number-to-fixed-digits-argument: `Number#toFixed()`
+// with no argument is equivalent to `.toFixed(0)`, which rounds away
+// every fractional digit. Authors almost always mean a non-zero digit
+// count, and the no-arg form is one of the more common silent
+// truncation bugs. The rule asks every call site to spell out the digit
+// count.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.toFixed` shape, and report when the call carries zero arguments.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-number-to-fixed-digits-argument.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireNumberToFixedDigitsArgument struct{}
+
+func (unicornRequireNumberToFixedDigitsArgument) Name() string {
+	return "unicorn/require-number-to-fixed-digits-argument"
+}
+func (unicornRequireNumberToFixedDigitsArgument) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequireNumberToFixedDigitsArgument) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "toFixed" {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+		return
+	}
+	ctx.Report(node, "Pass an explicit digits argument to `Number#toFixed()`.")
+}
+
+func init() {
+	Register(unicornRequireNumberToFixedDigitsArgument{})
+}

package/linthost/rules_unicorn_require_post_message_target_origin.go

@@ -0,0 +1,44 @@
+// unicorn/require-post-message-target-origin: `Window#postMessage` and
+// `Worker#postMessage` take a `targetOrigin` (or `transfer`) argument
+// that scopes which document/worker may receive the message. Omitting
+// it defaults to the receiver's own origin, which is a quiet security
+// footgun — cross-origin frames silently lose the message. The rule
+// asks every call site to pass an explicit second argument.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.postMessage` shape, and report when the call carries exactly one
+// argument (the message payload, with no targetOrigin to follow).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-post-message-target-origin.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequirePostMessageTargetOrigin struct{}
+
+func (unicornRequirePostMessageTargetOrigin) Name() string {
+	return "unicorn/require-post-message-target-origin"
+}
+func (unicornRequirePostMessageTargetOrigin) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequirePostMessageTargetOrigin) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "postMessage" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	ctx.Report(node, "Pass an explicit `targetOrigin` argument to `postMessage`.")
+}
+
+func init() {
+	Register(unicornRequirePostMessageTargetOrigin{})
+}

package/linthost/rules_unicorn_string_content.go

@@ -0,0 +1,27 @@
+// unicorn/string-content: rewrites configured substrings inside string
+// literals (e.g. straight quotes -> curly quotes, `...` -> `…`). The
+// rule has NO defaults; behavior depends entirely on the user-supplied
+// `patterns: { match: replacement }` configuration. Without that
+// per-pattern configuration plumbing in the host's rule-options
+// pipeline, the rule has nothing to enforce.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-string-content.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/string-content.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornStringContent struct{}
+
+func (unicornStringContent) Name() string           { return "unicorn/string-content" }
+func (unicornStringContent) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornStringContent) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+	Register(unicornStringContent{})
+}

package/linthost/rules_unicorn_switch_case_braces.go

@@ -0,0 +1,42 @@
+// unicorn/switch-case-braces: `case` and `default` clauses share their
+// parent switch's scope, so an unbraced `case x: let y = …;` leaks `y`
+// into every subsequent case. The default-on "always" mode of this rule
+// requires every clause body to be a single `{ … }` block, which both
+// scopes declarations and visually delimits clause bodies.
+//
+// AST-only: visit each `CaseClause` and `DefaultClause` and report when
+// the clause's statements list is anything other than exactly one
+// `Block`. Empty fall-through clauses (`case "a":` with no statements)
+// also fire — the rule's "always" mode wants the brace pair even when
+// the body is empty.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/switch-case-braces.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornSwitchCaseBraces struct{}
+
+func (unicornSwitchCaseBraces) Name() string { return "unicorn/switch-case-braces" }
+func (unicornSwitchCaseBraces) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
+}
+func (unicornSwitchCaseBraces) Check(ctx *Context, node *shimast.Node) {
+	clause := node.AsCaseOrDefaultClause()
+	if clause == nil || clause.Statements == nil {
+		return
+	}
+	stmts := clause.Statements.Nodes
+	if len(stmts) == 0 {
+		// Empty fall-through (`case "a":` followed immediately by another
+		// clause) is not the "missing braces" shape the rule targets.
+		return
+	}
+	if len(stmts) == 1 && stmts[0] != nil && stmts[0].Kind == shimast.KindBlock {
+		return
+	}
+	ctx.Report(node, "Wrap `case` clause body in a block (`case x: { ... }`).")
+}
+
+func init() {
+	Register(unicornSwitchCaseBraces{})
+}

package/linthost/rules_unicorn_switch_case_break_position.go

@@ -0,0 +1,31 @@
+// unicorn/switch-case-break-position: the upstream rule rejects a
+// `break` / `return` / `throw` that is followed by further statements
+// inside the same `case` / `default` clause, because the trailing
+// statements are dead code.
+//
+// In a well-formed TypeScript program the TypeScript-Go checker already
+// emits an `unreachable code` diagnostic for statements following a
+// terminator, so this AST-only port would either duplicate that
+// diagnostic (when reused as an MVP) or need scope/CFG analysis to
+// reproduce the exact upstream surface. The rule is registered as a
+// no-op until a follow-up exposes the unreachable-statement metadata
+// the checker computes for switch clauses.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/switch-case-break-position.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornSwitchCaseBreakPosition struct{}
+
+func (unicornSwitchCaseBreakPosition) Name() string {
+	return "unicorn/switch-case-break-position"
+}
+func (unicornSwitchCaseBreakPosition) Visits() []shimast.Kind { return nil }
+func (unicornSwitchCaseBreakPosition) Check(*Context, *shimast.Node) {
+	// Intentionally empty; see file-level comment.
+}
+
+func init() {
+	Register(unicornSwitchCaseBreakPosition{})
+}

package/linthost/rules_unicorn_template_indent.go

@@ -0,0 +1,28 @@
+// unicorn/template-indent: re-indents the contents of tagged template
+// literals (`outdent`, `dedent`, `stripIndent`, etc.) so the inner text
+// is column-aligned with the surrounding code. The autofix has to
+// detect the common leading-whitespace prefix of every line in the
+// template body, decide what the desired indent level is from the
+// template's own column, then rewrite every interior line — substantial
+// whitespace analysis well beyond a pattern match.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-template-indent.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/template-indent.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornTemplateIndent struct{}
+
+func (unicornTemplateIndent) Name() string           { return "unicorn/template-indent" }
+func (unicornTemplateIndent) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornTemplateIndent) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+	Register(unicornTemplateIndent{})
+}

package/linthost/rules_unicorn_text_encoding_identifier_case.go

@@ -0,0 +1,72 @@
+// unicorn/text-encoding-identifier-case: the IANA text-encoding labels
+// `UTF-8`, `utf8`, `ASCII`, etc. all resolve to the same encoding in
+// browsers and Node, but the surrounding ecosystem (HTTP headers,
+// `TextDecoder`, file APIs) varies on which spelling it echoes back.
+// Picking one canonical form per encoding makes string-equality checks
+// against those echoes stable. The rule asks every encoding-shaped
+// literal to use the canonical lowercase, hyphenated form.
+//
+// AST-only: visit `StringLiteral` and `NoSubstitutionTemplateLiteral`
+// nodes. The literal's lowercased text is matched against the well-known
+// encoding identifiers; a mismatch with the canonical form (the same
+// identifier already in canonical case) fires the rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/text-encoding-identifier-case.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornTextEncodingIdentifierCase struct{}
+
+// unicornCanonicalTextEncodings maps the lowercased label to its canonical
+// spelling. Authors who already wrote the canonical form pass; anything
+// else with the same lowercased label fires.
+var unicornCanonicalTextEncodings = map[string]string{
+	"utf-8":        "utf-8",
+	"utf-16le":     "utf-16le",
+	"utf-16be":     "utf-16be",
+	"ascii":        "ascii",
+	"latin1":       "latin1",
+	"iso-8859-1":   "iso-8859-1",
+	"windows-1252": "windows-1252",
+}
+
+func (unicornTextEncodingIdentifierCase) Name() string {
+	return "unicorn/text-encoding-identifier-case"
+}
+func (unicornTextEncodingIdentifierCase) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornTextEncodingIdentifierCase) Check(ctx *Context, node *shimast.Node) {
+	text := stringLiteralText(node)
+	if text == "" {
+		return
+	}
+	lower := strings.ToLower(text)
+	canonical, ok := unicornCanonicalTextEncodings[lower]
+	if !ok {
+		// `utf8`/`UTF8` share a canonical form with `utf-8` but lowercase
+		// differently — handle the hyphen-stripped aliases explicitly.
+		switch lower {
+		case "utf8":
+			canonical = "utf-8"
+		case "utf16le":
+			canonical = "utf-16le"
+		case "utf16be":
+			canonical = "utf-16be"
+		default:
+			return
+		}
+	}
+	if text == canonical {
+		return
+	}
+	ctx.Report(node, "Use the canonical lowercase form for text-encoding identifiers (e.g. `utf-8`).")
+}
+
+func init() {
+	Register(unicornTextEncodingIdentifierCase{})
+}