stimeo-ui 0.17.0 → 0.18.1

package/dist/controllers/tabs_controller.d.ts

@@ -26,13 +26,15 @@ import { Controller } from '@hotwired/stimulus';
  * (`0` for the active tab, `-1` for the rest), and the panel `hidden` attribute;
  * the consumer owns all styling. The required `list` target marks the tablist
  * container as part of the semantic contract — that container carries
- * `role="tablist"` and an accessible name; the controller performs no runtime
- * work on it.
+ * `role="tablist"` and an accessible name. The controller writes nothing to it;
+ * it reads the container's writing direction for the arrow keys, falling back to
+ * the controller element when the target is absent.
  *
  * Behavior provided:
  * - Click a tab to select it.
- * - `ArrowRight`/`ArrowLeft` move to and select the next/previous tab (wrapping);
- *   `Home`/`End` select the first/last tab.
+ * - The forward horizontal arrow (`ArrowRight`, or `ArrowLeft` when the tablist is
+ *   right-to-left) moves to and selects the next tab, and the backward one the
+ *   previous (wrapping); `Home`/`End` select the first/last tab.
  * - Every selection move is reported: `stimeo--tabs:change` dispatches
  *   `{ index: number, total: number, previous: number, reason: StateReason }`, after
  *   `aria-selected`, the roving `tabindex` and the panels' `hidden` are written
