refactor(types): mark internal Autocomplete members as private

The class shipped 2.0.0 with no access modifiers — every method and
field was implicitly public, so TypeScript consumers would see ~30
internal helpers (`initialize`, `onKeyPress`, `getSuggestions`,
`groupSuggestionsByCategory`, `verifySuggestionsFormat`, etc.) as
callable API without warning. That's a wider commitment than the
README documents.

Adds `private` to every member that isn't in the README's instance-
method table or otherwise part of the recommended public API. Public
surface is now exactly:

  - methods: setOptions, clear, clearCache, disable, enable, hide,
    select (per #846), dispose
  - fields:  options (read-only by convention)
  - statics: Autocomplete.defaults, Autocomplete.utils

Runtime is unchanged — TypeScript's `private` is a type-system
contract, not a runtime fence — but the emitted `.d.ts` now reflects
the actual surface area, so TS consumers will get a warning if they
reach into internals. (53 `private` declarations in
`dist/Autocomplete.d.ts` after this change vs 0 before.) JS callers
(including the existing test suite) keep working.

CLAUDE.md updated to capture the convention for future contributors.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tkirda-bison

CLAUDE.md

@@ -73,6 +73,7 @@ The minified UMD is ~13 KB; the unminified is ~26 KB.
 ## Conventions
 
 - TypeScript strict mode is on. Don't introduce `any` in public types. Internal `as unknown as X` casts are OK at jQuery boundaries where typings are imprecise.
+- The `Autocomplete` class explicitly marks every member `private` unless it's part of the documented public API in `readme.md` (`setOptions`, `clear`, `clearCache`, `disable`, `enable`, `hide`, `select`, `dispose`, plus the `options` field and the static `defaults`/`utils`). When adding a new member, default to `private`; only drop the keyword when you also add a row to the README's instance-method table. JS callers can still reach private members at runtime — they're a TypeScript-surface contract, not a runtime fence — but the contract is what consumers will rely on.
 - Methods use `this` directly. The one exception is `initialize()`, which aliases `const self = this` for the jQuery delegation handlers (`function (this: HTMLElement)`) that need both `$(this)` for the matched element AND access to the Autocomplete instance. Don't add new `that = this` aliases elsewhere — use arrow functions for callbacks instead.
 - Prefer native array methods (`.map`, `.filter`, `.find`, `.some`, `.indexOf`) over jQuery's `$.each` / `$.grep` / `$.map` / `$.inArray` in new code; the JS-source equivalents have already been swapped where semantics match.
 - Prettier owns formatting. Run `npm run format` before committing source changes.

dist/Autocomplete.d.ts

@@ -1,76 +1,71 @@
-import type { AutocompleteOptions, AutocompleteResponse, LookupArray, Orientation, ResolvedOptions, Suggestion } from "./types";
-interface Classes {
-    selected: string;
-    suggestion: string;
-}
+import type { AutocompleteOptions, ResolvedOptions } from "./types";
 export declare class Autocomplete {
     static defaults: ResolvedOptions;
     static utils: {
         escapeRegExChars(value: string): string;
         createNode(containerClass: string): HTMLDivElement;
     };
-    element: HTMLInputElement;
-    el: JQuery;
-    suggestions: Suggestion[];
-    badQueries: string[];
-    selectedIndex: number;
-    currentValue: string;
-    cachedResponse: Record<string, AutocompleteResponse>;
-    onChangeTimeout: ReturnType<typeof setTimeout> | null;
-    isLocal: boolean;
-    suggestionsContainer: HTMLDivElement;
-    noSuggestionsContainer: HTMLElement;
-    $container: JQuery;
-    $noSuggestionsContainer: JQuery;
+    private element;
+    private el;
+    private suggestions;
+    private badQueries;
+    private selectedIndex;
+    private currentValue;
+    private cachedResponse;
+    private onChangeTimeout;
+    private isLocal;
+    private suggestionsContainer;
+    private noSuggestionsContainer;
+    private $container;
+    private $noSuggestionsContainer;
     options: ResolvedOptions;
-    classes: Classes;
-    hint: Suggestion | null;
-    hintValue: string;
-    selection: Suggestion | null;
-    disabled?: boolean;
-    visible?: boolean;
-    ignoreValueChange?: boolean;
-    blurTimeoutId?: ReturnType<typeof setTimeout>;
-    fixPositionCapture?: () => void;
-    currentRequest: JQuery.jqXHR | null;
+    private classes;
+    private hint;
+    private hintValue;
+    private selection;
+    private disabled?;
+    private visible?;
+    private ignoreValueChange?;
+    private blurTimeoutId?;
+    private fixPositionCapture?;
+    private currentRequest;
     constructor(el: HTMLInputElement, options?: AutocompleteOptions);
-    initialize(): void;
-    onFocus(): void;
-    onBlur(): void;
-    abortAjax(): void;
+    private initialize;
+    private onFocus;
+    private onBlur;
+    private abortAjax;
     setOptions(suppliedOptions?: AutocompleteOptions): void;
     clearCache(): void;
     clear(): void;
     disable(): void;
     enable(): void;
-    fixPosition(): void;
-    isCursorAtEnd(): boolean;
-    onKeyPress(e: JQuery.KeyDownEvent): void;
-    onKeyUp(e: JQuery.TriggeredEvent): void;
-    onValueChange(): void;
-    isExactMatch(query: string): boolean;
-    getQuery(value: string): string;
-    getSuggestionsLocal(query: string): AutocompleteResponse;
-    getSuggestions(q: string): void;
-    isBadQuery(q: string): boolean;
+    private fixPosition;
+    private isCursorAtEnd;
+    private onKeyPress;
+    private onKeyUp;
+    private onValueChange;
+    private isExactMatch;
+    private getQuery;
+    private getSuggestionsLocal;
+    private getSuggestions;
+    private isBadQuery;
     hide(): void;
-    groupSuggestionsByCategory(suggestions: Suggestion[], key: string): Suggestion[];
-    suggest(): void;
-    noSuggestions(): void;
-    adjustContainerWidth(): void;
-    findBestHint(): void;
-    onHint(suggestion: Suggestion | null): void;
-    verifySuggestionsFormat(suggestions: LookupArray): Suggestion[];
-    validateOrientation(orientation: string | undefined, fallback: Orientation): Orientation;
-    processResponse(result: AutocompleteResponse, originalQuery: string, cacheKey: string): void;
-    activate(index: number): HTMLElement | null;
-    selectHint(): void;
+    private groupSuggestionsByCategory;
+    private suggest;
+    private noSuggestions;
+    private adjustContainerWidth;
+    private findBestHint;
+    private onHint;
+    private verifySuggestionsFormat;
+    private validateOrientation;
+    private processResponse;
+    private activate;
+    private selectHint;
     select(i: number): void;
-    moveUp(): void;
-    moveDown(): void;
-    adjustScroll(index: number): void;
-    onSelect(index: number): void;
-    getValue(value: string): string;
+    private moveUp;
+    private moveDown;
+    private adjustScroll;
+    private onSelect;
+    private getValue;
     dispose(): void;
 }
-export {};