react-x11 2.16.0 → 2.17.0

package/src/types/elements.d.ts

@@ -371,7 +371,29 @@ export interface WindowProps
   y?: number;
   /** Palette that `$token` style values resolve against, for this subtree. */
   theme?: Record<string, string | number>;
-  /** ICCCM `WM_CLASS`. */
+  /**
+   * The desktop identity of this window — which application it belongs to,
+   * and so which launcher icon it groups under and which `.desktop` entry a
+   * launcher matches it to.
+   *
+   * One name for what every desktop calls something else: ICCCM `WM_CLASS` on
+   * X11, `xdg_toplevel.set_app_id` on Wayland, the AppUserModelID on Windows.
+   * Normally the same string as `registerApplication({ appId })`, which is
+   * what a launcher matches against.
+   *
+   * A string is the modern single-id form. X11's instance/class pair is still
+   * accepted and passed through on that backend; every other backend takes
+   * the class, which is the part naming the application.
+   *
+   * Honoured on X11, on Windows — where it is the window's AppUserModelID,
+   * and where the jump list is attached to the same id — and, for windows
+   * opened after it is set, on Wayland, whose `app_id` is fixed when the
+   * surface is created. The cocoa backend accepts it and does nothing with
+   * it: macOS identity is the bundle's, decided at build time.
+   */
+  appId?: string | [string, string] | { instance: string; class?: string };
+  /** @deprecated Renamed to {@link WindowProps.appId} — `wmClass` is X11's
+   *  word for an identity every desktop has. Still accepted. */
   wmClass?: string | [string, string] | { instance: string; class?: string };
   /** EWMH `_NET_WM_WINDOW_TYPE`, or a list of fallbacks. */
   windowType?: WindowType | WindowType[];

package/src/types/events.d.ts