@@ -46,6 +48,7 @@ declare class TabsController extends Controller<HTMLElement> {
     static actions: readonly ["onKeydown", "select"];
     static events: readonly ["change"];
     readonly listTarget: HTMLElement;
+    readonly hasListTarget: boolean;
     readonly tabTargets: HTMLButtonElement[];
     readonly panelTargets: HTMLElement[];
     /**

package/dist/controllers/tabs_controller.js

@@ -30,6 +30,9 @@ function isReservedArrowChord(event, allow = []) {
   if (!event.key.startsWith("Arrow")) return false;
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
+function hasModifierChord(event) {
+  return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
+}
 
 function targetSelector(identifier, name) {
   return `[data-${identifier}-target~="${name}"]`;
@@ -62,11 +65,13 @@ var TabsController = class extends Controller {
   onKeydown(event) {
     if (event.defaultPrevented) return;
     if (isReservedArrowChord(event)) return;
+    if ((event.key === "Home" || event.key === "End") && hasModifierChord(event)) return;
     const tabs = this.tabTargets;
     const currentIndex = tabs.indexOf(event.currentTarget);
     if (currentIndex === -1) return;
     let nextIndex = null;
-    const step = isRtl(this.element) ? -1 : 1;
+    const directionElement = this.hasListTarget ? this.listTarget : this.element;
+    const step = isRtl(directionElement) ? -1 : 1;
     switch (event.key) {
       case "ArrowRight":
         nextIndex = (currentIndex + step + tabs.length) % tabs.length;

package/dist/controllers/tabs_controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/state_reason.ts","../../src/utils/action_source.ts","../../src/utils/logical_scroll.ts","../../src/utils/arrow_step.ts","../../src/utils/target_selector.ts","../../src/controllers/tabs_controller.ts"],"names":[],"mappings":"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","file":"tabs_controller.js","sourcesContent":["/**\n * Why a component's public state moved, carried as `detail.reason`\n * on the state event that reports the move.\n *\n * The attribute a component publishes (`aria-expanded`, `hidden`, `data-state`)\n * only says *what* the state is now. A subscriber that mirrors the state\n * elsewhere, or reports it, needs *why*: closing on `Escape` and closing because\n * the consumer called the action are the same attribute write and different\n * events to the page around it.\n *\n * `\"api\"` is the one every subscriber has to look at. A close the consumer asked\n * for arrives back at their own listener, so a listener that closes something\n * else on `close` loops unless it ignores its own calls.\n *\n * | Reason | The state moved because |\n * | --- | --- |\n * | `\"user\"` | a control of this component was operated |\n * | `\"select\"` | an item inside it was activated |\n * | `\"escape\"` | `Escape` was pressed and this layer owned it |\n * | `\"outside\"` | a pointer landed outside it, or on its backdrop |\n * | `\"focus\"` | focus entered or left it |\n * | `\"pointer\"` | the pointer entered or left it |\n * | `\"scroll\"` | a tracked scroll container scrolled |\n * | `\"api\"` | a public action was called with no DOM event |\n * | `\"timeout\"` | an automatic timer advanced or dismissed the state |\n * | `\"limit\"` | a capacity limit dismissed an item |\n * | `\"media\"` | an operating-system media preference changed |\n */\nexport type StateReason =\n  | \"user\"\n  | \"select\"\n  | \"escape\"\n  | \"outside\"\n  | \"focus\"\n  | \"pointer\"\n  | \"scroll\"\n  | \"api\"\n  | \"timeout\"\n  | \"limit\"\n  | \"media\";\n\n/** Focus modality: the events a focus move delivers to an action. */\nconst FOCUS_EVENTS = new Set([\"blur\", \"focus\", \"focusin\", \"focusout\"]);\n\n/** Pointer modality: the crossing events an action is bound to for hover. */\nconst POINTER_EVENTS = new Set([\"mouseenter\", \"mouseleave\", \"pointerenter\", \"pointerleave\"]);\n\n/**\n * Reads the interaction behind a **public action** from the DOM event it was\n * handed.\n *\n * Stimulus always passes the event to an action it invoked from `data-action`,\n * and a consumer calling the method themselves passes nothing — which is what\n * separates `\"api\"` from the rest.\n *\n * Only an action entry may resolve a reason this way. Inside the component the\n * event type no longer identifies the interaction: one `click` is the trigger\n * being pressed, the page outside being pressed, and an item being activated,\n * and those paths pass their own reason instead.\n *\n * @param event - The event the action received, if any.\n * @returns `\"api\"` with no event, else the modality the event type names, else\n *   `\"user\"`.\n *\n * @example\n * ```ts\n * toggle(event?: Event): void {\n *   this.#apply(!this.#isOpen, stateReasonFor(event));\n * }\n * ```\n */\nexport function stateReasonFor(event?: Event | null): \"user\" | \"focus\" | \"pointer\" | \"api\" {\n  if (!event) return \"api\";\n  if (FOCUS_EVENTS.has(event.type)) return \"focus\";\n  if (POINTER_EVENTS.has(event.type)) return \"pointer\";\n  return \"user\";\n}\n","import { stateReasonFor } from \"./state_reason\";\n\n/** The DOM binding and origin of a public action, or its explicit API element. */\nexport interface ActionSource {\n  readonly event: Event | null;\n  readonly host: Element | null;\n  readonly origin: Element | null;\n  readonly reason: ReturnType<typeof stateReasonFor>;\n}\n\n/**\n * Normalizes an action's DOM event or explicit element without choosing an owned target.\n *\n * Event hosts and origins stay separate so consumers can yield to nested controls.\n * An explicit element supplies both, with no DOM event and an `\"api\"` reason.\n * Consumers resolve current targets and enforce their own scope and interaction rules.\n *\n * @param source - The DOM event, explicit element, or absent optional argument.\n * @returns The source elements, original event and public interaction reason.\n */\nexport function actionSource(source?: Event | HTMLElement): ActionSource {\n  if (source instanceof HTMLElement) {\n    return { event: null, host: source, origin: source, reason: \"api\" };\n  }\n  const event = source ?? null;\n  return {\n    event,\n    host: event?.currentTarget instanceof Element ? event.currentTarget : null,\n    origin: event?.target instanceof Element ? event.target : null,\n    reason: stateReasonFor(event),\n  };\n}\n","/** Normalized scroll position and maximum distance on one logical axis. */\nexport interface LogicalScrollMetrics {\n  position: number;\n  max: number;\n}\n\n/**\n * Whether horizontal scrolling on `element` follows right-to-left inline flow.\n *\n * Resolved from the **computed** `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n *\n * Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n */\nexport function isRtl(element: Element): boolean {\n  return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/**\n * Returns scroll distance from the logical start edge.\n *\n * CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n */\nexport function logicalScrollMetrics(\n  element: HTMLElement,\n  horizontal: boolean,\n): LogicalScrollMetrics {\n  const max = Math.max(\n    0,\n    horizontal\n      ? element.scrollWidth - element.clientWidth\n      : element.scrollHeight - element.clientHeight,\n  );\n  const raw = horizontal ? element.scrollLeft : element.scrollTop;\n  const position = horizontal && isRtl(element) ? -raw : raw;\n  return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/**\n * Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n */\nexport function physicalScrollDelta(\n  element: HTMLElement,\n  horizontal: boolean,\n  logicalDelta: number,\n): number {\n  return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\n}\n","import { isRtl } from \"./logical_scroll\";\n\n/**\n * Turns an arrow key into a **logical** step: `+1` for \"next\", `-1` for\n * \"previous\", `0` when the key names neither.\n *\n * APG defines the horizontal pair as *next / previous* and says a vertical\n * arrangement swaps in Down/Up for the same meaning — so the pair is one axis's\n * spelling of an order, and the order reverses with the writing direction. Only\n * the horizontal pair reverses. Down/Up name an axis the writing direction does\n * not mirror, and returning them unchanged is the point: many controllers fold\n * both pairs into one branch, where swapping the branches under RTL would flip\n * the vertical axis too — a bug that reads as \"the arrows work\" until someone\n * presses Down.\n *\n * **Direction is read from the element the caller passes, which should be the\n * container that lays the items out** — not the focused child. A child may carry\n * its own `dir` (an LTR input inside an RTL form is ordinary authoring), and\n * probing per handler makes two handlers disagree at the boundary between them.\n *\n * This decides direction only. Whether the axis is even active (an\n * `orientation=\"horizontal\"` widget ignoring Down/Up), how far the step lands,\n * and what wrapping does all stay with the caller.\n *\n * **It encodes the list-order convention: `ArrowDown` is *next*.** Widgets that\n * pair the arrows by *value* instead — `ArrowUp` meaning \"more\", as a rating or a\n * slider does — must not use this, or their vertical axis inverts. Reverse the\n * horizontal pair on its own there.\n *\n * @example\n * ```ts\n * const step = logicalArrowStep(event.key, this.element);\n * if (step === 0) return;\n * this.#roving.setActive(rovingMove(current, length, step, \"wrap\"), { focus: true });\n * ```\n */\nexport function logicalArrowStep(key: string, element: Element): 1 | -1 | 0 {\n  if (key === \"ArrowDown\") return 1;\n  if (key === \"ArrowUp\") return -1;\n  if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return 0;\n  const forward = isRtl(element) ? \"ArrowLeft\" : \"ArrowRight\";\n  return key === forward ? 1 : -1;\n}\n\n/**\n * Rewrites `key` so an existing LTR-shaped branch keeps working under RTL:\n * `ArrowRight` and `ArrowLeft` trade places, everything else passes through.\n *\n * The alternative — negating a delta — silently breaks handlers whose two\n * horizontal branches are **not mirror images**. A grid that clamps one edge but\n * not the other, or a segmented field guarding `index > 0` on one side and\n * `index < length - 1` on the other, ends up applying the wrong guard to the\n * wrong direction. Swapping the key leaves each branch, guards and all, exactly\n * where its author put it.\n *\n * Same rule as {@link logicalArrowStep} about which element to read: pass the\n * container that lays the items out, not the focused child.\n *\n * @example\n * ```ts\n * switch (logicalArrowKey(event.key, this.element)) {\n *   case \"ArrowLeft\": // \"previous\" — whatever direction that is on screen\n * ```\n */\nexport function logicalArrowKey(key: string, element: Element): string {\n  if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return key;\n  if (!isRtl(element)) return key;\n  return key === \"ArrowRight\" ? \"ArrowLeft\" : \"ArrowRight\";\n}\n\n/** Modifiers a widget may claim on an arrow key, named for the `allow` list. */\nexport type ArrowModifier = \"alt\" | \"ctrl\" | \"meta\" | \"shift\";\n\n/**\n * True when an arrow key arrived carrying a modifier the widget must leave to\n * the browser: return without calling `preventDefault()` and without moving any\n * state.\n *\n * A bare arrow belongs to the widget; a chorded one usually does not.\n * `Alt`/`Meta` plus a horizontal arrow is history back/forward on every desktop\n * browser, and a widget that swallows it makes the shortcut work or not\n * depending on where focus happens to sit — a coin-flip the user cannot see.\n *\n * `allow` is for the combinations APG assigns to a pattern **and the widget\n * actually implements** — today only Combobox's optional `Alt+Down`/`Alt+Up`.\n * Listing one the widget does not implement defeats the point: the chord then\n * runs the plain-arrow branch, which is exactly what this guard exists to stop.\n * Non-arrow keys return `false`, so chorded letters and\n * `Control+Home`/`Control+End` are untouched.\n *\n * @example\n * ```ts\n * if (isReservedArrowChord(event)) return;\n * ```\n */\nexport function isReservedArrowChord(\n  event: KeyboardEvent,\n  allow: readonly ArrowModifier[] = [],\n): boolean {\n  if (!event.key.startsWith(\"Arrow\")) return false;\n  return (\n    (event.altKey && !allow.includes(\"alt\")) ||\n    (event.ctrlKey && !allow.includes(\"ctrl\")) ||\n    (event.metaKey && !allow.includes(\"meta\")) ||\n    (event.shiftKey && !allow.includes(\"shift\"))\n  );\n}\n\n/**\n * True when a press arrived carrying any modifier, for the keys the browser and\n * the OS own outright: return without calling `preventDefault()` and without\n * moving any state.\n *\n * `Control+Home` and `Control+End` jump the document to its ends, and a widget\n * that swallows them makes the shortcut work or not depending on where focus\n * happens to sit. {@link isReservedArrowChord} answers the same question for the\n * arrows, but returns `false` for every other key so that this one can decide.\n *\n * There is no `allow` list here on purpose. APG assigns no modifier chord to\n * `Home`/`End`, so a widget that wanted one would be claiming a combination the\n * pattern never gave it.\n *\n * @example\n * ```ts\n * case \"Home\":\n * case \"End\":\n *   if (hasModifierChord(event)) return;\n * ```\n */\nexport function hasModifierChord(event: KeyboardEvent): boolean {\n  return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;\n}\n","/**\n * The attribute selector for one declared target, in a controller's own namespace.\n *\n * Stimulus reads `data-<identifier>-target` as a **space-separated token list**, so a\n * single element can carry several target names at once. Matching the attribute value\n * whole would reach only the elements that declare exactly one name, which is why the\n * name is paired with `~=`.\n *\n * `identifier` is the name the controller is registered under, so the selector reaches\n * the markup that registration renders rather than one fixed spelling.\n */\nexport function targetSelector(identifier: string, name: string): string {\n  return `[data-${identifier}-target~=\"${name}\"]`;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { actionSource } from \"../utils/action_source\";\nimport { isReservedArrowChord } from \"../utils/arrow_step\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport type { StateReason } from \"../utils/state_reason\";\nimport { targetSelector } from \"../utils/target_selector\";\n\n/**\n * Headless, accessible tabs behavior.\n *\n * Markup contract (identifier: `stimeo--tabs`):\n *   <div data-controller=\"stimeo--tabs\">\n *     <div role=\"tablist\" aria-label=\"…\" data-stimeo--tabs-target=\"list\">\n *       <button role=\"tab\" id=\"tab-1\" aria-controls=\"panel-1\"\n *               data-stimeo--tabs-target=\"tab\"\n *               data-action=\"click->stimeo--tabs#select\n *                            keydown->stimeo--tabs#onKeydown\">Tab 1</button>\n *       <!-- more tabs -->\n *     </div>\n *     <div role=\"tabpanel\" id=\"panel-1\" aria-labelledby=\"tab-1\"\n *          data-stimeo--tabs-target=\"panel\">…</div>\n *     <!-- more panels -->\n *   </div>\n *\n * Implements the WAI-ARIA APG **Tabs** pattern with **automatic activation**:\n * moving focus with the arrow keys immediately selects the focused tab. Tabs are\n * paired to panels by index (the Nth tab controls the Nth panel).\n *\n * @remarks\n * Behavior only. State is exposed through `aria-selected`, roving `tabindex`\n * (`0` for the active tab, `-1` for the rest), and the panel `hidden` attribute;\n * the consumer owns all styling. The required `list` target marks the tablist\n * container as part of the semantic contract — that container carries\n * `role=\"tablist\"` and an accessible name; the controller performs no runtime\n * work on it.\n *\n * Behavior provided:\n * - Click a tab to select it.\n * - `ArrowRight`/`ArrowLeft` move to and select the next/previous tab (wrapping);\n *   `Home`/`End` select the first/last tab.\n * - Every selection move is reported: `stimeo--tabs:change` dispatches\n *   `{ index: number, total: number, previous: number, reason: StateReason }`, after\n *   `aria-selected`, the roving `tabindex` and the panels' `hidden` are written\n *   and before focus moves. It is informational, so it is not cancelable.\n *   Reselecting the tab that is already selected, the normalization in\n *   {@link connect}, and {@link disconnect} are all silent.\n */\nexport class TabsController extends Controller<HTMLElement> {\n  static override targets = [\"tab\", \"panel\", \"list\"];\n  static actions = [\"onKeydown\", \"select\"] as const;\n  static events = [\"change\"] as const;\n\n  declare readonly listTarget: HTMLElement;\n  declare readonly tabTargets: HTMLButtonElement[];\n  declare readonly panelTargets: HTMLElement[];\n\n  /** Whether selection moves are reported: set once `connect()` settled the baseline. */\n  #reporting = false;\n\n  /**\n   * Selects the initially active tab: the pre-selected one, else the first.\n   *\n   * `findIndex` makes this first-wins when the author marked several — the first\n   * in DOM order is the only deterministic reading of \"which one did they mean\" —\n   * and `#selectIndex` then writes an explicit value onto every tab, so a\n   * forgotten `aria-selected` cannot leave a tab looking unselectable.\n   */\n  override connect(): void {\n    const preselected = this.tabTargets.findIndex(\n      (tab) => tab.getAttribute(\"aria-selected\") === \"true\",\n    );\n    this.#selectIndex(preselected === -1 ? 0 : preselected, { focus: false });\n    this.#reporting = true;\n  }\n\n  /**\n   * Stops reporting until the next `connect()` has settled its baseline, so that\n   * normalization stays silent.\n   */\n  override disconnect(): void {\n    this.#reporting = false;\n  }\n\n  /** Selects the clicked tab. Bound via `data-action` (click). */\n  select(source: Event | HTMLElement): void {\n    const { host, origin, reason } = actionSource(source);\n    const tab = host?.closest<HTMLButtonElement>(targetSelector(this.identifier, \"tab\"));\n    if (!tab || !this.tabTargets.includes(tab)) return;\n    if (origin && origin.closest(`[data-controller~=\"${this.identifier}\"]`) !== this.element)\n      return;\n    const index = this.tabTargets.indexOf(tab);\n    this.#selectIndex(index, { focus: false }, reason);\n  }\n\n  /** Implements arrow/Home/End navigation with automatic activation. */\n  onKeydown(event: KeyboardEvent): void {\n    // A descendant widget that already claimed the key (a grabbed drag handle, a\n    // nested menu) must not ALSO act on it — composition depends on this yield.\n    if (event.defaultPrevented) return;\n    if (isReservedArrowChord(event)) return;\n    const tabs = this.tabTargets;\n    const currentIndex = tabs.indexOf(event.currentTarget as HTMLButtonElement);\n    if (currentIndex === -1) return;\n\n    let nextIndex: number | null = null;\n    // Logical, not physical. APG defines these as \"next / previous control\", and\n    // says a vertical arrangement swaps in Down/Up for the same meaning — so the\n    // pair is one axis's spelling of an order, and the order reverses with the\n    // writing direction. Read from the controller element: the container is what\n    // lays the items out, and a child may carry its own `dir` (an LTR input\n    // inside an RTL form is ordinary authoring).\n    const step = isRtl(this.element) ? -1 : 1;\n    switch (event.key) {\n      case \"ArrowRight\":\n        nextIndex = (currentIndex + step + tabs.length) % tabs.length;\n        break;\n      case \"ArrowLeft\":\n        nextIndex = (currentIndex - step + tabs.length) % tabs.length;\n        break;\n      case \"Home\":\n        nextIndex = 0;\n        break;\n      case \"End\":\n        nextIndex = tabs.length - 1;\n        break;\n      default:\n        return;\n    }\n\n    event.preventDefault();\n    this.#selectIndex(nextIndex, { focus: true });\n  }\n\n  /**\n   * Activates the tab/panel pair at `index`: updates `aria-selected`, the roving\n   * `tabindex`, and panel visibility. Optionally moves focus to the new tab.\n   */\n  #selectIndex(index: number, { focus }: { focus: boolean }, reason: StateReason = \"user\"): void {\n    const tabs = this.tabTargets;\n    const previous = tabs.findIndex((tab) => tab.getAttribute(\"aria-selected\") === \"true\");\n    tabs.forEach((tab, i) => {\n      const selected = i === index;\n      tab.setAttribute(\"aria-selected\", selected ? \"true\" : \"false\");\n      tab.tabIndex = selected ? 0 : -1;\n    });\n    this.panelTargets.forEach((panel, i) => {\n      panel.hidden = i !== index;\n    });\n    if (previous !== index && this.#reporting) {\n      this.dispatch(\"change\", {\n        detail: { index, total: tabs.length, previous, reason },\n        cancelable: false,\n      });\n    }\n    // A subscriber may select a different tab from the handler above; focusing\n    // then leaves the caret on a tab that is no longer the selected one.\n    if (focus && tabs[index]?.getAttribute(\"aria-selected\") === \"true\") tabs[index]?.focus();\n  }\n}\n"]}
+{"version":3,"sources":["../../src/utils/state_reason.ts","../../src/utils/action_source.ts","../../src/utils/logical_scroll.ts","../../src/utils/arrow_step.ts","../../src/utils/target_selector.ts","../../src/controllers/tabs_controller.ts"],"names":[],"mappings":"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","file":"tabs_controller.js","sourcesContent":["/**\n * Why a component's public state moved, carried as `detail.reason`\n * on the state event that reports the move.\n *\n * The attribute a component publishes (`aria-expanded`, `hidden`, `data-state`)\n * only says *what* the state is now. A subscriber that mirrors the state\n * elsewhere, or reports it, needs *why*: closing on `Escape` and closing because\n * the consumer called the action are the same attribute write and different\n * events to the page around it.\n *\n * `\"api\"` is the one every subscriber has to look at. A close the consumer asked\n * for arrives back at their own listener, so a listener that closes something\n * else on `close` loops unless it ignores its own calls.\n *\n * | Reason | The state moved because |\n * | --- | --- |\n * | `\"user\"` | a control of this component was operated |\n * | `\"select\"` | an item inside it was activated |\n * | `\"escape\"` | `Escape` was pressed and this layer owned it |\n * | `\"outside\"` | a pointer landed outside it, or on its backdrop |\n * | `\"focus\"` | focus entered or left it |\n * | `\"pointer\"` | the pointer entered or left it |\n * | `\"scroll\"` | a tracked scroll container scrolled |\n * | `\"api\"` | a public action was called with no DOM event |\n * | `\"timeout\"` | an automatic timer advanced or dismissed the state |\n * | `\"limit\"` | a capacity limit dismissed an item |\n * | `\"media\"` | an operating-system media preference changed |\n */\nexport type StateReason =\n  | \"user\"\n  | \"select\"\n  | \"escape\"\n  | \"outside\"\n  | \"focus\"\n  | \"pointer\"\n  | \"scroll\"\n  | \"api\"\n  | \"timeout\"\n  | \"limit\"\n  | \"media\";\n\n/** Focus modality: the events a focus move delivers to an action. */\nconst FOCUS_EVENTS = new Set([\"blur\", \"focus\", \"focusin\", \"focusout\"]);\n\n/** Pointer modality: the crossing events an action is bound to for hover. */\nconst POINTER_EVENTS = new Set([\"mouseenter\", \"mouseleave\", \"pointerenter\", \"pointerleave\"]);\n\n/**\n * Reads the interaction behind a **public action** from the DOM event it was\n * handed.\n *\n * Stimulus always passes the event to an action it invoked from `data-action`,\n * and a consumer calling the method themselves passes nothing — which is what\n * separates `\"api\"` from the rest.\n *\n * Only an action entry may resolve a reason this way. Inside the component the\n * event type no longer identifies the interaction: one `click` is the trigger\n * being pressed, the page outside being pressed, and an item being activated,\n * and those paths pass their own reason instead.\n *\n * @param event - The event the action received, if any.\n * @returns `\"api\"` with no event, else the modality the event type names, else\n *   `\"user\"`.\n *\n * @example\n * ```ts\n * toggle(event?: Event): void {\n *   this.#apply(!this.#isOpen, stateReasonFor(event));\n * }\n * ```\n */\nexport function stateReasonFor(event?: Event | null): \"user\" | \"focus\" | \"pointer\" | \"api\" {\n  if (!event) return \"api\";\n  if (FOCUS_EVENTS.has(event.type)) return \"focus\";\n  if (POINTER_EVENTS.has(event.type)) return \"pointer\";\n  return \"user\";\n}\n","import { stateReasonFor } from \"./state_reason\";\n\n/** The DOM binding and origin of a public action, or its explicit API element. */\nexport interface ActionSource {\n  readonly event: Event | null;\n  readonly host: Element | null;\n  readonly origin: Element | null;\n  readonly reason: ReturnType<typeof stateReasonFor>;\n}\n\n/**\n * Normalizes an action's DOM event or explicit element without choosing an owned target.\n *\n * Event hosts and origins stay separate so consumers can yield to nested controls.\n * An explicit element supplies both, with no DOM event and an `\"api\"` reason.\n * Consumers resolve current targets and enforce their own scope and interaction rules.\n *\n * @param source - The DOM event, explicit element, or absent optional argument.\n * @returns The source elements, original event and public interaction reason.\n */\nexport function actionSource(source?: Event | HTMLElement): ActionSource {\n  if (source instanceof HTMLElement) {\n    return { event: null, host: source, origin: source, reason: \"api\" };\n  }\n  const event = source ?? null;\n  return {\n    event,\n    host: event?.currentTarget instanceof Element ? event.currentTarget : null,\n    origin: event?.target instanceof Element ? event.target : null,\n    reason: stateReasonFor(event),\n  };\n}\n","/** Normalized scroll position and maximum distance on one logical axis. */\nexport interface LogicalScrollMetrics {\n  position: number;\n  max: number;\n}\n\n/**\n * Whether horizontal scrolling on `element` follows right-to-left inline flow.\n *\n * Resolved from the **computed** `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n *\n * Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n */\nexport function isRtl(element: Element): boolean {\n  return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/**\n * Returns scroll distance from the logical start edge.\n *\n * CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n */\nexport function logicalScrollMetrics(\n  element: HTMLElement,\n  horizontal: boolean,\n): LogicalScrollMetrics {\n  const max = Math.max(\n    0,\n    horizontal\n      ? element.scrollWidth - element.clientWidth\n      : element.scrollHeight - element.clientHeight,\n  );\n  const raw = horizontal ? element.scrollLeft : element.scrollTop;\n  const position = horizontal && isRtl(element) ? -raw : raw;\n  return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/**\n * Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n */\nexport function physicalScrollDelta(\n  element: HTMLElement,\n  horizontal: boolean,\n  logicalDelta: number,\n): number {\n  return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\n}\n","import { isRtl } from \"./logical_scroll\";\n\n/**\n * Turns an arrow key into a **logical** step: `+1` for \"next\", `-1` for\n * \"previous\", `0` when the key names neither.\n *\n * APG defines the horizontal pair as *next / previous* and says a vertical\n * arrangement swaps in Down/Up for the same meaning — so the pair is one axis's\n * spelling of an order, and the order reverses with the writing direction. Only\n * the horizontal pair reverses. Down/Up name an axis the writing direction does\n * not mirror, and returning them unchanged is the point: many controllers fold\n * both pairs into one branch, where swapping the branches under RTL would flip\n * the vertical axis too — a bug that reads as \"the arrows work\" until someone\n * presses Down.\n *\n * **Direction is read from the element the caller passes, which should be the\n * container that lays the items out** — not the focused child. A child may carry\n * its own `dir` (an LTR input inside an RTL form is ordinary authoring), and\n * probing per handler makes two handlers disagree at the boundary between them.\n *\n * This decides direction only. Whether the axis is even active (an\n * `orientation=\"horizontal\"` widget ignoring Down/Up), how far the step lands,\n * and what wrapping does all stay with the caller.\n *\n * **It encodes the list-order convention: `ArrowDown` is *next*.** Widgets that\n * pair the arrows by *value* instead — `ArrowUp` meaning \"more\", as a rating or a\n * slider does — must not use this, or their vertical axis inverts. Reverse the\n * horizontal pair on its own there.\n *\n * @example\n * ```ts\n * const step = logicalArrowStep(event.key, this.element);\n * if (step === 0) return;\n * this.#roving.setActive(rovingMove(current, length, step, \"wrap\"), { focus: true });\n * ```\n */\nexport function logicalArrowStep(key: string, element: Element): 1 | -1 | 0 {\n  if (key === \"ArrowDown\") return 1;\n  if (key === \"ArrowUp\") return -1;\n  if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return 0;\n  const forward = isRtl(element) ? \"ArrowLeft\" : \"ArrowRight\";\n  return key === forward ? 1 : -1;\n}\n\n/**\n * Rewrites `key` so an existing LTR-shaped branch keeps working under RTL:\n * `ArrowRight` and `ArrowLeft` trade places, everything else passes through.\n *\n * The alternative — negating a delta — silently breaks handlers whose two\n * horizontal branches are **not mirror images**. A grid that clamps one edge but\n * not the other, or a segmented field guarding `index > 0` on one side and\n * `index < length - 1` on the other, ends up applying the wrong guard to the\n * wrong direction. Swapping the key leaves each branch, guards and all, exactly\n * where its author put it.\n *\n * Same rule as {@link logicalArrowStep} about which element to read: pass the\n * container that lays the items out, not the focused child.\n *\n * @example\n * ```ts\n * switch (logicalArrowKey(event.key, this.element)) {\n *   case \"ArrowLeft\": // \"previous\" — whatever direction that is on screen\n * ```\n */\nexport function logicalArrowKey(key: string, element: Element): string {\n  if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return key;\n  if (!isRtl(element)) return key;\n  return key === \"ArrowRight\" ? \"ArrowLeft\" : \"ArrowRight\";\n}\n\n/**\n * The element whose writing direction orders a grid's columns: the nearest\n * `<table>` holding `grid` inside `root`, else `grid` itself. Table columns follow\n * the table's direction, so a direction declared only on a row group such as\n * `<tbody>` does not reorder them and must not reverse the arrows either.\n */\nexport function gridDirectionElement(grid: Element, root: Element): Element {\n  const table = grid.closest(\"table\");\n  return table !== null && root.contains(table) ? table : grid;\n}\n\n/** Modifiers a widget may claim on an arrow key, named for the `allow` list. */\nexport type ArrowModifier = \"alt\" | \"ctrl\" | \"meta\" | \"shift\";\n\n/**\n * True when an arrow key arrived carrying a modifier the widget must leave to\n * the browser: return without calling `preventDefault()` and without moving any\n * state.\n *\n * A bare arrow belongs to the widget; a chorded one usually does not.\n * `Alt`/`Meta` plus a horizontal arrow is history back/forward on every desktop\n * browser, and a widget that swallows it makes the shortcut work or not\n * depending on where focus happens to sit — a coin-flip the user cannot see.\n *\n * `allow` is for the combinations APG assigns to a pattern **and the widget\n * actually implements** — for example `Alt+Down`/`Alt+Up`, which the APG Combobox\n * pattern makes optional and `stimeo--combobox` implements.\n * Listing one the widget does not implement defeats the point: the chord then\n * runs the plain-arrow branch, which is exactly what this guard exists to stop.\n * Non-arrow keys return `false`, so chorded letters and\n * `Control+Home`/`Control+End` are untouched.\n *\n * @example\n * ```ts\n * if (isReservedArrowChord(event)) return;\n * ```\n */\nexport function isReservedArrowChord(\n  event: KeyboardEvent,\n  allow: readonly ArrowModifier[] = [],\n): boolean {\n  if (!event.key.startsWith(\"Arrow\")) return false;\n  return (\n    (event.altKey && !allow.includes(\"alt\")) ||\n    (event.ctrlKey && !allow.includes(\"ctrl\")) ||\n    (event.metaKey && !allow.includes(\"meta\")) ||\n    (event.shiftKey && !allow.includes(\"shift\"))\n  );\n}\n\n/**\n * True when a press carries Alt, Control, Meta, or Shift, regardless of its key.\n *\n * This predicate reports modifier presence only; key ownership stays with the\n * caller. Check the widget's implemented key/modifier bindings and their state\n * conditions before using this result to yield a chord. An unimplemented chord\n * must not fall through to the bare-key behavior.\n *\n * Dedicated bindings, such as a grid's Control+Home/End navigation, belong in\n * the caller. Unlike {@link isReservedArrowChord}, this function examines every\n * key and has no arrow-specific reservation or `allow` list.\n *\n * @example\n * ```ts\n * // A Home/End handler with no modifier bindings yields every modified press.\n * case \"Home\":\n * case \"End\":\n *   if (hasModifierChord(event)) return;\n * ```\n */\nexport function hasModifierChord(event: KeyboardEvent): boolean {\n  return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;\n}\n","/**\n * The attribute selector for one declared target, in a controller's own namespace.\n *\n * Stimulus reads `data-<identifier>-target` as a **space-separated token list**, so a\n * single element can carry several target names at once. Matching the attribute value\n * whole would reach only the elements that declare exactly one name, which is why the\n * name is paired with `~=`.\n *\n * `identifier` is the name the controller is registered under, so the selector reaches\n * the markup that registration renders rather than one fixed spelling.\n */\nexport function targetSelector(identifier: string, name: string): string {\n  return `[data-${identifier}-target~=\"${name}\"]`;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { actionSource } from \"../utils/action_source\";\nimport { hasModifierChord, isReservedArrowChord } from \"../utils/arrow_step\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport type { StateReason } from \"../utils/state_reason\";\nimport { targetSelector } from \"../utils/target_selector\";\n\n/**\n * Headless, accessible tabs behavior.\n *\n * Markup contract (identifier: `stimeo--tabs`):\n *   <div data-controller=\"stimeo--tabs\">\n *     <div role=\"tablist\" aria-label=\"…\" data-stimeo--tabs-target=\"list\">\n *       <button role=\"tab\" id=\"tab-1\" aria-controls=\"panel-1\"\n *               data-stimeo--tabs-target=\"tab\"\n *               data-action=\"click->stimeo--tabs#select\n *                            keydown->stimeo--tabs#onKeydown\">Tab 1</button>\n *       <!-- more tabs -->\n *     </div>\n *     <div role=\"tabpanel\" id=\"panel-1\" aria-labelledby=\"tab-1\"\n *          data-stimeo--tabs-target=\"panel\">…</div>\n *     <!-- more panels -->\n *   </div>\n *\n * Implements the WAI-ARIA APG **Tabs** pattern with **automatic activation**:\n * moving focus with the arrow keys immediately selects the focused tab. Tabs are\n * paired to panels by index (the Nth tab controls the Nth panel).\n *\n * @remarks\n * Behavior only. State is exposed through `aria-selected`, roving `tabindex`\n * (`0` for the active tab, `-1` for the rest), and the panel `hidden` attribute;\n * the consumer owns all styling. The required `list` target marks the tablist\n * container as part of the semantic contract — that container carries\n * `role=\"tablist\"` and an accessible name. The controller writes nothing to it;\n * it reads the container's writing direction for the arrow keys, falling back to\n * the controller element when the target is absent.\n *\n * Behavior provided:\n * - Click a tab to select it.\n * - The forward horizontal arrow (`ArrowRight`, or `ArrowLeft` when the tablist is\n *   right-to-left) moves to and selects the next tab, and the backward one the\n *   previous (wrapping); `Home`/`End` select the first/last tab.\n * - Every selection move is reported: `stimeo--tabs:change` dispatches\n *   `{ index: number, total: number, previous: number, reason: StateReason }`, after\n *   `aria-selected`, the roving `tabindex` and the panels' `hidden` are written\n *   and before focus moves. It is informational, so it is not cancelable.\n *   Reselecting the tab that is already selected, the normalization in\n *   {@link connect}, and {@link disconnect} are all silent.\n */\nexport class TabsController extends Controller<HTMLElement> {\n  static override targets = [\"tab\", \"panel\", \"list\"];\n  static actions = [\"onKeydown\", \"select\"] as const;\n  static events = [\"change\"] as const;\n\n  declare readonly listTarget: HTMLElement;\n  declare readonly hasListTarget: boolean;\n  declare readonly tabTargets: HTMLButtonElement[];\n  declare readonly panelTargets: HTMLElement[];\n\n  /** Whether selection moves are reported: set once `connect()` settled the baseline. */\n  #reporting = false;\n\n  /**\n   * Selects the initially active tab: the pre-selected one, else the first.\n   *\n   * `findIndex` makes this first-wins when the author marked several — the first\n   * in DOM order is the only deterministic reading of \"which one did they mean\" —\n   * and `#selectIndex` then writes an explicit value onto every tab, so a\n   * forgotten `aria-selected` cannot leave a tab looking unselectable.\n   */\n  override connect(): void {\n    const preselected = this.tabTargets.findIndex(\n      (tab) => tab.getAttribute(\"aria-selected\") === \"true\",\n    );\n    this.#selectIndex(preselected === -1 ? 0 : preselected, { focus: false });\n    this.#reporting = true;\n  }\n\n  /**\n   * Stops reporting until the next `connect()` has settled its baseline, so that\n   * normalization stays silent.\n   */\n  override disconnect(): void {\n    this.#reporting = false;\n  }\n\n  /** Selects the clicked tab. Bound via `data-action` (click). */\n  select(source: Event | HTMLElement): void {\n    const { host, origin, reason } = actionSource(source);\n    const tab = host?.closest<HTMLButtonElement>(targetSelector(this.identifier, \"tab\"));\n    if (!tab || !this.tabTargets.includes(tab)) return;\n    if (origin && origin.closest(`[data-controller~=\"${this.identifier}\"]`) !== this.element)\n      return;\n    const index = this.tabTargets.indexOf(tab);\n    this.#selectIndex(index, { focus: false }, reason);\n  }\n\n  /** Implements arrow/Home/End navigation with automatic activation. */\n  onKeydown(event: KeyboardEvent): void {\n    // A descendant widget that already claimed the key (a grabbed drag handle, a\n    // nested menu) must not ALSO act on it — composition depends on this yield.\n    if (event.defaultPrevented) return;\n    if (isReservedArrowChord(event)) return;\n    if ((event.key === \"Home\" || event.key === \"End\") && hasModifierChord(event)) return;\n    const tabs = this.tabTargets;\n    const currentIndex = tabs.indexOf(event.currentTarget as HTMLButtonElement);\n    if (currentIndex === -1) return;\n\n    let nextIndex: number | null = null;\n    /**\n     * Horizontal navigation follows the current tablist's computed direction.\n     * A missing list uses the controller element, while a tab's own direction\n     * never changes the sequence.\n     */\n    const directionElement = this.hasListTarget ? this.listTarget : this.element;\n    const step = isRtl(directionElement) ? -1 : 1;\n    switch (event.key) {\n      case \"ArrowRight\":\n        nextIndex = (currentIndex + step + tabs.length) % tabs.length;\n        break;\n      case \"ArrowLeft\":\n        nextIndex = (currentIndex - step + tabs.length) % tabs.length;\n        break;\n      case \"Home\":\n        nextIndex = 0;\n        break;\n      case \"End\":\n        nextIndex = tabs.length - 1;\n        break;\n      default:\n        return;\n    }\n\n    event.preventDefault();\n    this.#selectIndex(nextIndex, { focus: true });\n  }\n\n  /**\n   * Activates the tab/panel pair at `index`: updates `aria-selected`, the roving\n   * `tabindex`, and panel visibility. Optionally moves focus to the new tab.\n   */\n  #selectIndex(index: number, { focus }: { focus: boolean }, reason: StateReason = \"user\"): void {\n    const tabs = this.tabTargets;\n    const previous = tabs.findIndex((tab) => tab.getAttribute(\"aria-selected\") === \"true\");\n    tabs.forEach((tab, i) => {\n      const selected = i === index;\n      tab.setAttribute(\"aria-selected\", selected ? \"true\" : \"false\");\n      tab.tabIndex = selected ? 0 : -1;\n    });\n    this.panelTargets.forEach((panel, i) => {\n      panel.hidden = i !== index;\n    });\n    if (previous !== index && this.#reporting) {\n      this.dispatch(\"change\", {\n        detail: { index, total: tabs.length, previous, reason },\n        cancelable: false,\n      });\n    }\n    // A subscriber may select a different tab from the handler above; focusing\n    // then leaves the caret on a tab that is no longer the selected one.\n    if (focus && tabs[index]?.getAttribute(\"aria-selected\") === \"true\") tabs[index]?.focus();\n  }\n}\n"]}

