@sister.software/oxlint-config 10.0.0 → 12.0.0

package/README.md

@@ -40,14 +40,20 @@ export default createOxlintConfig({
 | `react`                  | `false`                   | Enable oxlint's React plugin.                               |
 | `headers`                | `true`                    | Enforce file headers (error severity, auto-fixed).          |
 | `padding`                | `true`                    | Blank line before `return`/block-like statements.           |
+| `consolePadding`         | `true`                    | Blank line on each side of a `console.*` call.               |
+| `multilineStatementPadding` | `true`                 | Blank line on each side of a multi-line statement.           |
 | `braces`                 | `true`                    | Braces around single-statement bodies.                      |
 | `restrictProcessGlobals` | `false`                   | Forbid direct `process.env` / `process.argv` access.        |
 | `limits`                 | calibrated defaults       | Override individual legibility ceilings.                    |
 | `testFilePatterns`       | `**/*.test.ts`, …         | Globs where the size and constant rules switch off.         |
 | `generatedFilePatterns`  | `**/*.gen.ts`, …          | Globs where only the size ceilings switch off.              |
+| `untypedFilePatterns`    | `**/*.js`, `**/*.mjs`, …  | Globs where the multi-line JSDoc requirement switches off.  |
 | `unnamedThresholds`      | `false`                   | Flag numeric literals used as comparison thresholds.        |
 | `constantDocs`           | `false`                   | Require JSDoc on exported / `SCREAMING_CASE` constants.     |
+| `acronymCasing`          | `false`                   | Flag an acronym title-cased inside an identifier.           |
 | `lengthTruthiness`       | `true`                    | Rewrite explicit length comparisons to truthiness.          |
+| `multilineJSDoc`         | `true`                    | Require JSDoc blocks to span multiple lines.                |
+| `sectionMarkers`         | `true`                    | Enforce the banner → MARK → region → split ladder.          |
 | `ignorePatterns`         | build output, `.yarn`     | Replace the default ignore list.                            |
 | `overrides`              | `{}`                      | Extra config merged last (escape hatch).                    |
 
@@ -85,6 +91,97 @@ A bundled oxlint JS plugin (`sister-software/require-file-header`) reports and a
 `@copyright`/`@license`/`@author` header, preserving any other JSDoc tags already in the leading
 comment block. Run `oxlint --fix` to stamp headers.
 
+### Statement padding
+
+`padding-lines` (warn, autofixed) puts a blank line before the statements that end a path or a step —
+`return`, `continue`, `break`, a bare `x++`/`x--` — and before block-like statements. An `interface`,
+`type`, `enum` or `namespace` with a body counts as block-like: same braces, same weight on the page.
+
+`multiline-statement-padding` (warn, autofixed) puts one on each side of a statement that spans lines,
+so a reader sees where it starts and stops without matching brackets:
+
+```ts
+const canonical = {          const canonical = {
+	raw,                            raw,
+	source,                         source,
+}                     →      }
+const aligned = align()
+                             const aligned = align()
+```
+
+An exported declaration is padded exactly like the unexported form — both rules look through the
+`export` wrapper.
+
+Neither edge is required at a block boundary, where the brace already separates. `console.*` calls are
+left to the rule below, which groups consecutive ones — this one would split a run that happens to
+contain a tall call, and a run of output is one thing.
+
+### Console padding
+
+`console-padding` (warn, autofixed) puts a blank line on each side of a `console.*` call, so the lines
+that produce output stand apart from the lines that compute it:
+
+```ts
+const total = sum(stats)
+console.log(`${total} shards`)      const total = sum(stats)
+const headers = ["source"]
+console.log(headers)          →     console.log(`${total} shards`)
+
+                                    const headers = ["source"]
+
+                                    console.log(headers)
+```
+
+A RUN of calls is one group — no blank lines inside it, one before the first and one after the last,
+because consecutive calls are one block of output. Neither edge is required where a block boundary
+already separates them: nothing before a call that opens a block, nothing after one that closes it.
+
+### Section markers
+
+Four rules over the comments people use to carve a file into sections. They form one ladder, and each
+rung is a smaller file than the last:
+
+```ts
+// ---------------------------------------------------------------
+// Second section                     →  // MARK: Second section
+// ---------------------------------------------------------------
+```
+
+1. **`prefer-mark-comment`** (error, autofixed) — a `----` banner is three lines of decoration
+   carrying one label. It becomes `// MARK: <label>`, with a blank line on each side. A banner
+   wrapping more than one line of prose is reported but never collapsed — that prose is content.
+2. **`concise-section-marker`** (error) — a marker's label is a label, not a paragraph. Past
+   `maxBodyLength` (60), the detail belongs in the JSDoc of what it describes, or the file wants
+   splitting and an `@file` block.
+3. **`prefer-region-over-marks`** (warn) — past one marker, a file has sections, and sections have
+   ENDS. `//#region` / `//#endregion` fold, so a reader can collapse what they are not reading.
+4. **`max-regions`** (warn) — past `maxRegions` (10), the sections want to be files. Deliberately
+   high: four well-named regions are usually fine, and splitting can separate a type from its
+   helpers. This is a runaway detector, not a style nudge.
+
+Rungs 3 and 4 warn rather than error: where a section ends, and whether it should move, are judgment
+calls no fixer gets to make. Both switch off in test files, where the suite's shape is dictated by the
+code under test.
+
+```ts
+createOxlintConfig({ sectionMarkers: { maxBodyLength: 80, maxRegions: 6 } })
+```
+
+### Multi-line JSDoc
+
+`multiline-jsdoc` (error, autofixed) expands a one-line block:
+
+```ts
+/** The answer. */          →     /**
+                                   * The answer.
+                                   */
+```
+
+A one-line block reads as an aside; the multi-line form reads as documentation, and it leaves
+somewhere to put the second sentence. Only blocks that lead their line are rewritten — one sharing a
+line with code is a type cast, and expanding it changes what the line means. Off for
+`untypedFilePatterns`, where a JSDoc block often IS the type annotation.
+
 ### Legibility tiers
 
 v10 turns on four tiers of upstream rules by default:
@@ -128,6 +225,78 @@ const AMBIGUITY_CEILING = 12
 
 Not `/** The ambiguity ceiling. */`, which leaves the reader exactly where they started.
 
+### Acronym casing
+
+`acronymCasing` turns on `sister-software/no-title-case-acronym`, which enforces that an acronym is
+capitalized as a whole camelCase component — `parseJSON`, `POILookup`, `createWOFResolver` — and
+reports the title-cased spelling:
+
+```ts
+export function parseJson() {}     // → parseJSON
+export interface PoiBoard {        // → POIBoard
+	sourceUrl: string                //  → sourceURL
+}
+```
+
+The mechanism knows no vocabulary of its own. `DefaultAcronyms` is a generic list (`JSON`, `HTTP`,
+`URL`, `SQL`, …); a project layers its own on top, and the policy stays in the config:
+
+```ts
+createOxlintConfig({
+	acronymCasing: {
+		extraAcronyms: ["POI", "WOF", "NUTS", "ONNX"],
+		// Names whose casing is not ours to choose: an external library's own spelling, a wire field
+		// someone else named, or a prop a framework derives from something else (Pastel turns
+		// `--run-id` into `runId`, so the schema key has to match its derivation).
+		ignoreNames: ["HttpStatusCode", "operationId", "runId"],
+	},
+})
+```
+
+`acronyms` replaces that list outright; `extraAcronyms` extends whichever list is in effect. Add an
+acronym once the project has settled on its capitalized form — the rule reports drift from an
+established convention, it does not invent one.
+
+**`ID` is on the default list, and `Id` is NOT the house form** — it is `placeID`, `sourceID`,
+`nodeID`. `ID` is the one default short enough to hide inside ordinary words (`Identifier`, `Idle`,
+`Ideal`), which is what the component boundary is for, and it holds: none of those end a component.
+The other short candidates were measured against a 1,587-file corpus and turned down — `IO` because
+`IoT` is the settled spelling, so the rule would report `IoTGateway` and suggest the wrong
+`IOTGateway`; `UI` because `UiButton` is a deliberate choice in plenty of React codebases and `UiPath`
+is a vendor that spells itself that way; `DB` because it is a shorthand for one word rather than an
+initialism, and every occurrence measured was a Pastel option key derived from `--admin-db`. Add any
+of them per project if your own corpus says otherwise.
+
+**Whole components, not substrings.** `Poi` lives inside `Point`, `Id` inside `Identifier`, `Us`
+inside `User`. A run counts only where it ENDS at an uppercase letter, a digit, `_`, or the end of the
+identifier, and STARTS at the identifier's start or after a lowercase letter, digit or underscore. So
+`PoiBoard` is reported and `Point`, `Pointer`, `Client` and `Jsonify` are not.
+
+**Scope.** The default, `"exported"`, reads the names a consumer can see: exported declarations, the
+members of exported interfaces, classes and enums, and the exported half of a re-export. That is where
+a wrong acronym costs someone a breaking rename later; a local costs nothing to rename at any time.
+`scope: "all"` reads every declaration in the file, exported or not.
+
+**Names you did not choose are never read**, at either scope. An object literal's keys are a wire
+contract whose casing belongs to whoever is on the other end, and the LEFT half of a destructuring
+rename is the source object's property, not a declaration:
+
+```ts
+const { baseUrl: baseURL } = docusaurusContext.siteConfig  // `baseUrl` is Docusaurus's key — silent
+return { operationId: id }                                 // OpenAPI's field name — silent
+```
+
+The rule is deliberately **not** auto-fixable: renaming a declaration without renaming its references
+produces code that does not compile, and a linter cannot see the references.
+
+Prefer a scoped disable over an `ignoreNames` entry, which silently covers every future declaration of
+the same name:
+
+```ts
+// oxlint-disable-next-line sister-software/no-title-case-acronym -- kysely spells its own dialect classes this way.
+export interface SqliteJsonDialect {}
+```
+
 ### Length checks
 
 The house convention is truthiness — `if (items.length)`, not `if (items.length > 0)`.

package/out/acronym-case-plugin.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A no-title-case-acronym rule, authored as an oxlint JS plugin (ESLint v9-compatible API). An
+ *   acronym is capitalized as a whole camelCase component — `parseJSON`, `POILookup`,
+ *   `createWOFResolver` — never title-cased. The mechanism knows nothing about any particular
+ *   project: the acronyms are options, so adding one is a config edit rather than a code change.
+ *
+ *   The subtlety the rule exists for is the COMPONENT BOUNDARY. `Poi` appears inside `Point`, `Id`
+ *   inside `Identifier`, `Us` inside `User` — none of those are acronyms, they are prefixes of
+ *   ordinary words. A substring match reports every one of them; a component match reports none.
+ *
+ *   Deliberately not fixable: renaming a declaration without renaming its references produces code
+ *   that does not compile, and a linter cannot see the references.
+ */
+import type { Rule } from "./plugin-types.js";
+/**
+ * Acronyms enforced when the caller names none. Deliberately generic — every entry is an acronym in general programming
+ * rather than in some particular domain, because this list ships to consumers who share none of each other's
+ * vocabulary. Domain acronyms belong in `extraAcronyms`.
+ *
+ * `ID` is on the list and `Id` is NOT the house form: `placeID`, `sourceID`, `nodeID`. It is the one entry short enough
+ * to hide inside ordinary words — `Id` leads `Identifier`, `Idle`, `Ideal` — which is what the component boundary is
+ * for, and it holds: none of those end a component.
+ *
+ * The other short candidates were measured against a 1,587-file corpus and turned down. Read this before adding one
+ * back:
+ *
+ * - `IO` — `IoT` is the settled spelling of the commonest identifier component starting with `Io`, so the rule would
+ *   report `IoTGateway` and suggest the wrong `IOTGateway`. Zero drift in the corpus, so nothing offsets that.
+ * - `UI` — zero drift in the corpus, and the uppercase form is not settled the way `ID`'s is. `UiButton` is a deliberate
+ *   choice in plenty of React codebases, and `UiPath` is a vendor that spells itself that way.
+ * - `DB` — a shorthand for one word rather than an initialism, so there is no English uppercase form to settle on. It is
+ *   also the exact collision the exemptions exist for: every hit in the corpus was a Pastel option key, where the
+ *   framework derives `adminDb` from `--admin-db` and the schema has to match its derivation.
+ */
+export declare const DefaultAcronyms: readonly ["API", "ASCII", "CLI", "CPU", "CSS", "CSV", "DNS", "DOM", "GPU", "HTML", "HTTP", "HTTPS", "ID", "JSON", "JSONL", "JWT", "MIME", "PDF", "RGB", "RGBA", "SDK", "SQL", "SSL", "SVG", "TLS", "TSV", "TTL", "URI", "URL", "UTC", "UTF8", "UUID", "XML", "YAML"];
+/**
+ * Which declarations the rule reads.
+ */
+export type AcronymCaseScope = "exported" | "all";
+/**
+ * Options accepted by {@link noTitleCaseAcronymRule}.
+ */
+export interface AcronymCaseOptions {
+    /**
+     * Acronyms in the ALL-CAPS spelling identifiers should use; the rule derives the title-case form (`POI` → `Poi`) and
+     * reports that. Replaces {@link DefaultAcronyms} rather than extending it.
+     *
+     * Add an acronym once the project has settled on its capitalized form. This reports drift from an established
+     * convention; it does not invent one.
+     */
+    acronyms?: string[];
+    /**
+     * Acronyms added to whichever list is in effect — the usual way to layer a project's own vocabulary on the default.
+     */
+    extraAcronyms?: string[];
+    /**
+     * Identifiers exempt everywhere, for names whose casing is not ours to choose: an external library's own spelling
+     * (`HttpStatusCode` from axios), a wire field someone else named (`operationId` in OpenAPI), or a prop a framework
+     * derives from something else (Pastel turns `--run-id` into `runId`, so the schema key has to match its derivation).
+     *
+     * Prefer a scoped `// oxlint-disable-next-line sister-software/no-title-case-acronym` at the one site that needs it.
+     * A config entry silently covers every future declaration of the same name.
+     */
+    ignoreNames?: string[];
+    /**
+     * `"exported"` (the default) reads the names a consumer can see: exported declarations, the members of exported
+     * interfaces, classes and enums, and the exported half of a re-export. That is where a wrong acronym costs someone a
+     * breaking rename later; a local costs nothing to rename at any time.
+     *
+     * `"all"` reads every declaration in the file, exported or not. Object-literal keys are never read under either
+     * setting — a wire contract is a string, and its casing belongs to whoever is on the other end.
+     */
+    scope?: AcronymCaseScope;
+}
+export declare const noTitleCaseAcronymRule: Rule;
+export default noTitleCaseAcronymRule;
+//# sourceMappingURL=acronym-case-plugin.d.ts.map

package/out/acronym-case-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acronym-case-plugin.d.ts","sourceRoot":"","sources":["../src/acronym-case-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,sQAqClB,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,KAAK,CAAA;AAEjD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAA;CACxB;AAyID,eAAO,MAAM,sBAAsB,EAAE,IAiHpC,CAAA;AAED,eAAe,sBAAsB,CAAA"}

package/out/acronym-case-plugin.js

@@ -0,0 +1,272 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A no-title-case-acronym rule, authored as an oxlint JS plugin (ESLint v9-compatible API). An
+ *   acronym is capitalized as a whole camelCase component — `parseJSON`, `POILookup`,
+ *   `createWOFResolver` — never title-cased. The mechanism knows nothing about any particular
+ *   project: the acronyms are options, so adding one is a config edit rather than a code change.
+ *
+ *   The subtlety the rule exists for is the COMPONENT BOUNDARY. `Poi` appears inside `Point`, `Id`
+ *   inside `Identifier`, `Us` inside `User` — none of those are acronyms, they are prefixes of
+ *   ordinary words. A substring match reports every one of them; a component match reports none.
+ *
+ *   Deliberately not fixable: renaming a declaration without renaming its references produces code
+ *   that does not compile, and a linter cannot see the references.
+ */
+/**
+ * Acronyms enforced when the caller names none. Deliberately generic — every entry is an acronym in general programming
+ * rather than in some particular domain, because this list ships to consumers who share none of each other's
+ * vocabulary. Domain acronyms belong in `extraAcronyms`.
+ *
+ * `ID` is on the list and `Id` is NOT the house form: `placeID`, `sourceID`, `nodeID`. It is the one entry short enough
+ * to hide inside ordinary words — `Id` leads `Identifier`, `Idle`, `Ideal` — which is what the component boundary is
+ * for, and it holds: none of those end a component.
+ *
+ * The other short candidates were measured against a 1,587-file corpus and turned down. Read this before adding one
+ * back:
+ *
+ * - `IO` — `IoT` is the settled spelling of the commonest identifier component starting with `Io`, so the rule would
+ *   report `IoTGateway` and suggest the wrong `IOTGateway`. Zero drift in the corpus, so nothing offsets that.
+ * - `UI` — zero drift in the corpus, and the uppercase form is not settled the way `ID`'s is. `UiButton` is a deliberate
+ *   choice in plenty of React codebases, and `UiPath` is a vendor that spells itself that way.
+ * - `DB` — a shorthand for one word rather than an initialism, so there is no English uppercase form to settle on. It is
+ *   also the exact collision the exemptions exist for: every hit in the corpus was a Pastel option key, where the
+ *   framework derives `adminDb` from `--admin-db` and the schema has to match its derivation.
+ */
+export const DefaultAcronyms = [
+    "API",
+    // oxlint-disable-next-line unicorn/text-encoding-identifier-case -- an entry in an acronym list, not an encoding label.
+    "ASCII",
+    "CLI",
+    "CPU",
+    "CSS",
+    "CSV",
+    "DNS",
+    "DOM",
+    "GPU",
+    "HTML",
+    "HTTP",
+    "HTTPS",
+    "ID",
+    "JSON",
+    "JSONL",
+    "JWT",
+    "MIME",
+    "PDF",
+    "RGB",
+    "RGBA",
+    "SDK",
+    "SQL",
+    "SSL",
+    "SVG",
+    "TLS",
+    "TSV",
+    "TTL",
+    "URI",
+    "URL",
+    "UTC",
+    // oxlint-disable-next-line unicorn/text-encoding-identifier-case -- an entry in an acronym list, not an encoding label.
+    "UTF8",
+    "UUID",
+    "XML",
+    "YAML",
+];
+/**
+ * Characters that may follow a title-cased run for it to be a whole component: the start of the next component, a
+ * digit, or an underscore.
+ */
+const COMPONENT_END = /[A-Z0-9_]/;
+/**
+ * Characters that may precede a title-cased run for it to START a component.
+ */
+const COMPONENT_START = /[a-z0-9_]/;
+/**
+ * Node types opening a scope whose names are private to it. Meeting one on the walk up means the declaration is a
+ * local, however deep inside an exported declaration it sits — the body of an exported function is not public surface.
+ */
+const SCOPE_BOUNDARIES = new Set([
+    "ArrowFunctionExpression",
+    "BlockStatement",
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "Program",
+    "StaticBlock",
+    "TSModuleBlock",
+]);
+/**
+ * Node types that make what they wrap part of the module's public surface.
+ */
+const EXPORT_WRAPPERS = new Set(["ExportNamedDeclaration", "ExportDefaultDeclaration"]);
+/**
+ * Title case of an acronym — the drifted spelling (`POI` → `Poi`, `NZ` → `Nz`).
+ */
+function titleCase(acronym) {
+    return acronym[0] + acronym.slice(1).toLowerCase();
+}
+/**
+ * Is the run of `found` at `index` a whole camelCase component of `identifier`?
+ *
+ * This is the entire subtlety of the rule. A component ENDS where the next character starts another one — uppercase, a
+ * digit, `_`, or the end of the identifier — and STARTS at the identifier's start or after a lowercase letter, digit or
+ * underscore. `PoiBoard` qualifies (`B` follows); `Point` does not (`n` follows).
+ */
+function isWholeComponent(identifier, index, found) {
+    const after = identifier[index + found.length];
+    if (after !== undefined && !COMPONENT_END.test(after))
+        return false;
+    const before = identifier[index - 1];
+    return before === undefined || COMPONENT_START.test(before);
+}
+/**
+ * Every title-cased acronym in `identifier`, plus the identifier as it should have been written.
+ */
+function findTitleCasedAcronyms(identifier, acronyms) {
+    const candidates = [];
+    for (const acronym of acronyms) {
+        const found = titleCase(acronym);
+        // A one-letter acronym, or one whose tail is already caseless (`H3`), has no drifted spelling to
+        // look for: title case and house case are the same string, so every match would be a correct one.
+        if (found === acronym)
+            continue;
+        for (let index = identifier.indexOf(found); index !== -1; index = identifier.indexOf(found, index + 1)) {
+            if (isWholeComponent(identifier, index, found)) {
+                candidates.push({ index, acronym, found });
+            }
+        }
+    }
+    // Longest run first where two start together, so `Jsonl` wins over `Json`.
+    const ordered = candidates.toSorted((left, right) => left.index - right.index || right.found.length - left.found.length);
+    const hits = [];
+    let expected = "";
+    let cursor = 0;
+    for (const hit of ordered) {
+        if (hit.index < cursor)
+            continue;
+        hits.push(hit);
+        expected += identifier.slice(cursor, hit.index) + hit.acronym;
+        cursor = hit.index + hit.found.length;
+    }
+    return { hits, expected: expected + identifier.slice(cursor) };
+}
+/**
+ * Is `node` part of what the module exports?
+ *
+ * The walk stops at the first scope boundary rather than running to the root, which is what separates an exported
+ * declaration from a local one that merely lives inside an exported function.
+ */
+function isPublicSurface(node) {
+    let current = node.parent;
+    while (current) {
+        if (EXPORT_WRAPPERS.has(current.type))
+            return true;
+        if (SCOPE_BOUNDARIES.has(current.type))
+            return false;
+        current = current.parent;
+    }
+    return false;
+}
+export const noTitleCaseAcronymRule = {
+    meta: {
+        name: "no-title-case-acronym",
+        type: "suggestion",
+        schema: [{ type: "object", additionalProperties: true }],
+    },
+    create(context) {
+        const options = (context.options[0] ?? {});
+        const configured = options.acronyms ?? DefaultAcronyms;
+        const acronyms = [...configured, ...(options.extraAcronyms ?? [])].map((acronym) => acronym.toUpperCase());
+        const ignoreNames = new Set(options.ignoreNames);
+        const scope = options.scope ?? "exported";
+        const reported = new Set();
+        /**
+         * Reports the identifier bound by `node`, if it title-cases an acronym.
+         */
+        function check(node) {
+            if (node?.type !== "Identifier" || !node.name)
+                return;
+            if (ignoreNames.has(node.name))
+                return;
+            // A declaration can be reached by two visitors at once (an export specifier and the binding it
+            // names, say); the range keys the site so it is reported once.
+            const site = `${node.range[0]}:${node.range[1]}`;
+            if (reported.has(site))
+                return;
+            const { hits, expected } = findTitleCasedAcronyms(node.name, acronyms);
+            if (!hits.length)
+                return;
+            reported.add(site);
+            const spelled = hits.map((hit) => `\`${hit.acronym}\``).join(", ");
+            context.report({
+                node,
+                message: `\`${node.name}\` title-cases ${hits.length > 1 ? "the acronyms" : "the acronym"} ${spelled} — an ` +
+                    `acronym is capitalized as a whole camelCase component, so this reads \`${expected}\`.`,
+            });
+        }
+        function inScope(node) {
+            return scope === "all" || isPublicSurface(node);
+        }
+        /**
+         * Parameters are declarations too, but renaming one breaks nobody, so they are read only when the caller has asked
+         * for every declaration in the file.
+         */
+        function parameters(node) {
+            if (scope !== "all")
+                return;
+            for (const parameter of node.params ?? []) {
+                check(parameter);
+            }
+        }
+        /**
+         * A named declaration: `function`, `class`, `interface`, `type`, `enum`, `module`, and enum members.
+         */
+        function declared(node) {
+            parameters(node);
+            if (inScope(node)) {
+                check(node.id);
+            }
+        }
+        /**
+         * A member of an interface, type literal, or class — public surface of the type that holds it.
+         */
+        function member(node) {
+            if (node.computed || node.accessibility === "private")
+                return;
+            if (inScope(node)) {
+                check(node.key);
+            }
+        }
+        return {
+            FunctionDeclaration: declared,
+            ClassDeclaration: declared,
+            TSInterfaceDeclaration: declared,
+            TSTypeAliasDeclaration: declared,
+            TSEnumDeclaration: declared,
+            TSModuleDeclaration: declared,
+            TSEnumMember: declared,
+            TSPropertySignature: member,
+            TSMethodSignature: member,
+            PropertyDefinition: member,
+            MethodDefinition: member,
+            VariableDeclaration(node) {
+                if (!inScope(node))
+                    return;
+                for (const declarator of node.declarations ?? []) {
+                    check(declarator.id);
+                }
+            },
+            // The exported half of `export { poiBoard as PoiBoard }` and `export * as PoiBoard from "…"` is
+            // the name a consumer imports, whatever the local one is called.
+            ExportSpecifier(node) {
+                check(node.exported);
+            },
+            ExportAllDeclaration(node) {
+                check(node.exported);
+            },
+            FunctionExpression: parameters,
+            ArrowFunctionExpression: parameters,
+        };
+    },
+};
+export default noTitleCaseAcronymRule;
+//# sourceMappingURL=acronym-case-plugin.js.map

package/out/acronym-case-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acronym-case-plugin.js","sourceRoot":"","sources":["../src/acronym-case-plugin.ts"],"names":[],"mappings":"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"}

package/out/browser-globals.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The browser globals whose bare use is ambiguous, and the rule entry built from them. A list
+ *   this long is reference data — it belongs beside the code that consumes it, not inside the file
+ *   that assembles the platform-layering overrides.
+ */
+/**
+ * Browser globals whose bare use is ambiguous (they collide with common identifiers). Browser- and node-runtime files
+ * warn on these, nudging toward an explicit `window.` access.
+ */
+export declare const BROWSER_GLOBALS: readonly ["addEventListener", "blur", "close", "closed", "confirm", "defaultStatus", "defaultstatus", "event", "external", "find", "focus", "frameElement", "frames", "history", "innerHeight", "innerWidth", "length", "location", "locationbar", "menubar", "moveBy", "moveTo", "name", "onblur", "onerror", "onfocus", "onload", "onresize", "onunload", "open", "opener", "opera", "outerHeight", "outerWidth", "pageXOffset", "pageYOffset", "parent", "print", "removeEventListener", "resizeBy", "resizeTo", "screen", "screenLeft", "screenTop", "screenX", "screenY", "scroll", "scrollbars", "scrollBy", "scrollTo", "scrollX", "scrollY", "self", "status", "statusbar", "stop", "toolbar", "top"];
+export declare function restrictedBrowserGlobalsRule(): unknown;
+//# sourceMappingURL=browser-globals.d.ts.map

package/out/browser-globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-globals.d.ts","sourceRoot":"","sources":["../src/browser-globals.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,+qBA2DlB,CAAA;AAEV,wBAAgB,4BAA4B,IAAI,OAAO,CAEtD"}

package/out/browser-globals.js

@@ -0,0 +1,76 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The browser globals whose bare use is ambiguous, and the rule entry built from them. A list
+ *   this long is reference data — it belongs beside the code that consumes it, not inside the file
+ *   that assembles the platform-layering overrides.
+ */
+/**
+ * Browser globals whose bare use is ambiguous (they collide with common identifiers). Browser- and node-runtime files
+ * warn on these, nudging toward an explicit `window.` access.
+ */
+export const BROWSER_GLOBALS = [
+    "addEventListener",
+    "blur",
+    "close",
+    "closed",
+    "confirm",
+    "defaultStatus",
+    "defaultstatus",
+    "event",
+    "external",
+    "find",
+    "focus",
+    "frameElement",
+    "frames",
+    "history",
+    "innerHeight",
+    "innerWidth",
+    "length",
+    "location",
+    "locationbar",
+    "menubar",
+    "moveBy",
+    "moveTo",
+    "name",
+    "onblur",
+    "onerror",
+    "onfocus",
+    "onload",
+    "onresize",
+    "onunload",
+    "open",
+    "opener",
+    "opera",
+    "outerHeight",
+    "outerWidth",
+    "pageXOffset",
+    "pageYOffset",
+    "parent",
+    "print",
+    "removeEventListener",
+    "resizeBy",
+    "resizeTo",
+    "screen",
+    "screenLeft",
+    "screenTop",
+    "screenX",
+    "screenY",
+    "scroll",
+    "scrollbars",
+    "scrollBy",
+    "scrollTo",
+    "scrollX",
+    "scrollY",
+    "self",
+    "status",
+    "statusbar",
+    "stop",
+    "toolbar",
+    "top",
+];
+export function restrictedBrowserGlobalsRule() {
+    return ["warn", ...BROWSER_GLOBALS.map((name) => ({ name, message: `Ambiguous: did you mean \`window.${name}\`?` }))];
+}
+//# sourceMappingURL=browser-globals.js.map

package/out/browser-globals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-globals.js","sourceRoot":"","sources":["../src/browser-globals.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC9B,kBAAkB;IAClB,MAAM;IACN,OAAO;IACP,QAAQ;IACR,SAAS;IACT,eAAe;IACf,eAAe;IACf,OAAO;IACP,UAAU;IACV,MAAM;IACN,OAAO;IACP,cAAc;IACd,QAAQ;IACR,SAAS;IACT,aAAa;IACb,YAAY;IACZ,QAAQ;IACR,UAAU;IACV,aAAa;IACb,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,SAAS;IACT,SAAS;IACT,QAAQ;IACR,UAAU;IACV,UAAU;IACV,MAAM;IACN,QAAQ;IACR,OAAO;IACP,aAAa;IACb,YAAY;IACZ,aAAa;IACb,aAAa;IACb,QAAQ;IACR,OAAO;IACP,qBAAqB;IACrB,UAAU;IACV,UAAU;IACV,QAAQ;IACR,YAAY;IACZ,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,YAAY;IACZ,UAAU;IACV,UAAU;IACV,SAAS;IACT,SAAS;IACT,MAAM;IACN,QAAQ;IACR,WAAW;IACX,MAAM;IACN,SAAS;IACT,KAAK;CACI,CAAA;AAEV,MAAM,UAAU,4BAA4B;IAC3C,OAAO,CAAC,MAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,oCAAoC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,CAAA;AACtH,CAAC"}