@@ -39,6 +39,22 @@ export interface SyntheticEvent<T = DrawnNode> {
    * what a node's `abs` is in (docs/scale.md). */
   x: number;
   y: number;
+  /**
+   * Where the pointer is on the **virtual screen**, in the same logical
+   * pixels `x`/`y` are in — what to reach for when placing something outside
+   * the window, such as a context menu at the pointer.
+   *
+   * Present exactly where the backend reported a position. That is most
+   * events, including keys on X11, whose KeyPress carries where the pointer
+   * was; it is undefined rather than `0` where a backend reported none, since
+   * zero is the screen's top-left corner and not an absence.
+   *
+   * `nativeEvent.rootx`/`rooty` is X11's name for the same point and is still
+   * there, in *device* pixels — the same split as `x` against
+   * `nativeEvent.x`.
+   */
+  screenX?: number;
+  screenY?: number;
   /** Coordinates relative to `target`'s box. */
   localX: number;
   localY: number;
@@ -541,6 +557,11 @@ export interface AcceleratorOptions {
  * matched against the Latin keysym so a layout switch does not turn it off,
  * and behind whatever a focused element consumed with `preventDefault()`.
  * See docs/events.md.
+ *
+ * With no `scope` the binding belongs to the tree's top-level `<window>`, or,
+ * in an app that has none, to the root-level `<popup>` holding the keyboard —
+ * a tray popover. One that can reach neither binds nothing and says so once
+ * in development.
  */
 export function useAccelerator(
   shortcut: MenuShortcut,

package/src/types/filedialog.d.ts

@@ -162,7 +162,9 @@ export interface FileDialogs {
  *
  * Exact when the tree has one top-level window, which is nearly every app.
  * With several it prefers the focused one and warns in development when it
- * has to guess — see docs/filedialog.md.
+ * has to guess; with none — a menu-bar app, which is a tray item and a
+ * popover — it answers the root-level `<popup>` that took the keyboard. See
+ * docs/filedialog.md.
  */
 export declare function useTopLevelWindow(): {
   readonly current: NtkWindow | DrawnNode | null;

package/src/types/launcher.d.ts

@@ -35,17 +35,23 @@ export declare function setBadge(
 export declare function useBadge(value: BadgeValue): void;
 
 /**
- * The menu behind a right-click on the app's icon in the Dock or launcher,
- * from the same item vocabulary `MenuBar` takes; an item's `onSelect` fires
- * when picked. Installed while mounted, replaced when `items` changes, taken
- * down on unmount.
+ * The menu behind a right-click on the app's **launcher icon** — the Dock on
+ * macOS, the launcher on Linux — from the same item vocabulary `MenuBar`
+ * takes; an item's `onSelect` fires when picked. Installed while mounted,
+ * replaced when `items` changes, taken down on unmount.
  *
  * `NSDockTile`'s menu on the cocoa backend; the launcher protocol's
  * **quicklist** on Linux — a `com.canonical.dbusmenu` tree, the same menu
  * protocol the tray and the global menu speak. Needs the identity
  * `registerApplication({ appId })` establishes and a `.desktop` file of that
  * name, like the badge.
+ *
+ * Reads `useDesktopCapability('launcher').features.menu`.
  */
+export declare function useLauncherMenu(items: MenuItem[] | null): void;
+
+/** @deprecated Renamed to {@link useLauncherMenu} — "Dock" is one desktop's
+ *  word for the icon every desktop has. Still exported and still works. */
 export declare function useDockMenu(items: MenuItem[] | null): void;
 
 /**
@@ -80,9 +86,17 @@ export declare function setUrgent(
 ): Promise<boolean>;
 
 /**
- * {@link useDockMenu}'s imperative twin, for code with no component. `null`
- * takes the menu down.
+ * {@link useLauncherMenu}'s imperative twin, for code with no component.
+ * `null` takes the menu down.
  */
+export declare function setLauncherMenu(
+  items: MenuItem[] | null,
+  options?: SetBadgeOptions,
+): Promise<boolean>;
+
+/** @deprecated Renamed to {@link setLauncherMenu} — "quicklist" is the Unity
+ *  launcher's word for the menu macOS calls the Dock menu, and this drove
+ *  both all along. Still exported and still works. */
 export declare function setQuicklist(
   items: MenuItem[] | null,
   options?: SetBadgeOptions,

package/src/types/taskbar.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The Windows taskbar's own surfaces. See docs/windows-integrations.md.
+ *
+ * Three things the taskbar has that no other desktop does, so none of them is
+ * a rung on an existing ladder. They are reported as features of the
+ * **launcher** — `useDesktopCapability('launcher').features.thumbnailToolbar`
+ * and its two siblings — because all of them hang off the one icon the
+ * desktop shows for this app, beside the badge and the progress bar. The
+ * hooks do nothing where the backend has none, so they are safe to call
+ * unconditionally and an app needs no platform check.
+ */
+
+/**
+ * An icon for a toolbar button: raw RGBA with its size, an ntk `Image`, or a
+ * path to a file. The shell tints it for the theme, so the shape is the whole
+ * of it and a white glyph on transparent is the usual choice.
+ */
+export type TaskbarIcon =
+  | string
+  | { data: Uint8Array; width: number; height: number }
+  | { width: number; height: number };
+
+export interface ThumbnailToolbarButton {
+  /** What a click is reported as. Not the shell's index. */
+  id: string;
+  /** The hover tooltip; `label` is accepted as a synonym. */
+  tooltip?: string;
+  label?: string;
+  icon?: TaskbarIcon | null;
+  /** Default true. A disabled button is shown greyed rather than hidden. */
+  enabled?: boolean;
+  /** Close the hover preview when this one is clicked. */
+  dismissOnClick?: boolean;
+}
+
+/**
+ * Up to seven buttons under this window's taskbar hover preview — where a
+ * media player puts play and skip. `null` hides them, which is as far down as
+ * the shell allows: a window that has had a toolbar keeps one.
+ *
+ * The eighth button and beyond are dropped rather than refused, because the
+ * shell refuses the whole call for an eighth.
+ */
+export declare function useThumbnailToolbar(
+  buttons: readonly ThumbnailToolbarButton[] | null | undefined,
+  onClick?: (id: string, event: unknown) => void,
+): void;
+
+export interface JumpListTask {
+  title: string;
+  /** Passed to a **new** process; nothing calls back into this one. */
+  arguments?: string;
+  description?: string;
+}
+
+/**
+ * The Tasks category of this application's jump list — the menu on a right
+ * click of its taskbar button. `null` deletes the category.
+ *
+ * Each entry **relaunches this executable** with the arguments given, which
+ * is what a jump-list task is. That is why this is not `useLauncherMenu`, whose
+ * items carry a callback: reported as `features.tasks` rather than
+ * `features.menu`, so an app cannot mistake one for the other.
+ */
+export declare function useJumpList(
+  tasks: readonly JumpListTask[] | null | undefined,
+): void;
+
+/** Notes `path` for the shell's Recent lists whenever it changes. */
+export declare function useRecentDocument(path?: string | null): void;
+
+/**
+ * The imperative form of {@link useRecentDocument}. Returns false where the
+ * backend has no Recent list, rather than throwing.
+ */
+export declare function noteRecentDocument(
+  path: string | null,
+  options?: { app?: unknown },
+): boolean;

package/src/wayland/context2d.js

@@ -206,7 +206,7 @@ function scaleOf(m) {
 
 /**
  * The Render ops a `drawGlyphs` call can name, numbered as XRender numbers
- * them — the same table the Cocoa backend answers (`src/cocoa/context2d.js`),
+ * them — the same table the native backends answer (`src/backend/context2d.js`),
  * so `ctx.Render.PictOp.Over` reads the same on every backend. The op is
  * ignored here: text composites Over, and for the opaque inks text uses Src
  * and Over agree.

package/src/wayland/xkb.js

@@ -19,8 +19,10 @@
 //   xkb_symbols    `key <AD01> { [ q, Q ] };`     keycode -> keysyms per level,
 //                  with `symbols[Group2]`/`symbols[2]` and `type=` where given
 //                  `modifier_map Mod5 { <LVL3> }` real modifier -> keycodes
-//   xkb_compat     `interpret ISO_Level3_Shift { virtualModifier= LevelThree; }`
-//                                                keysym -> virtual modifier
+//   xkb_compat     `interpret ISO_Level3_Shift { virtualModifier= LevelThree;
+//                     useModMapMods= level1; }`  keysym -> virtual modifier,
+//                                                and which of a key's symbols
+//                                                may name it
 //
 // From the last two, a virtual modifier like `LevelThree` resolves to the
 // real modifier bit the compositor will actually report in
@@ -29,8 +31,10 @@
 // that does not say.
 //
 // What is not read: key actions (the compositor applies those; we only see
-// their effect in the modifier state), indicators, geometry, and the
-// per-type `preserve` rules.
+// their effect in the modifier state), indicators and geometry. The per-type
+// `preserve` rules *are* read, for the one thing they decide here: whether
+// Caps Lock still has a capitalisation to do after the type has chosen a
+// level (`_capitalises`).
 //
 // The output is two things. `keycode2keysyms` is the X core shape —
 // `[g1l1, g1l2, g2l1, g2l2, …]` — because that is what `keyboard.js`'s
@@ -38,7 +42,7 @@
 // `decode()` is the full answer, using the key's real type so that level 3
 // and 4 (AltGr) resolve where the two-level core shape cannot express them.
 
-import { charOf } from '../keysyms.js';
+import { charOf, keysymToUpper } from '../keysyms.js';
 import { keysymFromName } from './keysymnames.js';
 
 /** Real modifier bits, as X and XKB both number them. */
@@ -135,7 +139,7 @@ export class XkbKeymap {
     while ((m = re.exec(s))) {
       const body = balanced(s, m.index + m[0].length - 1);
       re.lastIndex = m.index + m[0].length + body.length;
-      const type = { name: m[1], mods: [], map: [], levels: 1 };
+      const type = { name: m[1], mods: [], map: [], preserve: [], levels: 1 };
       const mods = body.match(/modifiers\s*=\s*([^;]+);/);
       if (mods)
         type.mods = mods[1]
@@ -153,6 +157,17 @@ export class XkbKeymap {
         type.map.push({ set, level });
         if (level > type.levels) type.levels = level;
       }
+      // `preserve[Lock+LevelThree]= Lock;` — the modifiers this state does
+      // *not* consume, which is the whole of whether Caps Lock still applies
+      // on a key whose type otherwise swallows Lock.
+      for (const e of body.matchAll(/preserve\[([^\]]+)\]\s*=\s*([^;]+);/gi)) {
+        const split = (x) =>
+          x
+            .split('+')
+            .map((y) => y.trim())
+            .filter((y) => y && y !== 'none' && y !== 'None');
+        type.preserve.push({ set: split(e[1]), kept: split(e[2]) });
+      }
       for (const e of body.matchAll(/level_name\[(?:Level)?(\d+)\]/gi)) {
         if (+e[1] > type.levels) type.levels = +e[1];
       }
@@ -161,6 +176,10 @@ export class XkbKeymap {
   }
 
   _parseCompat(s) {
+    // `interpret.useModMapMods= AnyLevel;` — the section default, which every
+    // keymap states, and which an interpretation overrides for itself.
+    const dflt = s.match(/interpret\.useModMapMods\s*=\s*([A-Za-z0-9_]+)/i);
+    const level1 = (word) => /^level(?:1|One)$/i.test(word ?? '');
     // interpret <keysym>[+cond] { virtualModifier= X; ... }
     const re = /interpret\s+([A-Za-z0-9_]+)(?:\+[^{]*)?\s*\{/g;
     let m;
@@ -170,7 +189,12 @@ export class XkbKeymap {
       const vm = body.match(/virtualModifier\s*=\s*([A-Za-z0-9_]+)/i);
       if (!vm) continue;
       const sym = keysymFromName(m[1]);
-      if (sym) (this._interp ??= new Map()).set(sym, vm[1]);
+      if (!sym) continue;
+      const umm = body.match(/useModMapMods\s*=\s*([A-Za-z0-9_]+)/i);
+      (this._interp ??= new Map()).set(sym, {
+        vmod: vm[1],
+        level1Only: level1(umm ? umm[1] : dflt?.[1]),
+      });
     }
   }
 
@@ -256,24 +280,51 @@ export class XkbKeymap {
   }
 
   /**
-   * Virtual modifier -> real modifier: the keys whose keysym `interpret`
-   * binds to the virtual modifier are looked up in `modifier_map`, and the
-   * real bits found there are the answer.
+   * Virtual modifier -> real modifier: a key's `interpret`ed keysyms name the
+   * virtual modifiers the key sets, and the key's `modifier_map` bits are
+   * what those virtual modifiers turn out to mean.
+   *
+   * Which of a key's keysyms may name one is `useModMapMods`, and it is the
+   * whole of AltGr working. `<RALT>` sits in `modifier_map Mod1` beside the
+   * other Alt keys and *also* carries `ISO_Level3_Shift`, on a secondary
+   * group or a second level:
+   *
+   *     key <RALT> { type= "ONE_LEVEL", symbols[1]= [ Alt_R ],
+   *                                     symbols[2]= [ ISO_Level3_Shift ] };
+   *     modifier_map Mod1 { <LALT>, <RALT>, <ALT>, <META> };
+   *     modifier_map Mod5 { <LVL3> };
+   *
+   * Attributing a key's bits to every keysym on it collected Mod1 from
+   * `<RALT>` on top of Mod5 from `<LVL3>`, so `LevelThree` resolved to
+   * `Mod1|Mod5` — and since `_levelFor` matches the masked state for
+   * equality, a real AltGr press (Mod5 alone) never reached level 3. AltGr
+   * did nothing and the third and fourth level of every layout were
+   * unreachable. `useModMapMods= level1`, which is what the keymap says for
+   * `ISO_Level3_Shift`, means a key contributes only where the keysym is its
+   * **primary** symbol — group 1, level 1 — and `<RALT>`'s primary symbol is
+   * `Alt_R`, so it never should have contributed.
    */
   _resolveVmods() {
-    const bySym = new Map(); // keysym -> real mask, from modmap via symbols
+    const bind = (vmod, bits) =>
+      this.vmods.set(vmod, (this.vmods.get(vmod) ?? 0) | bits);
     for (const [code, key] of this.keys) {
       const bits = this.modmap.get(code);
       if (!bits) continue;
-      for (const g of key.groups)
-        for (const sym of g?.syms ?? [])
-          if (sym) bySym.set(sym, (bySym.get(sym) ?? 0) | bits);
+      for (let gi = 0; gi < key.groups.length; gi++) {
+        const syms = key.groups[gi]?.syms ?? [];
+        for (let li = 0; li < syms.length; li++) {
+          const interp = syms[li] && this._interp?.get(syms[li]);
+          if (!interp) continue;
+          if (interp.level1Only && (gi || li)) continue;
+          bind(interp.vmod, bits);
+        }
+      }
     }
-    for (const { sym, bit } of this._modmapSyms ?? [])
-      bySym.set(sym, (bySym.get(sym) ?? 0) | bit);
-    for (const [sym, vmod] of this._interp ?? []) {
-      const real = bySym.get(sym);
-      if (real) this.vmods.set(vmod, (this.vmods.get(vmod) ?? 0) | real);
+    // `modifier_map Shift { Shift_L };` — the bare-keysym form names no key,
+    // so there is no level to test it against.
+    for (const { sym, bit } of this._modmapSyms ?? []) {
+      const interp = this._interp?.get(sym);
+      if (interp) bind(interp.vmod, bit);
     }
     for (const [name, bit] of Object.entries(VMOD_FALLBACK)) {
       if (!this.vmods.has(name)) this.vmods.set(name, bit);
@@ -286,6 +337,13 @@ export class XkbKeymap {
     return this.vmods.get(name) ?? 0;
   }
 
+  /** A list of modifier names as one real mask. */
+  _maskOf(names) {
+    let mask = 0;
+    for (const name of names) mask |= this._modMask(name);
+    return mask;
+  }
+
   /**
    * The X core keyboard mapping — two keysyms per group, up to four groups —
    * which is what `GetKeyboardMapping` would have answered.
@@ -319,17 +377,37 @@ export class XkbKeymap {
    */
   _levelFor(type, mods) {
     if (!type) return mods & REAL_MODS.Shift ? 1 : 0;
-    let relevant = 0;
-    for (const m of type.mods) relevant |= this._modMask(m);
+    const relevant = this._maskOf(type.mods);
     const masked = mods & relevant;
     for (const { set, level } of type.map) {
-      let want = 0;
-      for (const m of set) want |= this._modMask(m);
-      if (want === masked) return level - 1;
+      if (this._maskOf(set) === masked) return level - 1;
     }
     return 0;
   }
 
+  /**
+   * Whether Caps Lock still has a capitalisation to do.
+   *
+   * XKB's rule: Lock is effective, and the key's type did not **consume** it.
+   * A type that names Lock among its modifiers consumed it — `ALPHABETIC`'s
+   * `map[Lock]= 2` has already picked the level Caps Lock wanted, and
+   * capitalising on top would be doing it twice. Unless the type says
+   * otherwise: `preserve[Lock+LevelThree]= Lock` hands Lock back, which is how
+   * German's AltGr levels capitalise (`ſ` -> `S`) while its Shift levels,
+   * reached through `map[Lock]`, do not.
+   */
+  _capitalises(type, mods) {
+    if (!(mods & REAL_MODS.Lock)) return false;
+    if (!type) return true;
+    const relevant = this._maskOf(type.mods);
+    if (!(relevant & REAL_MODS.Lock)) return true;
+    const masked = mods & relevant;
+    for (const { set, kept } of type.preserve)
+      if (this._maskOf(set) === masked)
+        return (this._maskOf(kept) & REAL_MODS.Lock) !== 0;
+    return false;
+  }
+
   /**
    * Decode a key event.
    *
@@ -349,31 +427,17 @@ export class XkbKeymap {
     let level = this._levelFor(g.type, mods);
     if (level >= g.syms.length || !g.syms[level]) {
       // Lock on a one-level key, or Shift on a key with no upper level:
-      // fall back the way the core protocol does — the first symbol,
-      // uppercased when it has a case.
+      // fall back the way the core protocol does, to the first symbol. Any
+      // capitalisation it has coming is the separate step below.
       level = 0;
     }
     let keysym = g.syms[level] ?? 0;
-    // Caps Lock on a plain two-level alphabetic key whose type does not
-    // fold Lock (a keymap with only "TWO_LEVEL" for letters): X core rule.
-    if (
-      level === 0 &&
-      mods & REAL_MODS.Lock &&
-      g.syms.length >= 2 &&
-      !(mods & REAL_MODS.Shift)
-    ) {
-      const lower = charOf(g.syms[0]);
-      const upper = charOf(g.syms[1]);
-      if (
-        lower &&
-        upper &&
-        lower !== upper &&
-        lower.toUpperCase() === upper &&
-        g.type?.mods?.includes('Lock') === false
-      ) {
-        keysym = g.syms[1];
-      }
-    }
+    // Caps Lock capitalises the keysym the type already chose, rather than
+    // reaching for an uppercase sibling level. Pairing levels works for
+    // `[a, A]` and nothing else: AZERTY's `é` key is `[é, 2, ~, ˘]`, where
+    // level 2 is a digit, and German's AltGr `ſ` has no sibling at all — so
+    // `é`, `à`, `è`, `ç`, `ù` and every Cyrillic letter stayed lowercase.
+    if (this._capitalises(g.type, mods)) keysym = keysymToUpper(keysym);
     if (!keysym) return undefined;
     const ch = charOf(keysym);
     const codepoint = ch ? ch.codePointAt(0) : undefined;
@@ -398,24 +462,71 @@ export class XkbKeymap {
 }
 
 /**
- * The type XKB assigns a key that names none: one symbol is ONE_LEVEL, two
- * are ALPHABETIC when they are a case pair and TWO_LEVEL otherwise, four are
- * FOUR_LEVEL(_ALPHABETIC / _SEMIALPHABETIC).
+ * `XkbKSIsKeypad`: the one run of keysyms the keypad produces, `KP_Space`
+ * through `KP_Equal`. Every keypad key is in it on both of its levels — the
+ * navigation keysym (`KP_Home`) as much as the digit (`KP_7`).
+ */
+function isKeypad(sym) {
+  return sym >= 0xff80 && sym <= 0xffbd;
+}
+
+/**
+ * `XkbKSIsLower` and `XkbKSIsUpper`: a keysym has a case, and is the lower or
+ * the upper one of the pair.
+ *
+ * Two independent questions rather than one pairing — which is the same
+ * mistake `decode()` used to make about Caps Lock, in the one other place it
+ * was made. German's `s` is `[s, S, ſ, ẞ]`, and `ſ` does not *pair* with `ẞ`
+ * (`'ſ'.toUpperCase()` is `'S'`), but `ſ` is a lowercase letter and `ẞ` is an
+ * uppercase one, which is all the type ladder asks. Pairing them made the key
+ * FOUR_LEVEL_SEMIALPHABETIC, whose `preserve[Lock+LevelThree]` hands Lock back
+ * — so Caps+AltGr capitalised a level that was already capital.
+ */
+function isLower(sym) {
+  const ch = charOf(sym);
+  return !!ch && ch.toLowerCase() === ch && ch.toUpperCase() !== ch;
+}
+function isUpper(sym) {
+  const ch = charOf(sym);
+  return !!ch && ch.toUpperCase() === ch && ch.toLowerCase() !== ch;
+}
+
+/**
+ * The type XKB assigns a key that names none — xkbcomp's `FindAutomaticType`,
+ * which libxkbcommon inherits. Two symbols are ALPHABETIC when they are a
+ * case pair, **KEYPAD when either of them is a keypad keysym**, and TWO_LEVEL
+ * otherwise; three or four are the FOUR_LEVEL family along the same ladder.
+ *
+ * The keypad rung is not decoration: libxkbcommon writes the keypad bare —
+ * `key <KP7> { [ KP_Home, KP_7 ] };` — so *every* keypad key lands here, and
+ * `[KP_Home, KP_7]` is not a case pair. Without the rung it fell through to
+ * TWO_LEVEL, whose `map[Shift]= 2` puts the digit on Shift and leaves NumLock
+ * with nothing to do, which inverted the whole keypad: the digits typed
+ * `KP_Home`/`KP_Up`/`KP_End` and moved the cursor, and holding Shift is what
+ * produced a number. The keymap's own KEYPAD type — `modifiers= Shift+NumLock;
+ * map[NumLock]= 2;` — is the one that belongs.
  */
 function implicitType(syms) {
-  const n = syms.filter(Boolean).length;
+  // The width is the length of the list with only *trailing* NoSymbols
+  // trimmed, which is how libxkbcommon counts it. A NoSymbol in the middle
+  // is a level that types nothing, not an absent one: counting the non-zero
+  // entries instead made `key <ALT> { [ NoSymbol, Alt_L ] };` a one-level key
+  // whose only level was NoSymbol, so <ALT>, <META>, <SUPR> and <HYPR>
+  // decoded to nothing in every modifier state.
+  let n = syms.length;
+  while (n > 0 && !syms[n - 1]) n--;
   if (n <= 1) return 'ONE_LEVEL';
-  const casePair = (a, b) => {
-    const la = charOf(a);
-    const lb = charOf(b);
-    return la && lb && la !== lb && la.toUpperCase() === lb;
-  };
-  if (n === 2) return casePair(syms[0], syms[1]) ? 'ALPHABETIC' : 'TWO_LEVEL';
-  if (casePair(syms[0], syms[1]))
-    return casePair(syms[2], syms[3])
+  const cased = (a, b) => isLower(a) && isUpper(b);
+  const keypad = isKeypad(syms[0]) || isKeypad(syms[1]);
+  if (n === 2) {
+    if (cased(syms[0], syms[1])) return 'ALPHABETIC';
+    return keypad ? 'KEYPAD' : 'TWO_LEVEL';
+  }
+  if (cased(syms[0], syms[1]))
+    return cased(syms[2], syms[3])
       ? 'FOUR_LEVEL_ALPHABETIC'
       : 'FOUR_LEVEL_SEMIALPHABETIC';
-  return 'FOUR_LEVEL';
+  return keypad ? 'FOUR_LEVEL_KEYPAD' : 'FOUR_LEVEL';
 }
 
 /** Everything from `//` or `#` to the end of the line, outside strings. */