package/dist/controllers/tags_input_controller.d.ts

@@ -29,8 +29,8 @@ import { Controller } from '@hotwired/stimulus';
  *
  * There is no single established APG pattern; this composes a labeled text input
  * with a roving-tabindex list of removable chips, mapping to WCAG 2.1.1, 2.4.7,
- * 4.1.2, 4.1.3, and 1.3.1. Unlike {@link MultiSelectController} (pick from a
- * candidate list) the user types arbitrary strings.
+ * 4.1.2, 4.1.3, and 1.3.1. Unlike `stimeo--multi-select` (pick from a candidate
+ * list) the user types arbitrary strings.
  *
  * Behavior provided:
  * - `Enter` or the configured delimiter commits the trimmed input as a tag.
@@ -48,8 +48,9 @@ import { Controller } from '@hotwired/stimulus';
  *   DOM/Turbo tag changes dispatch `stimeo--tags-input:reconcile`; authored
  *   templates route localized addition/removal text to the shared announcer.
  * - The remove buttons form one roving Tab stop: `ArrowLeft`/`ArrowRight` move
- *   between them (right past the end returns to the input), `Delete`/`Backspace`
+ *   between them (past the logical end returns to the input), `Delete`/`Backspace`
  *   delete the focused tag, and `Backspace` on an empty input deletes the last.
+ *   The current `tags` container defines horizontal direction for the chips and input boundary.
  * - Removing from a chip moves focus to its neighbor (else the input); removing
  *   via empty-input `Backspace` keeps focus in the input for continued editing.
  * `change` and `reconcile` dispatch `{ tags: string[] }`; `reject` dispatches

package/dist/controllers/tags_input_controller.js

@@ -1,5 +1,12 @@
 import { Controller } from '@hotwired/stimulus';
 
+function fillTemplate(template, values) {
+  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
+    const replacement = Object.hasOwn(values, name) ? values[name] : void 0;
+    return replacement === void 0 ? match : String(replacement);
+  });
+}
+
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -9,12 +16,6 @@ function announce(message, options = {}) {
     })
   );
 }
-function fillTemplate(template, values) {
-  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
-    const replacement = values[name];
-    return replacement === void 0 ? match : String(replacement);
-  });
-}
 
 function isRtl(element) {
   return window.getComputedStyle(element).direction === "rtl";
@@ -67,7 +68,7 @@ var RovingTabindex = class {
 };
 
 var ChipRow = class {
-  #directionElement;
+  #getDirectionElement;
   #getItems;
   #getButton;
   #onRemove;
@@ -75,7 +76,7 @@ var ChipRow = class {
   #roving = new RovingTabindex(() => this.buttons);
   #container = null;
   constructor(options) {
-    this.#directionElement = options.directionElement;
+    this.#getDirectionElement = options.getDirectionElement;
     this.#getItems = options.getItems;
     this.#getButton = options.getButton ?? ((item) => matchingPart(item, "button"));
     this.#onRemove = options.onRemove;
@@ -156,7 +157,7 @@ var ChipRow = class {
     if (!entry) return;
     const buttons = entry.buttons;
     const index = entry.buttonIndex;
-    switch (logicalArrowKey(event.key, this.#directionElement)) {
+    switch (logicalArrowKey(event.key, this.#getDirectionElement())) {
       case "ArrowLeft":
         if (index > 0) {
           event.preventDefault();
@@ -186,63 +187,182 @@ var COMPOSITION_INPUT_TYPES = /* @__PURE__ */ new Set([
   "deleteCompositionText",
   "deleteByComposition"
 ]);
+function isCompositionInputType(inputType) {
+  return inputType !== void 0 && COMPOSITION_INPUT_TYPES.has(inputType);
+}
+var BEFORE_MORPH_ATTRIBUTE = "turbo:before-morph-attribute";
+var textOf = (element) => element.value;
+var holdsFocus = (element) => element instanceof Node && element.getRootNode().activeElement === element;
 var CompositionTracker = class {
   #observedTargets = /* @__PURE__ */ new Set();
-  #activeTargets = /* @__PURE__ */ new Set();
+  #composition = null;
   #onStart;
   #onEnd;
+  #onAbandon;
   #confirmedTarget = null;
+  #keyComposing = false;
+  #connected = false;
+  #abandoned = null;
   constructor(options = {}) {
     this.#onStart = options.onStart;
     this.#onEnd = options.onEnd;
+    this.#onAbandon = options.onAbandon;
   }
   observe(target) {
+    this.#connected = true;
     if (this.#observedTargets.has(target)) return;
     target.addEventListener("compositionstart", this.#handleStart);
     target.addEventListener("compositionend", this.#handleEnd);
-    target.addEventListener("keydown", this.#handleKeydown);
+    target.addEventListener("keydown", this.#handleKeydown, true);
+    target.addEventListener("beforeinput", this.#handleBeforeInput, true);
+    target.addEventListener("input", this.#handleInput, true);
+    target.addEventListener("blur", this.#handleBlur, true);
+    target.addEventListener(BEFORE_MORPH_ATTRIBUTE, this.#handleBeforeMorphAttribute);
     this.#observedTargets.add(target);
   }
   unobserve(target) {
     if (!this.#observedTargets.delete(target)) return;
-    target.removeEventListener("compositionstart", this.#handleStart);
-    target.removeEventListener("compositionend", this.#handleEnd);
-    target.removeEventListener("keydown", this.#handleKeydown);
-    this.#activeTargets.delete(target);
+    this.#release(target);
+    if (this.#composition?.target === target) this.#letGo();
     if (this.#confirmedTarget === target) this.#confirmedTarget = null;
   }
   disconnect() {
-    for (const target of this.#observedTargets) {
-      target.removeEventListener("compositionstart", this.#handleStart);
-      target.removeEventListener("compositionend", this.#handleEnd);
-      target.removeEventListener("keydown", this.#handleKeydown);
-    }
+    this.#connected = false;
+    for (const target of this.#observedTargets) this.#release(target);
     this.#observedTargets.clear();
-    this.#activeTargets.clear();
+    this.#letGo();
     this.#confirmedTarget = null;
+    this.#keyComposing = false;
+    this.#abandoned = null;
   }
   isComposing(event) {
-    return this.#activeTargets.size > 0 || event?.isComposing === true;
+    this.#settle();
+    return event?.isComposing === true || this.#composition !== null;
+  }
+  composingElement() {
+    this.#settle();
+    return this.#composition?.element ?? null;
+  }
+  owns(event) {
+    const element = this.composingElement();
+    return event.isComposing === true || element !== null && element === event.target;
   }
   consumesConfirmedInput(event) {
     const confirmed = this.#confirmedTarget;
     this.#confirmedTarget = null;
     if (confirmed === null || confirmed !== event.target) return false;
     const inputType = event.inputType;
-    return !inputType || COMPOSITION_INPUT_TYPES.has(inputType);
+    return !inputType || isCompositionInputType(inputType);
   }
+  #release(target) {
+    target.removeEventListener("compositionstart", this.#handleStart);
+    target.removeEventListener("compositionend", this.#handleEnd);
+    target.removeEventListener("keydown", this.#handleKeydown, true);
+    target.removeEventListener("beforeinput", this.#handleBeforeInput, true);
+    target.removeEventListener("input", this.#handleInput, true);
+    target.removeEventListener("blur", this.#handleBlur, true);
+    target.removeEventListener(BEFORE_MORPH_ATTRIBUTE, this.#handleBeforeMorphAttribute);
+  }
+  #letGo() {
+    const composition = this.#composition;
+    if (composition === null) return;
+    if (!holdsFocus(composition.element)) {
+      this.#composition = null;
+      return;
+    }
+    queueMicrotask(() => {
+      if (this.#composition !== composition || this.#observedTargets.has(composition.target)) {
+        return;
+      }
+      this.#composition = null;
+      if (!this.#connected) return;
+      this.#abandoned = { element: composition.element, inPlace: true };
+      this.#runAbandon();
+    });
+  }
+  #settle() {
+    const composition = this.#composition;
+    if (composition === null) return;
+    const { target, element, text } = composition;
+    if (target instanceof Node && element instanceof Node && !target.contains(element)) {
+      this.#composition = null;
+    } else if (textOf(element) !== text) {
+      this.#abandon(false);
+    }
+  }
+  #abandon(inPlace) {
+    this.#owe(inPlace);
+    this.#composition = null;
+    queueMicrotask(this.#runAbandon);
+  }
+  #owe(inPlace) {
+    const composition = this.#composition;
+    if (composition !== null) this.#abandoned = { element: composition.element, inPlace };
+  }
+  #runAbandon = () => {
+    const abandoned = this.#abandoned;
+    if (abandoned === null) return;
+    this.#abandoned = null;
+    this.#onAbandon?.(abandoned.element, abandoned.inPlace);
+  };
   #handleStart = (event) => {
     this.#confirmedTarget = null;
-    if (event.currentTarget) this.#activeTargets.add(event.currentTarget);
+    this.#settle();
+    this.#owe(true);
+    const target = event.currentTarget;
+    const element = event.target;
+    this.#composition = { target, element, text: textOf(element) };
+    this.#runAbandon();
     this.#onStart?.(event);
   };
   #handleEnd = (event) => {
-    if (event.currentTarget) this.#activeTargets.delete(event.currentTarget);
+    this.#runAbandon();
+    if (this.#composition?.target === event.currentTarget) this.#composition = null;
     this.#confirmedTarget = event.target;
     this.#onEnd?.(event);
   };
-  #handleKeydown = () => {
+  #handleKeydown = (event) => {
+    this.#settle();
+    this.#runAbandon();
     this.#confirmedTarget = null;
+    this.#keyComposing = event.isComposing === true;
+  };
+  #handleBeforeInput = (event) => {
+    const keyComposing = this.#keyComposing;
+    this.#keyComposing = false;
+    this.#settle();
+    const { isComposing, inputType } = event;
+    if (this.#composition !== null && !keyComposing && !isComposing && inputType && !isCompositionInputType(inputType)) {
+      this.#abandon(true);
+    }
+    this.#runAbandon();
+  };
+  #handleInput = (event) => {
+    const composition = this.#composition;
+    const { isTrusted, isComposing, inputType } = event;
+    if (composition !== null && event.target === composition.element && (isTrusted || isComposing || isCompositionInputType(inputType))) {
+      composition.text = textOf(composition.element);
+    } else {
+      this.#settle();
+    }
+    this.#runAbandon();
+  };
+  #handleBlur = (event) => {
+    this.#settle();
+    this.#runAbandon();
+    const composition = this.#composition;
+    if (composition === null || composition.target === composition.element) return;
+    const { element } = composition;
+    if (!(element instanceof Node) || event.target !== element) return;
+    const root = element.getRootNode();
+    if (root.activeElement !== element) this.#composition = null;
+  };
+  #handleBeforeMorphAttribute = (event) => {
+    this.#settle();
+    const composition = this.#composition;
+    if (composition?.target !== event.currentTarget || event.target !== composition.element) return;
+    const detail = event.detail;
+    if (detail?.attributeName === "value") event.preventDefault();
   };
 };
 
@@ -295,6 +415,9 @@ var MicrotaskCoalescer = class {
     this.#queued = false;
     this.#generation += 1;
   }
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -325,6 +448,9 @@ var MorphRenderWatcher = class {
   schedule() {
     this.#pass.schedule();
   }
+  get pending() {
+    return this.#pass.pending;
+  }
   disconnect() {
     this.#listeners.dispose();
     this.#pass.cancel();
@@ -481,7 +607,7 @@ var TagsInputController = class _TagsInputController extends Controller {
   });
   #reconcile = new MorphRenderWatcher(() => this.#reconcileTags());
   #chipRow = new ChipRow({
-    directionElement: this.element,
+    getDirectionElement: () => this.#chipDirectionElement,
     getItems: () => this.tagTargets,
     getButton: (tag) => matchingPart(tag, `button${this.#rows.selector("remove")}`),
     onRemove: (index) => this.#removeAt(index),
@@ -554,7 +680,7 @@ var TagsInputController = class _TagsInputController extends Controller {
       }
       return;
     }
-    if (logicalArrowKey(event.key, this.element) === "ArrowLeft" && this.inputTarget.value === "") {
+    if (logicalArrowKey(event.key, this.#chipDirectionElement) === "ArrowLeft" && this.inputTarget.value === "") {
       if (this.#chipRow.length > 0) {
         event.preventDefault();
         this.#chipRow.focusLast();
@@ -607,6 +733,9 @@ var TagsInputController = class _TagsInputController extends Controller {
     }
     if (!this.#chipRow.focusAfterRemoval(index)) this.#focusInput();
   }
+  get #chipDirectionElement() {
+    return this.hasTagsTarget ? this.tagsTarget : this.element;
+  }
   #focusInput() {
     if (this.hasInputTarget) this.inputTarget.focus();
   }