stimeo-ui 0.16.0 → 0.17.0

package/dist/controllers/input_mask_controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/composition_tracker.ts","../../src/utils/declared_value.ts","../../src/utils/focus_candidate.ts","../../src/utils/half_width.ts","../../src/controllers/input_mask_controller.ts"],"names":[],"mappings":"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","file":"input_mask_controller.js","sourcesContent":["/** Minimal event shape carrying the platform's per-event composition signal. */\nexport interface CompositionSignal {\n  readonly isComposing?: boolean;\n}\n\n/** Minimal `input` shape needed to tell a composition echo from a fresh edit. */\nexport interface ConfirmedInputSignal {\n  readonly target: EventTarget | null;\n  readonly inputType?: string;\n}\n\n/**\n * The `inputType` values an engine reports on an `input` that belongs to a\n * composition rather than to an edit the user just made.\n */\nconst COMPOSITION_INPUT_TYPES = new Set([\n  \"insertCompositionText\",\n  \"insertFromComposition\",\n  \"deleteCompositionText\",\n  \"deleteByComposition\",\n]);\n\n/** Hooks that keep component-specific work outside {@link CompositionTracker}. */\nexport interface CompositionTrackerOptions {\n  /** Runs after lifecycle state is set for a `compositionstart` event. */\n  readonly onStart?: (event: Event) => void;\n  /** Runs after lifecycle state is cleared for a `compositionend` event. */\n  readonly onEnd?: (event: Event) => void;\n}\n\n/**\n * Owns IME composition listeners and transient state for one or more event targets.\n *\n * Some browsers omit `KeyboardEvent.isComposing` on the keydown that confirms a\n * conversion. Tracking `compositionstart` through `compositionend` supplies the\n * missing lifecycle signal without relying on deprecated numeric key codes.\n * Component policy stays with the consumer: filtering, validation, and submission\n * belong in the optional {@link CompositionTrackerOptions.onEnd} callback.\n *\n * The tracker also owns the other half of that lifecycle: **the `input` some\n * engines send after `compositionend` to echo the text just confirmed.** A\n * consumer that ran `onEnd` and then handled the echo would commit the same\n * confirmation twice, so {@link CompositionTracker.consumesConfirmedInput} tells\n * the echo apart and the consumer returns early on it.\n *\n * **What the echo is not, is the harder half.** Not every engine sends one —\n * Chromium ends a confirmation at `compositionend` with no `input` after it — so\n * a window that waits for the echo and only closes on the next key would swallow\n * the first edit that arrives without one: dictation, autofill, a drop,\n * `insertText`. Two things keep that from happening. The window closes on the\n * next anything — a key, a new composition, any `input`, losing the field — and\n * an `input` that reports an `inputType` outside {@link COMPOSITION_INPUT_TYPES}\n * is an edit, so it is never folded. Only an engine that reports no `inputType`\n * at all is left relying on the window alone.\n *\n * @example\n * ```ts\n * #composition = new CompositionTracker({ onEnd: () => this.filter() });\n *\n * connect(): void {\n *   this.#composition.observe(this.inputTarget);\n * }\n *\n * disconnect(): void {\n *   this.#composition.disconnect();\n * }\n *\n * onInput(event: InputEvent): void {\n *   if (this.#composition.consumesConfirmedInput(event)) return;\n *   if (this.#composition.isComposing(event)) return;\n * }\n *\n * onKeydown(event: KeyboardEvent): void {\n *   if (this.#composition.isComposing(event)) return;\n * }\n * ```\n */\nexport class CompositionTracker {\n  readonly #observedTargets = new Set<EventTarget>();\n  readonly #activeTargets = new Set<EventTarget>();\n  readonly #onStart: ((event: Event) => void) | undefined;\n  readonly #onEnd: ((event: Event) => void) | undefined;\n  /** The field whose confirming `input` is still owed, while the window is open. */\n  #confirmedTarget: EventTarget | null = null;\n\n  constructor(options: CompositionTrackerOptions = {}) {\n    this.#onStart = options.onStart;\n    this.#onEnd = options.onEnd;\n  }\n\n  /** Starts lifecycle tracking for `target`; repeated calls are idempotent. */\n  observe(target: EventTarget): void {\n    if (this.#observedTargets.has(target)) return;\n    target.addEventListener(\"compositionstart\", this.#handleStart);\n    target.addEventListener(\"compositionend\", this.#handleEnd);\n    target.addEventListener(\"keydown\", this.#handleKeydown);\n    this.#observedTargets.add(target);\n  }\n\n  /** Stops tracking one target and clears any active composition it owned. */\n  unobserve(target: EventTarget): void {\n    if (!this.#observedTargets.delete(target)) return;\n    target.removeEventListener(\"compositionstart\", this.#handleStart);\n    target.removeEventListener(\"compositionend\", this.#handleEnd);\n    target.removeEventListener(\"keydown\", this.#handleKeydown);\n    this.#activeTargets.delete(target);\n    if (this.#confirmedTarget === target) this.#confirmedTarget = null;\n  }\n\n  /** Releases every listener and clears state so reconnect starts cleanly. */\n  disconnect(): void {\n    for (const target of this.#observedTargets) {\n      target.removeEventListener(\"compositionstart\", this.#handleStart);\n      target.removeEventListener(\"compositionend\", this.#handleEnd);\n      target.removeEventListener(\"keydown\", this.#handleKeydown);\n    }\n    this.#observedTargets.clear();\n    this.#activeTargets.clear();\n    this.#confirmedTarget = null;\n  }\n\n  /** True when lifecycle tracking or the current event reports composition. */\n  isComposing(event?: CompositionSignal): boolean {\n    return this.#activeTargets.size > 0 || event?.isComposing === true;\n  }\n\n  /**\n   * Whether `event` is the `input` echoing the composition just confirmed.\n   *\n   * Asking closes the window either way, so one confirmation is folded at most\n   * once and a consumer asks once per `input`.\n   */\n  consumesConfirmedInput(event: ConfirmedInputSignal): boolean {\n    const confirmed = this.#confirmedTarget;\n    this.#confirmedTarget = null;\n    if (confirmed === null || confirmed !== event.target) return false;\n    // An engine that reports no kind at all leaves `inputType` empty, and the\n    // window is then the only signal there is.\n    const inputType = event.inputType;\n    return !inputType || COMPOSITION_INPUT_TYPES.has(inputType);\n  }\n\n  readonly #handleStart = (event: Event): void => {\n    this.#confirmedTarget = null;\n    if (event.currentTarget) this.#activeTargets.add(event.currentTarget);\n    this.#onStart?.(event);\n  };\n\n  readonly #handleEnd = (event: Event): void => {\n    if (event.currentTarget) this.#activeTargets.delete(event.currentTarget);\n    this.#confirmedTarget = event.target;\n    this.#onEnd?.(event);\n  };\n\n  /** A key on an observed field opens an edit of its own, so no echo is owed. */\n  readonly #handleKeydown = (): void => {\n    this.#confirmedTarget = null;\n  };\n}\n","/**\n * Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n *\n * Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n *\n * Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n */\n\n/**\n * The result of `parse(raw)`, or `fallback` when `parse` throws.\n *\n * Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n */\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n  try {\n    return parse(raw);\n  } catch {\n    return fallback;\n  }\n}\n\n/** What {@link validSelector} needs of the element it probes with. */\nexport interface SelectorProbe {\n  matches(selector: string): boolean;\n}\n\n/**\n * `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n *\n * `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n *\n * The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n */\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n  if (raw.length === 0) return fallback;\n  return parseDeclared(\n    raw,\n    (selector) => {\n      element.matches(selector);\n      return selector;\n    },\n    fallback,\n  );\n}\n\n/** How `compileRegExp` wraps a source before compiling it. */\nexport type RegExpAnchor = \"none\" | \"exact\";\n\n/**\n * `source` compiled as a `RegExp`, or `null` when it does not compile.\n *\n * `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)|(1` becomes `^(?:0)|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n */\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp | null {\n  return parseDeclared(\n    source,\n    (text) => {\n      const bare = new RegExp(text);\n      return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n    },\n    null,\n  );\n}\n\n/**\n * The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n */\nexport function parseJsonObject(raw: string): Record<string, unknown> | null {\n  const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n  if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n","/**\n * Whether a disabled `<fieldset>` ancestor actually reaches `control`.\n *\n * HTML exempts the contents of a fieldset's **first direct-child `<legend>`**, and\n * the exemption is per fieldset — a control legal in one legend can still be\n * disabled by a second, outer fieldset, so the walk continues upward.\n *\n * Exported on its own for callers that need the disabled-inheritance rule without\n * the rest of {@link canTakeFocus} — a control's availability check, or a `hidden`\n * walk bounded at a widget root, which is a different rule to compose with.\n */\nexport function inheritsFieldsetDisabled(control: HTMLElement): boolean {\n  let fieldset: Element | null = control.closest(\"fieldset[disabled]\");\n  while (fieldset) {\n    const legend = Array.from(fieldset.children).find((child) => child.tagName === \"LEGEND\");\n    if (!legend?.contains(control)) return true;\n    fieldset = fieldset.parentElement?.closest(\"fieldset[disabled]\") ?? null;\n  }\n  return false;\n}\n\n/**\n * Whether an element can actually take focus, checked **before** `focus()` runs.\n *\n * A controller that must move focus off a control it is about to disable or hide\n * picks a destination and calls `focus()` on it. If that destination cannot take\n * focus, the call **fails silently**: `hidden` and natively `disabled` elements\n * swallow it, so the caret stays in the subtree that is disappearing and lands on\n * `<body>` a frame later — the exact outcome the rescue exists to prevent, minus\n * any signal that it happened.\n *\n * Testing after the fact is the obvious alternative and is deliberately not the\n * rule. Reading `document.activeElement` back only works in a real browser, and\n * looping over candidates that way performs a real focus move per failure —\n * observable to assistive technology. Checking first costs nothing and catches\n * the cases that actually occur.\n *\n * **`aria-disabled` is not disqualifying.** It is the attribute an author uses\n * for a control that must stay *discoverable*, and the roving contract keeps\n * such items reachable. Only the four conditions that make the platform refuse\n * focus are checked: `hidden` / `inert` (an ancestor's counts),\n * `input[type=\"hidden\"]`, the native `disabled` property, and `disabled`\n * inherited from an ancestor `fieldset`. CSS-only invisibility is handled by\n * {@link isRenderedForFocus} when a consumer needs sequential-focus semantics.\n *\n * Reading `:disabled` instead of walking the fieldset chain would be shorter, but\n * that pseudo-class is not evaluated consistently outside real browsers and this\n * has to be right headlessly too. happy-dom in particular focuses a `<button>`\n * inside a disabled fieldset where a real engine refuses, so the inheritance is\n * spelled out rather than delegated.\n *\n * What a consumer does when nothing survives is its own call: some fall back to\n * their landmark, while a widget whose caret already sits somewhere legitimate\n * refuses the move outright rather than relocating it.\n *\n * @example\n * ```ts\n * const target = candidates.find(canTakeFocus);\n * if (target) target.focus();\n * else {\n *   this.#tabindex.lend(this.element); // nothing left: fall back to the landmark\n *   this.element.focus();\n * }\n * ```\n *\n * @param element - the candidate destination\n */\nexport function canTakeFocus(element: HTMLElement): boolean {\n  if (element.closest(\"[hidden], [inert]\")) return false;\n  if (element instanceof HTMLInputElement && element.type === \"hidden\") return false;\n  if (!(\"disabled\" in element)) return true;\n  if ((element as HTMLElement & { disabled: boolean }).disabled) return false;\n  return !inheritsFieldsetDisabled(element);\n}\n\n/** Elements whose semantics or authored attributes can place them in sequential focus order. */\nexport const TAB_STOP_CANDIDATE_SELECTOR = [\n  \"a[href]\",\n  \"area[href]\",\n  \"button\",\n  \"input\",\n  \"select\",\n  \"textarea\",\n  \"summary\",\n  \"iframe\",\n  \"audio[controls]\",\n  \"video[controls]\",\n  \"[tabindex]\",\n  \"[contenteditable]\",\n].join(\",\");\n\n/** Optional browser visibility API used to exclude CSS-hidden candidates. */\ninterface VisibilityCheckable {\n  checkVisibility?: (options?: { visibilityProperty?: boolean }) => boolean;\n}\n\n/** Whether CSS visibility allows an otherwise eligible element to participate in focus order. */\nexport function isRenderedForFocus(element: HTMLElement): boolean {\n  const check = (element as HTMLElement & VisibilityCheckable).checkVisibility;\n  return typeof check === \"function\" ? check.call(element, { visibilityProperty: true }) : true;\n}\n\n/** Parses an authored `tabindex`; invalid syntax has no explicit focus-order meaning. */\nfunction authoredTabindex(element: HTMLElement): number | null {\n  const value = element.getAttribute(\"tabindex\");\n  if (value === null || !/^[+-]?\\d+$/.test(value.trim())) return null;\n  return Number(value);\n}\n\n/** Whether the element's native semantics place it in sequential focus order. */\nfunction hasNativeTabStop(element: HTMLElement): boolean {\n  if (element instanceof HTMLAnchorElement || element instanceof HTMLAreaElement) {\n    return element.hasAttribute(\"href\");\n  }\n  if (\n    element instanceof HTMLButtonElement ||\n    element instanceof HTMLSelectElement ||\n    element instanceof HTMLTextAreaElement\n  ) {\n    return true;\n  }\n  if (element instanceof HTMLInputElement) return element.type !== \"hidden\";\n  if (element instanceof HTMLIFrameElement) return true;\n  if (element.tagName === \"AUDIO\" || element.tagName === \"VIDEO\") {\n    return element.hasAttribute(\"controls\");\n  }\n  if (element instanceof HTMLElement && element.tagName === \"SUMMARY\") {\n    const details = element.parentElement;\n    return (\n      details instanceof HTMLDetailsElement &&\n      Array.from(details.children).find((child) => child.tagName === \"SUMMARY\") === element\n    );\n  }\n  return false;\n}\n\n/** Whether an explicit `contenteditable` value creates an editable tab stop. */\nfunction hasEditableTabStop(element: HTMLElement): boolean {\n  const value = element.getAttribute(\"contenteditable\")?.toLowerCase();\n  return value === \"\" || value === \"true\" || value === \"plaintext-only\";\n}\n\n/**\n * Whether an element is a usable sequential Tab stop right now.\n *\n * Native semantics, authored `tabindex`, editable hosts, inherited disabled state,\n * HTML `hidden`/`inert`, and CSS visibility are evaluated together. `aria-disabled`\n * remains focusable because it communicates unavailability without removing the\n * control from discovery order.\n */\nexport function isTabStop(element: HTMLElement): boolean {\n  if (!canTakeFocus(element) || !isRenderedForFocus(element)) return false;\n\n  const tabindex = authoredTabindex(element);\n  if (tabindex !== null) return tabindex >= 0;\n  return hasNativeTabStop(element) || hasEditableTabStop(element);\n}\n\n/** Returns every usable sequential Tab stop below `root` in document order. */\nexport function tabStopsWithin(root: ParentNode): HTMLElement[] {\n  return Array.from(root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)).filter(\n    isTabStop,\n  );\n}\n\n/** Returns the first usable sequential Tab stop below `root`, if one exists. */\nexport function firstTabStop(root: ParentNode): HTMLElement | null {\n  for (const candidate of root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)) {\n    if (isTabStop(candidate)) return candidate;\n  }\n  return null;\n}\n\n/** Whether `root` contains at least one usable sequential Tab stop. */\nexport function hasTabStop(root: ParentNode): boolean {\n  return firstTabStop(root) !== null;\n}\n","/** The distance between a full-width ASCII code point and its half-width twin. */\nconst FULL_WIDTH_SHIFT = 0xfee0;\n\n/**\n * The half-width form of `char`, or `char` itself when it has none.\n *\n * An IME confirming in full-width mode produces U+FF01–U+FF5E (and U+3000 for\n * the space) where the page means ASCII — the digits of a phone number, the\n * letters of a code, the separators between them. Reading those as their ASCII\n * equivalents keeps confirmed text usable instead of discarding it. Characters\n * outside that block, including kana and astral code points, are returned\n * unchanged, so this never rewrites text a consumer meant to keep as typed.\n */\nexport function halfWidthChar(char: string): string {\n  if (char >= \"！\" && char <= \"～\") {\n    return String.fromCharCode(char.charCodeAt(0) - FULL_WIDTH_SHIFT);\n  }\n  return char === \"　\" ? \" \" : char;\n}\n\n/** Every full-width ASCII character in `text` rewritten by {@link halfWidthChar}. */\nexport function toHalfWidth(text: string): string {\n  let out = \"\";\n  for (const char of text) out += halfWidthChar(char);\n  return out;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { CompositionTracker } from \"../utils/composition_tracker\";\nimport { compileRegExp, parseJsonObject } from \"../utils/declared_value\";\nimport { inheritsFieldsetDisabled } from \"../utils/focus_candidate\";\nimport { halfWidthChar } from \"../utils/half_width\";\n\n/** Default placeholder tokens → single-char regex sources (user tokens merge over these). */\nconst DEFAULT_TOKENS: Readonly<Record<string, string>> = {\n  \"9\": \"\\\\d\",\n  a: \"[A-Za-z]\",\n  \"*\": \"[A-Za-z0-9]\",\n};\n\n/**\n * Suffix of the attribute marking the hidden raw-value sink; its value may name the\n * paired input's `id`.\n */\nconst UNMASK_ATTR = \"unmask\";\n\n/** Which neighbour a deleting keystroke aimed at, when the platform names one. */\ntype Deletion = \"backward\" | \"forward\";\n\n/** Who moved the value: the user editing the field, or the controller re-deciding it. */\ntype Cause = \"edit\" | \"reconcile\";\n\n/** The outcome of applying a fixed mask to a raw string. */\nexport interface MaskResult {\n  /** The formatted (masked) string. */\n  readonly masked: string;\n  /** The significant characters only (literals/separators removed). */\n  readonly unmasked: string;\n  /** Whether every token slot in the pattern is filled. */\n  readonly complete: boolean;\n  /** Per-output-char flag: true where the char fills a token (not a literal). */\n  readonly tokenFlags: readonly boolean[];\n}\n\n/**\n * The form of `char` this token takes: as typed when the token accepts it, else\n * its half-width form when *that* is what the token accepts, else `null` for a\n * rejected character. Trying the character as typed first keeps a token written\n * for full-width text (or for text an IME leaves as kana) authoritative.\n */\nfunction acceptedForm(regex: RegExp, char: string): string | null {\n  if (regex.test(char)) return char;\n  const half = halfWidthChar(char);\n  return half !== char && regex.test(half) ? half : null;\n}\n\n/**\n * Applies a fixed mask `pattern` to `value` using `tokens` (placeholder → regex).\n * Non-matching input characters are rejected (skipped); literals are auto-inserted\n * and a typed literal that matches is consumed. A character an IME confirmed in\n * full-width form fills a token — or consumes a literal — when its half-width\n * form is the one the mask asked for, and the half-width form is what the output\n * carries. Pure and exported for direct testing.\n */\nexport function applyMask(\n  value: string,\n  pattern: string,\n  tokens: ReadonlyMap<string, RegExp>,\n): MaskResult {\n  let masked = \"\";\n  let unmasked = \"\";\n  const tokenFlags: boolean[] = [];\n  let valueIndex = 0;\n  let totalTokens = 0;\n\n  for (const patternChar of pattern) {\n    const regex = tokens.get(patternChar);\n    if (regex) totalTokens += 1;\n    if (valueIndex >= value.length) continue;\n\n    if (regex) {\n      // Skip rejected characters until one fills this token (or input runs out).\n      let taken: string | null = null;\n      while (valueIndex < value.length) {\n        taken = acceptedForm(regex, value[valueIndex] ?? \"\");\n        if (taken !== null) break;\n        valueIndex += 1;\n      }\n      if (taken === null) continue;\n      masked += taken;\n      unmasked += taken;\n      tokenFlags.push(true);\n      valueIndex += 1;\n    } else {\n      masked += patternChar;\n      tokenFlags.push(false);\n      // The literal is already in the output, so the typed character only has to\n      // be the one that renders it — in either width.\n      if (halfWidthChar(value[valueIndex] ?? \"\") === halfWidthChar(patternChar)) valueIndex += 1;\n    }\n  }\n\n  return {\n    masked,\n    unmasked,\n    complete: totalTokens > 0 && unmasked.length === totalTokens,\n    tokenFlags,\n  };\n}\n\n/**\n * The token map a `tokens` declaration selects: the defaults with the declared\n * single-char regex sources compiled over them.\n *\n * A declaration that is not a JSON object of string sources declares no tokens,\n * leaving the defaults. A source that is not a valid regex is answered per key:\n * a key that has a default keeps that default, and a key that has none is left\n * out so the character stays a literal. Either way the rest of the mask, and the\n * field, keep working instead of going down with the broken source.\n */\nfunction compileTokens(declaration: string): Map<string, RegExp> {\n  const map = new Map<string, RegExp>();\n  for (const [key, source] of Object.entries(DEFAULT_TOKENS)) {\n    const compiled = compileRegExp(source, \"exact\");\n    if (compiled) map.set(key, compiled);\n  }\n  for (const [key, source] of Object.entries(parseTokens(declaration))) {\n    const compiled = compileRegExp(source, \"exact\");\n    // A broken source declares nothing: the default this key may already carry\n    // is what it falls back to, and a key without one holds no token at all.\n    if (compiled) map.set(key, compiled);\n  }\n  return map;\n}\n\n/** The `{ token: source }` pairs a declaration holds; anything else reads as none. */\nfunction parseTokens(declaration: string): Record<string, string> {\n  const parsed = parseJsonObject(declaration);\n  if (parsed === null) return {};\n\n  const tokens: Record<string, string> = {};\n  for (const [key, source] of Object.entries(parsed)) {\n    if (typeof source === \"string\") tokens[key] = source;\n  }\n  return tokens;\n}\n\n/** The direction an `input` event deleted in, or `null` when it is not a deletion. */\nfunction deletionOf(event: Event | undefined): Deletion | null {\n  const inputType = event instanceof InputEvent ? event.inputType : \"\";\n  if (!inputType.startsWith(\"delete\")) return null;\n  // Word, line, and content deletions all name their direction; the ones that\n  // name none (a cut, a drag-out) took a selection, so read them as backward.\n  return inputType.endsWith(\"Forward\") ? \"forward\" : \"backward\";\n}\n\n/** The offset of the `n`-th token char in a masked string, or `-1` when there is none. */\nfunction tokenCharOffset(tokenFlags: readonly boolean[], n: number): number {\n  let seen = 0;\n  for (let i = 0; i < tokenFlags.length; i += 1) {\n    if (!tokenFlags[i]) continue;\n    seen += 1;\n    if (seen === n) return i;\n  }\n  return -1;\n}\n\n/**\n * Headless **input mask** — formats a field in place against a fixed pattern\n * (`9`=digit, `a`=letter, `*`=alphanumeric, others literal), preserving the caret,\n * rejecting invalid characters, and syncing the raw value to a hidden field. No\n * dedicated APG pattern; `stimeo--currency-input` owns money-specific formatting.\n *\n * Markup contract (identifier: `stimeo--input-mask`, on the `<input>`):\n *   <input type=\"text\" inputmode=\"numeric\"\n *          data-controller=\"stimeo--input-mask\"\n *          data-stimeo--input-mask-pattern-value=\"999-9999\"\n *          data-action=\"input->stimeo--input-mask#format\">\n *   <input type=\"hidden\" name=\"zip\" data-stimeo--input-mask-unmask>\n *\n * `change` and `reconcile` dispatch `{ masked, unmasked, complete }`.\n *\n * @remarks\n * Behavior only and **idempotent** — the formatted value lives only in the input and\n * the hidden field (no module-scope state), so `connect()` re-formats the existing\n * value and is stable across Turbo restore/morph. The controller sits on the\n * `<input>` itself (a void element), so the raw-value sink is not a Stimulus target;\n * it is the `[data-stimeo--input-mask-unmask]` field resolved nearest-first among\n * the associated form's own controls (an explicit pairing by the sink attribute's\n * value naming the input's `id` wins; otherwise the closest ancestor's value-less\n * sink) — when one form holds several masked inputs, wrap each input+sink pair in a\n * container or pair them by `id`.\n *\n * Formatting never steals keys: it rejects disallowed characters silently and keeps\n * the caret on insert, Backspace, and range replacement (WCAG 2.2 3.3.2 / 1.3.5;\n * the expected format is the consumer's `aria-describedby`). The caret anchors on\n * the token slots the text before it fills, so a rejected character leaves it\n * exactly where it was. Backspace and Delete always progress: when the keystroke\n * only removed literals the mask re-inserts, the significant character it aimed at\n * goes instead. Events fired mid-IME-composition are ignored; the confirmed text is\n * formatted once on `compositionend`. A `pattern` / `tokens` / `unmaskToHidden`\n * change that arrives mid-composition leaves the uncommitted text alone and applies\n * with that same format: as the user's `change` when the composition committed\n * text, as `reconcile` when it ended on the text it began with.\n *\n * It reflects `data-mask-complete` / `data-mask-empty`, dispatches\n * `stimeo--input-mask:change` only when a user edit moves the committed value, and\n * `stimeo--input-mask:reconcile` when the controller itself decides that value —\n * a server-rendered or restored value normalized on connection, or a re-format\n * after `pattern` / `tokens` / `unmaskToHidden` changed. A malformed `tokens`\n * declaration falls back to the default tokens, and a single broken source falls\n * back to that key's default: it is parsed once in `tokensValueChanged`, and the\n * hot path only ever sees the validated map. A field\n * the user cannot edit (`readonly`, `disabled`, or inside a disabled `<fieldset>`)\n * keeps the value the page authored — the sink and the state hooks still follow it,\n * but the field itself is never rewritten. The composition listener is released on\n * `disconnect()`.\n */\nexport class InputMaskController extends Controller<HTMLInputElement> {\n  /** The attribute above, in the namespace this controller is registered under. */\n  get #unmaskAttribute(): string {\n    return `data-${this.identifier}-${UNMASK_ATTR}`;\n  }\n\n  static override values = {\n    pattern: { type: String, default: \"\" },\n    tokens: { type: String, default: \"\" },\n    unmaskToHidden: { type: Boolean, default: true },\n  };\n  static actions = [\"format\"] as const;\n  static events = [\"change\", \"reconcile\"] as const;\n\n  declare patternValue: string;\n  declare tokensValue: string;\n  declare unmaskToHiddenValue: boolean;\n\n  /** The value this controller last committed, and the baseline both events compare. */\n  #lastValue: string | null = null;\n  #started = false;\n\n  /** Validated token map; the hot path never parses the `tokens` declaration. */\n  #tokens = compileTokens(\"\");\n\n  /** The field's text when the running composition began. */\n  #textBeforeComposition = \"\";\n\n  /**\n   * Holds mid-composition input so the IME's uncommitted text is never rewritten,\n   * and formats the confirmed text once when the composition ends. A composition\n   * that ends on the text it began with committed nothing, so a re-format then is\n   * the page's: the mask changed while it ran.\n   */\n  readonly #composition = new CompositionTracker({\n    onStart: () => {\n      this.#textBeforeComposition = this.element.value;\n    },\n    onEnd: () => {\n      const committedNothing = this.element.value === this.#textBeforeComposition;\n      this.#reformat(committedNothing ? \"reconcile\" : \"edit\");\n    },\n  });\n\n  /** Re-parses the declaration and re-formats under the tokens it now selects. */\n  tokensValueChanged(): void {\n    this.#tokens = compileTokens(this.tokensValue);\n    if (this.#started) this.#reformat(\"reconcile\");\n  }\n\n  patternValueChanged(): void {\n    if (this.#started) this.#reformat(\"reconcile\");\n  }\n\n  /** Clears a sink it stops maintaining so a submit cannot carry a stale raw value. */\n  unmaskToHiddenValueChanged(): void {\n    if (!this.#started) return;\n    if (!this.unmaskToHiddenValue) {\n      const sink = this.#resolveSink();\n      if (sink) sink.value = \"\";\n    }\n    this.#reformat(\"reconcile\");\n  }\n\n  override connect(): void {\n    this.#started = true;\n    this.#composition.observe(this.element);\n    // Seed the baseline from the DOM so a value that is already masked stays\n    // silent, then re-format any server-rendered/restored value.\n    this.#lastValue = this.element.value;\n    this.#reformat(\"reconcile\");\n  }\n\n  override disconnect(): void {\n    this.#started = false;\n    this.#composition.disconnect();\n  }\n\n  /** Formats the field on input, preserving the caret. Bound via `data-action`. */\n  format(event?: Event): void {\n    if (this.#composition.isComposing(event as InputEvent | undefined)) return;\n    this.#reformat(\"edit\", deletionOf(event));\n  }\n\n  /**\n   * Core reformat: mask the current value, restore the caret, sync the sink and\n   * the state hooks, and report a moved value under the event `cause` selects.\n   *\n   * @stimeoRenderRoot\n   */\n  #reformat(cause: Cause, deletion: Deletion | null = null): void {\n    // The IME owns the text until it commits; the composition's end re-formats it.\n    if (this.#composition.isComposing()) return;\n    const input = this.element;\n    const raw = input.value;\n\n    // No pattern → act as a pass-through. Without this branch `applyMask` would\n    // produce an empty string and blank a misconfigured field's value; the hooks\n    // still describe the field so a pattern removed at runtime cannot leave a\n    // stale `data-mask-complete` behind.\n    if (this.patternValue === \"\") {\n      this.#flag(\"data-mask-complete\", false);\n      this.#flag(\"data-mask-empty\", raw.length === 0);\n      this.#lastValue = raw;\n      return;\n    }\n\n    const caret = input.selectionStart ?? raw.length;\n    let anchor = this.#significantBefore(raw.slice(0, caret));\n    let result = applyMask(raw, this.patternValue, this.#tokens);\n\n    // A deletion that only took literals the mask re-inserts would land back on\n    // the value it started from, so that keystroke could never delete anything:\n    // drop the significant character it aimed at instead.\n    if (deletion !== null && result.masked === this.#lastValue) {\n      const target = deletion === \"backward\" ? anchor : anchor + 1;\n      const offset = tokenCharOffset(result.tokenFlags, target);\n      if (offset >= 0) {\n        anchor = target - 1;\n        result = applyMask(\n          result.masked.slice(0, offset) + result.masked.slice(offset + 1),\n          this.patternValue,\n          this.#tokens,\n        );\n      }\n    }\n\n    // The value of a field the user cannot edit belongs to the page: publish the\n    // derived outputs against it, but never rewrite it and never report a move.\n    if (input.readOnly || input.disabled || inheritsFieldsetDisabled(input)) {\n      this.#publish(result, raw);\n      this.#lastValue = raw;\n      return;\n    }\n\n    input.value = result.masked;\n    this.#restoreCaret(result.tokenFlags, anchor);\n    this.#publish(result, result.masked);\n\n    if (result.masked === this.#lastValue) return;\n    this.#lastValue = result.masked;\n    const detail = { masked: result.masked, unmasked: result.unmasked, complete: result.complete };\n    if (cause === \"edit\") this.dispatch(\"change\", { detail });\n    else this.dispatch(\"reconcile\", { detail });\n  }\n\n  /** Syncs the raw-value sink and the state hooks for the `shown` field text. */\n  #publish(result: MaskResult, shown: string): void {\n    if (this.unmaskToHiddenValue) {\n      const sink = this.#resolveSink();\n      if (sink) sink.value = result.unmasked;\n    }\n    this.#flag(\"data-mask-complete\", result.complete);\n    this.#flag(\"data-mask-empty\", shown.length === 0);\n  }\n\n  /**\n   * How many token slots the text before the caret fills. Masking that prefix is\n   * what makes a rejected character — or a literal that also matches a token —\n   * count exactly as the rendering counts it, so the caret cannot drift.\n   */\n  #significantBefore(prefix: string): number {\n    return applyMask(prefix, this.patternValue, this.#tokens).unmasked.length;\n  }\n\n  /** Places the caret after the `n`-th token char (skipping following literals). */\n  #restoreCaret(tokenFlags: readonly boolean[], n: number): void {\n    let position: number;\n    if (n <= 0) {\n      // Sit after any leading literals, before the first token slot.\n      let i = 0;\n      while (i < tokenFlags.length && !tokenFlags[i]) i += 1;\n      position = i;\n    } else {\n      const offset = tokenCharOffset(tokenFlags, n);\n      if (offset < 0) {\n        position = tokenFlags.length;\n      } else {\n        let j = offset + 1;\n        while (j < tokenFlags.length && !tokenFlags[j]) j += 1;\n        position = j;\n      }\n    }\n    try {\n      this.element.setSelectionRange(position, position);\n    } catch {\n      /* selection unsupported for this input type — value formatting still applies */\n    }\n  }\n\n  /**\n   * The hidden raw-value sink for this input, resolved so several masked inputs\n   * can coexist in one form:\n   *\n   * 1. **Explicit pairing** — a sink whose attribute value names this input's\n   *    `id` (`data-stimeo--input-mask-unmask=\"zip\"`).\n   * 2. **Nearest container** — otherwise, walking up from the input, the first\n   *    *value-less* sink in the closest ancestor. Wrapped input+sink pairs each\n   *    find their own sink, and a single form-level sink is found the same\n   *    way. A sink claimed by another input's id is never matched here.\n   *\n   * Both steps only ever consider the associated form's own controls, so a sink\n   * belonging to a different form (or to none) is never written, while one the\n   * `form` attribute associates from elsewhere in the document still resolves —\n   * for either the input or the sink, neither of which needs to contain or be\n   * contained by the form. A form-less input reads the document instead.\n   */\n  #resolveSink(): HTMLInputElement | null {\n    const candidates = this.#sinkCandidates();\n    const id = this.element.id;\n    if (id.length > 0) {\n      const paired = candidates.find((sink) => sink.getAttribute(this.#unmaskAttribute) === id);\n      if (paired) return paired;\n    }\n\n    // A bare (value-less) attribute is unclaimed, so a sink naming another\n    // input's id can never be taken by this fallback.\n    const free = candidates.filter((sink) => sink.getAttribute(this.#unmaskAttribute) === \"\");\n    for (let node = this.element.parentElement; node !== null; node = node.parentElement) {\n      const ancestor = node;\n      const sink = free.find((candidate) => ancestor.contains(candidate));\n      if (sink) return sink;\n    }\n    return null;\n  }\n\n  /**\n   * Every sink the input's form owns, in document order — one collection read per\n   * resolution, so the cost tracks the form's own controls and not the depth of\n   * the markup around it. `form.elements` lists controls the `form` attribute\n   * associates from anywhere in the document, and lists nothing another form owns.\n   */\n  #sinkCandidates(): HTMLInputElement[] {\n    const form = this.element.form;\n    if (form === null) {\n      return Array.from(\n        document.querySelectorAll<HTMLInputElement>(`input[${this.#unmaskAttribute}]`),\n      );\n    }\n    return Array.from(form.elements).filter(\n      (element): element is HTMLInputElement =>\n        element instanceof HTMLInputElement && element.hasAttribute(this.#unmaskAttribute),\n    );\n  }\n\n  /** Sets a boolean `data-*` flag to `\"true\"` when `on`, else removes it. */\n  #flag(name: string, on: boolean): void {\n    if (on) this.element.setAttribute(name, \"true\");\n    else this.element.removeAttribute(name);\n  }\n}\n"]}
+{"version":3,"sources":["../../src/utils/composition_tracker.ts","../../src/utils/declared_value.ts","../../src/utils/focus_candidate.ts","../../src/utils/half_width.ts","../../src/utils/listener_set.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/morph_render_watcher.ts","../../src/controllers/input_mask_controller.ts"],"names":[],"mappings":"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","file":"input_mask_controller.js","sourcesContent":["/** Minimal event shape carrying the platform's per-event composition signal. */\nexport interface CompositionSignal {\n  readonly isComposing?: boolean;\n}\n\n/** Minimal `input` shape needed to tell a composition echo from a fresh edit. */\nexport interface ConfirmedInputSignal {\n  readonly target: EventTarget | null;\n  readonly inputType?: string;\n}\n\n/**\n * The `inputType` values an engine reports on an `input` that belongs to a\n * composition rather than to an edit the user just made.\n */\nconst COMPOSITION_INPUT_TYPES = new Set([\n  \"insertCompositionText\",\n  \"insertFromComposition\",\n  \"deleteCompositionText\",\n  \"deleteByComposition\",\n]);\n\n/** Hooks that keep component-specific work outside {@link CompositionTracker}. */\nexport interface CompositionTrackerOptions {\n  /** Runs after lifecycle state is set for a `compositionstart` event. */\n  readonly onStart?: (event: Event) => void;\n  /** Runs after lifecycle state is cleared for a `compositionend` event. */\n  readonly onEnd?: (event: Event) => void;\n}\n\n/**\n * Owns IME composition listeners and transient state for one or more event targets.\n *\n * Some browsers omit `KeyboardEvent.isComposing` on the keydown that confirms a\n * conversion. Tracking `compositionstart` through `compositionend` supplies the\n * missing lifecycle signal without relying on deprecated numeric key codes.\n * Component policy stays with the consumer: filtering, validation, and submission\n * belong in the optional {@link CompositionTrackerOptions.onEnd} callback.\n *\n * The tracker also owns the other half of that lifecycle: **the `input` some\n * engines send after `compositionend` to echo the text just confirmed.** A\n * consumer that ran `onEnd` and then handled the echo would commit the same\n * confirmation twice, so {@link CompositionTracker.consumesConfirmedInput} tells\n * the echo apart and the consumer returns early on it.\n *\n * **What the echo is not, is the harder half.** Not every engine sends one —\n * Chromium ends a confirmation at `compositionend` with no `input` after it — so\n * a window that waits for the echo and only closes on the next key would swallow\n * the first edit that arrives without one: dictation, autofill, a drop,\n * `insertText`. Two things keep that from happening. The window closes on the\n * next anything — a key, a new composition, any `input`, losing the field — and\n * an `input` that reports an `inputType` outside {@link COMPOSITION_INPUT_TYPES}\n * is an edit, so it is never folded. Only an engine that reports no `inputType`\n * at all is left relying on the window alone.\n *\n * @example\n * ```ts\n * #composition = new CompositionTracker({ onEnd: () => this.filter() });\n *\n * connect(): void {\n *   this.#composition.observe(this.inputTarget);\n * }\n *\n * disconnect(): void {\n *   this.#composition.disconnect();\n * }\n *\n * onInput(event: InputEvent): void {\n *   if (this.#composition.consumesConfirmedInput(event)) return;\n *   if (this.#composition.isComposing(event)) return;\n * }\n *\n * onKeydown(event: KeyboardEvent): void {\n *   if (this.#composition.isComposing(event)) return;\n * }\n * ```\n */\nexport class CompositionTracker {\n  readonly #observedTargets = new Set<EventTarget>();\n  readonly #activeTargets = new Set<EventTarget>();\n  readonly #onStart: ((event: Event) => void) | undefined;\n  readonly #onEnd: ((event: Event) => void) | undefined;\n  /** The field whose confirming `input` is still owed, while the window is open. */\n  #confirmedTarget: EventTarget | null = null;\n\n  constructor(options: CompositionTrackerOptions = {}) {\n    this.#onStart = options.onStart;\n    this.#onEnd = options.onEnd;\n  }\n\n  /** Starts lifecycle tracking for `target`; repeated calls are idempotent. */\n  observe(target: EventTarget): void {\n    if (this.#observedTargets.has(target)) return;\n    target.addEventListener(\"compositionstart\", this.#handleStart);\n    target.addEventListener(\"compositionend\", this.#handleEnd);\n    target.addEventListener(\"keydown\", this.#handleKeydown);\n    this.#observedTargets.add(target);\n  }\n\n  /** Stops tracking one target and clears any active composition it owned. */\n  unobserve(target: EventTarget): void {\n    if (!this.#observedTargets.delete(target)) return;\n    target.removeEventListener(\"compositionstart\", this.#handleStart);\n    target.removeEventListener(\"compositionend\", this.#handleEnd);\n    target.removeEventListener(\"keydown\", this.#handleKeydown);\n    this.#activeTargets.delete(target);\n    if (this.#confirmedTarget === target) this.#confirmedTarget = null;\n  }\n\n  /** Releases every listener and clears state so reconnect starts cleanly. */\n  disconnect(): void {\n    for (const target of this.#observedTargets) {\n      target.removeEventListener(\"compositionstart\", this.#handleStart);\n      target.removeEventListener(\"compositionend\", this.#handleEnd);\n      target.removeEventListener(\"keydown\", this.#handleKeydown);\n    }\n    this.#observedTargets.clear();\n    this.#activeTargets.clear();\n    this.#confirmedTarget = null;\n  }\n\n  /** True when lifecycle tracking or the current event reports composition. */\n  isComposing(event?: CompositionSignal): boolean {\n    return this.#activeTargets.size > 0 || event?.isComposing === true;\n  }\n\n  /**\n   * Whether `event` is the `input` echoing the composition just confirmed.\n   *\n   * Asking closes the window either way, so one confirmation is folded at most\n   * once and a consumer asks once per `input`.\n   */\n  consumesConfirmedInput(event: ConfirmedInputSignal): boolean {\n    const confirmed = this.#confirmedTarget;\n    this.#confirmedTarget = null;\n    if (confirmed === null || confirmed !== event.target) return false;\n    // An engine that reports no kind at all leaves `inputType` empty, and the\n    // window is then the only signal there is.\n    const inputType = event.inputType;\n    return !inputType || COMPOSITION_INPUT_TYPES.has(inputType);\n  }\n\n  readonly #handleStart = (event: Event): void => {\n    this.#confirmedTarget = null;\n    if (event.currentTarget) this.#activeTargets.add(event.currentTarget);\n    this.#onStart?.(event);\n  };\n\n  readonly #handleEnd = (event: Event): void => {\n    if (event.currentTarget) this.#activeTargets.delete(event.currentTarget);\n    this.#confirmedTarget = event.target;\n    this.#onEnd?.(event);\n  };\n\n  /** A key on an observed field opens an edit of its own, so no echo is owed. */\n  readonly #handleKeydown = (): void => {\n    this.#confirmedTarget = null;\n  };\n}\n","/**\n * Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n *\n * Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n *\n * Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n */\n\n/**\n * The result of `parse(raw)`, or `fallback` when `parse` throws.\n *\n * Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n */\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n  try {\n    return parse(raw);\n  } catch {\n    return fallback;\n  }\n}\n\n/** What {@link validSelector} needs of the element it probes with. */\nexport interface SelectorProbe {\n  matches(selector: string): boolean;\n}\n\n/**\n * `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n *\n * `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n *\n * The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n */\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n  if (raw.length === 0) return fallback;\n  return parseDeclared(\n    raw,\n    (selector) => {\n      element.matches(selector);\n      return selector;\n    },\n    fallback,\n  );\n}\n\n/** How `compileRegExp` wraps a source before compiling it. */\nexport type RegExpAnchor = \"none\" | \"exact\";\n\n/**\n * `source` compiled as a `RegExp`, or `null` when it does not compile.\n *\n * `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)|(1` becomes `^(?:0)|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n */\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp | null {\n  return parseDeclared(\n    source,\n    (text) => {\n      const bare = new RegExp(text);\n      return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n    },\n    null,\n  );\n}\n\n/**\n * The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n */\nexport function parseJsonObject(raw: string): Record<string, unknown> | null {\n  const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n  if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n","/**\n * Whether a disabled `<fieldset>` ancestor actually reaches `control`.\n *\n * HTML exempts the contents of a fieldset's **first direct-child `<legend>`**, and\n * the exemption is per fieldset — a control legal in one legend can still be\n * disabled by a second, outer fieldset, so the walk continues upward.\n *\n * Exported on its own for callers that need the disabled-inheritance rule without\n * the rest of {@link canTakeFocus} — a control's availability check, or a `hidden`\n * walk bounded at a widget root, which is a different rule to compose with.\n */\nexport function inheritsFieldsetDisabled(control: HTMLElement): boolean {\n  let fieldset: Element | null = control.closest(\"fieldset[disabled]\");\n  while (fieldset) {\n    const legend = Array.from(fieldset.children).find((child) => child.tagName === \"LEGEND\");\n    if (!legend?.contains(control)) return true;\n    fieldset = fieldset.parentElement?.closest(\"fieldset[disabled]\") ?? null;\n  }\n  return false;\n}\n\n/**\n * Whether the engine reports `element` assigned to no slot of the open shadow root its parent\n * hosts: such an element is not in the flat tree, so it and what it holds are rendered nowhere\n * and cannot take focus.\n */\nfunction unslotted(element: Element): boolean {\n  return element.assignedSlot === null && element.parentElement?.shadowRoot != null;\n}\n\n/**\n * The parent of `element` in the flat tree: the slot it is assigned to, its parent element,\n * or the host of the shadow root it is a child of; `null` at the top of the document or of a\n * detached tree, and for an element the engine assigns to no slot of the open shadow root its\n * parent hosts, which is outside the flat tree. A closed shadow root does not report its slots,\n * so an element assigned to one climbs to the host.\n */\nexport function flatTreeParent(element: Element): Element | null {\n  if (unslotted(element)) return null;\n  const parent = element.assignedSlot ?? element.parentNode;\n  if (parent instanceof ShadowRoot) return parent.host;\n  return parent instanceof Element ? parent : null;\n}\n\n/** Whether `element` is `ancestor` or one of its descendants in the flat tree. */\nexport function flatTreeContains(ancestor: Element, element: Element | null): boolean {\n  for (let node = element; node; node = flatTreeParent(node)) {\n    if (node === ancestor) return true;\n  }\n  return false;\n}\n\n/** The nearest of `element` and its flat-tree ancestors that matches `selector`, or `null`. */\nexport function closestInFlatTree(element: Element, selector: string): Element | null {\n  for (let node: Element | null = element; node; node = flatTreeParent(node)) {\n    if (node.matches(selector)) return node;\n  }\n  return null;\n}\n\n/**\n * The children of `element` in the flat tree: its open shadow root's children, a slot's\n * assigned elements (its own children when nothing is assigned to it), or its children.\n */\nexport function flatTreeChildren(element: Element): Element[] {\n  return ownedScope(element) ?? Array.from(element.children);\n}\n\n/**\n * Whether an element can actually take focus, checked **before** `focus()` runs.\n *\n * A controller that must move focus off a control it is about to disable or hide\n * picks a destination and calls `focus()` on it. If that destination cannot take\n * focus, the call **fails silently**: `hidden` and natively `disabled` elements\n * swallow it, so the caret stays in the subtree that is disappearing and lands on\n * `<body>` a frame later — the exact outcome the rescue exists to prevent, minus\n * any signal that it happened.\n *\n * Testing after the fact is the obvious alternative and is deliberately not the\n * rule. Reading `document.activeElement` back only works in a real browser, and\n * looping over candidates that way performs a real focus move per failure —\n * observable to assistive technology. Checking first costs nothing and catches\n * the cases that actually occur.\n *\n * **`aria-disabled` is not disqualifying.** It is the attribute an author uses\n * for a control that must stay *discoverable*, and the roving contract keeps\n * such items reachable. Only the conditions that make the platform refuse\n * focus are checked: `hidden` / `inert` on the element or a flat-tree ancestor\n * (the host of an open shadow root it sits in, the slot it is assigned to), the\n * element or an ancestor left out of the flat tree (one the engine assigns to no\n * slot of the open shadow root its parent hosts), `input[type=\"hidden\"]`, the\n * native `disabled` property, and `disabled` inherited from an ancestor\n * `fieldset`. CSS-only invisibility is handled by {@link isRenderedForFocus}\n * when a consumer needs sequential-focus semantics.\n *\n * Reading `:disabled` instead of walking the fieldset chain would be shorter, but\n * that pseudo-class is not evaluated consistently outside real browsers and this\n * has to be right headlessly too. happy-dom in particular focuses a `<button>`\n * inside a disabled fieldset where a real engine refuses, so the inheritance is\n * spelled out rather than delegated.\n *\n * What a consumer does when nothing survives is its own call: some fall back to\n * their landmark, while a widget whose caret already sits somewhere legitimate\n * refuses the move outright rather than relocating it.\n *\n * @example\n * ```ts\n * const target = candidates.find(canTakeFocus);\n * if (target) target.focus();\n * else {\n *   this.#tabindex.lend(this.element); // nothing left: fall back to the landmark\n *   this.element.focus();\n * }\n * ```\n *\n * @param element - the candidate destination\n */\nexport function canTakeFocus(element: HTMLElement): boolean {\n  for (let node: Element | null = element; node; node = flatTreeParent(node)) {\n    if (unslotted(node) || node.matches(\"[hidden], [inert]\")) return false;\n  }\n  if (element instanceof HTMLInputElement && element.type === \"hidden\") return false;\n  if (!(\"disabled\" in element)) return true;\n  if ((element as HTMLElement & { disabled: boolean }).disabled) return false;\n  return !inheritsFieldsetDisabled(element);\n}\n\n/** Elements whose semantics or authored attributes can place them in sequential focus order. */\nexport const TAB_STOP_CANDIDATE_SELECTOR = [\n  \"a[href]\",\n  \"area[href]\",\n  \"button\",\n  \"input\",\n  \"select\",\n  \"textarea\",\n  \"summary\",\n  \"iframe\",\n  \"audio[controls]\",\n  \"video[controls]\",\n  \"[tabindex]\",\n  \"[contenteditable]\",\n].join(\",\");\n\n/** Optional browser visibility API used to exclude CSS-hidden candidates. */\ninterface VisibilityCheckable {\n  checkVisibility?: (options?: { visibilityProperty?: boolean }) => boolean;\n}\n\n/** Whether CSS visibility allows an otherwise eligible element to participate in focus order. */\nexport function isRenderedForFocus(element: HTMLElement): boolean {\n  const check = (element as HTMLElement & VisibilityCheckable).checkVisibility;\n  return typeof check === \"function\" ? check.call(element, { visibilityProperty: true }) : true;\n}\n\n/** Parses an authored `tabindex`; invalid syntax has no explicit focus-order meaning. */\nfunction authoredTabindex(element: Element): number | null {\n  const value = element.getAttribute(\"tabindex\");\n  if (value === null || !/^[+-]?\\d+$/.test(value.trim())) return null;\n  return Number(value);\n}\n\n/** Whether the element's native semantics place it in sequential focus order. */\nfunction hasNativeTabStop(element: HTMLElement): boolean {\n  if (element instanceof HTMLAnchorElement || element instanceof HTMLAreaElement) {\n    return element.hasAttribute(\"href\");\n  }\n  if (\n    element instanceof HTMLButtonElement ||\n    element instanceof HTMLSelectElement ||\n    element instanceof HTMLTextAreaElement\n  ) {\n    return true;\n  }\n  if (element instanceof HTMLInputElement) return element.type !== \"hidden\";\n  if (element instanceof HTMLIFrameElement) return true;\n  if (element.tagName === \"AUDIO\" || element.tagName === \"VIDEO\") {\n    return element.hasAttribute(\"controls\");\n  }\n  if (element instanceof HTMLElement && element.tagName === \"SUMMARY\") {\n    const details = element.parentElement;\n    return (\n      details instanceof HTMLDetailsElement &&\n      Array.from(details.children).find((child) => child.tagName === \"SUMMARY\") === element\n    );\n  }\n  return false;\n}\n\n/** Whether an explicit `contenteditable` value creates an editable tab stop. */\nfunction hasEditableTabStop(element: HTMLElement): boolean {\n  const value = element.getAttribute(\"contenteditable\")?.toLowerCase();\n  return value === \"\" || value === \"true\" || value === \"plaintext-only\";\n}\n\n/**\n * Whether an element is a usable sequential Tab stop right now.\n *\n * Native semantics, authored `tabindex`, editable hosts, inherited disabled state,\n * HTML `hidden`/`inert`, and CSS visibility are evaluated together. `aria-disabled`\n * remains focusable because it communicates unavailability without removing the\n * control from discovery order.\n */\nexport function isTabStop(element: HTMLElement): boolean {\n  if (!canTakeFocus(element) || !isRenderedForFocus(element)) return false;\n\n  const tabindex = authoredTabindex(element);\n  if (tabindex !== null) return tabindex >= 0;\n  return hasNativeTabStop(element) || hasEditableTabStop(element);\n}\n\n/** Returns every usable sequential Tab stop below `root` in document order. */\nexport function tabStopsWithin(root: ParentNode): HTMLElement[] {\n  return Array.from(root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)).filter(\n    isTabStop,\n  );\n}\n\n/** Returns the first usable sequential Tab stop below `root`, if one exists. */\nexport function firstTabStop(root: ParentNode): HTMLElement | null {\n  for (const candidate of root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)) {\n    if (isTabStop(candidate)) return candidate;\n  }\n  return null;\n}\n\n/** Whether `root` contains at least one usable sequential Tab stop. */\nexport function hasTabStop(root: ParentNode): boolean {\n  return firstTabStop(root) !== null;\n}\n\n/** An element sequential focus navigation can stop on. */\nexport type TabStopElement = HTMLElement | SVGElement;\n\n/** Whether the element is a radio button. */\nfunction isRadio(element: Element | null): element is HTMLInputElement {\n  return element instanceof HTMLInputElement && element.type === \"radio\";\n}\n\n/**\n * Whether two radios form one group: the same non-empty `name`, the same form owner and\n * the same tree. A radio without a name is a group of its own.\n */\nfunction sameRadioGroup(a: HTMLInputElement, b: HTMLInputElement): boolean {\n  return (\n    a.name !== \"\" && a.name === b.name && a.form === b.form && a.getRootNode() === b.getRootNode()\n  );\n}\n\n/**\n * Whether the element is part of editable content: the nearest ancestor that sets a valid\n * `contenteditable` decides. `false` ends the editable region (a non-editable island\n * inside an editor); an invalid value inherits from further up.\n */\nfunction isInEditableContent(element: Element): boolean {\n  for (let node = element.parentElement; node; node = node.parentElement) {\n    if (node.getAttribute(\"contenteditable\")?.toLowerCase() === \"false\") return false;\n    if (hasEditableTabStop(node)) return true;\n  }\n  return false;\n}\n\n/** The XLink namespace, where an SVG link may carry its `href`. */\nconst XLINK_NAMESPACE = \"http://www.w3.org/1999/xlink\";\n\n/** Whether the element is an SVG link: an SVG `a` with `href` or `xlink:href`. */\nfunction isSvgLink(element: Element): boolean {\n  return (\n    element instanceof SVGElement &&\n    element.localName === \"a\" &&\n    (element.hasAttribute(\"href\") || element.hasAttributeNS(XLINK_NAMESPACE, \"href\"))\n  );\n}\n\n/**\n * Whether an image-map area has a rendered image: an `img` in the area's tree whose\n * `usemap` names the area's map (by `name`, or by `id` without one) and that is rendered.\n * The area has no box of its own for {@link isRenderedForFocus} to check.\n */\nfunction hasRenderedImage(area: HTMLAreaElement): boolean {\n  const map = area.closest(\"map\");\n  const key = map?.name || map?.id;\n  if (!map || !key) return false;\n  const root = map.getRootNode() as Document | ShadowRoot;\n  return Array.from(root.querySelectorAll<HTMLElement>(\"img[usemap]\")).some(\n    (image) => image.getAttribute(\"usemap\") === `#${key}` && isRenderedForFocus(image),\n  );\n}\n\n/** Whether the element can take focus and has no negative `tabindex`. */\nfunction isFocusableInOrder(element: TabStopElement): boolean {\n  const tabindex = authoredTabindex(element);\n  return (tabindex === null || tabindex >= 0) && canTakeFocus(element as HTMLElement);\n}\n\n/**\n * The engine's verdict for the stops {@link isTabStop} does not judge the way sequential\n * navigation does, or `null` for every other element: an image-map area with an `href` or\n * its own `tabindex` stops while an image that uses its map is rendered; an object stops\n * while it holds a nested document, as an iframe does; an SVG link stops while it is\n * rendered. Each also needs to take focus and not be taken out of the order with a\n * negative `tabindex`.\n */\nfunction extraStop(element: TabStopElement): boolean | null {\n  if (element instanceof HTMLAreaElement) {\n    const focusable = element.hasAttribute(\"href\") || authoredTabindex(element) !== null;\n    return focusable && isFocusableInOrder(element) && hasRenderedImage(element);\n  }\n  if (element instanceof HTMLObjectElement) {\n    return (\n      isFocusableInOrder(element) && isRenderedForFocus(element) && element.contentWindow !== null\n    );\n  }\n  if (isSvgLink(element))\n    return isFocusableInOrder(element) && isRenderedForFocus(element as HTMLElement);\n  return null;\n}\n\n/**\n * Whether sequential navigation stops on the element: a usable Tab stop\n * ({@link isTabStop}), or one of the stops `extraStop` judges, except a link inside\n * editable content without a `tabindex` of its own, which the engine leaves to editing.\n * Other controls inside an editing host, and the host itself, stay stops.\n */\nfunction isSequentialStop(element: TabStopElement): boolean {\n  const stop =\n    extraStop(element) ??\n    (element.matches(TAB_STOP_CANDIDATE_SELECTOR) && isTabStop(element as HTMLElement));\n  if (!stop) return false;\n  const link =\n    element instanceof HTMLAnchorElement ||\n    element instanceof HTMLAreaElement ||\n    isSvgLink(element);\n  return !(link && authoredTabindex(element) === null && isInEditableContent(element));\n}\n\n/**\n * The elements of the focus navigation scope `element` owns: its open shadow root's\n * children, or a slot's assigned elements (its fallback content when nothing is\n * assigned). `null` when it owns no scope. A closed shadow root cannot be read, so its\n * host owns none.\n */\nfunction ownedScope(element: Element): Element[] | null {\n  if (element.shadowRoot) return Array.from(element.shadowRoot.children);\n  if (element instanceof HTMLSlotElement) {\n    const assigned = element.assignedElements();\n    return assigned.length > 0 ? assigned : Array.from(element.children);\n  }\n  return null;\n}\n\n/** One member of a focus navigation scope: its tabindex and the stops it contributes. */\ninterface ScopeEntry {\n  readonly tabindex: number;\n  readonly stops: TabStopElement[];\n}\n\n/** What a walk of the order records besides the order itself. */\ninterface OrderWalk {\n  /** The element a move starts from. */\n  readonly from: Element | null;\n  /** Every stop, in flat-tree order. */\n  readonly tree: TabStopElement[];\n  /** How many entries of {@link OrderWalk.tree} come before `from`; `-1` until the walk meets it. */\n  fromAt: number;\n}\n\n/**\n * Orders one focus navigation scope the way HTML's sequential navigation does: members\n * with a positive `tabindex` first, ascending, ties in tree order, then the rest in tree\n * order. A member that owns a scope (a shadow host, a slot) is followed by that scope's\n * own order; one taken out of the order with a negative `tabindex` takes its scope with it.\n */\nfunction orderScope(elements: Element[], walk: OrderWalk): TabStopElement[] {\n  const entries: ScopeEntry[] = [];\n  const visit = (element: Element): void => {\n    if (element === walk.from) walk.fromAt = walk.tree.length;\n    const tabindex = authoredTabindex(element) ?? 0;\n    const stop =\n      (element instanceof HTMLElement || element instanceof SVGElement) && isSequentialStop(element)\n        ? element\n        : null;\n    if (stop) walk.tree.push(stop);\n    const owned = ownedScope(element);\n    if (owned) {\n      if (tabindex >= 0) {\n        entries.push({ tabindex, stops: [...(stop ? [stop] : []), ...orderScope(owned, walk)] });\n      }\n      return;\n    }\n    if (stop) entries.push({ tabindex, stops: [stop] });\n    for (const child of Array.from(element.children)) visit(child);\n  };\n  for (const element of elements) visit(element);\n  const positive = entries.filter((entry) => entry.tabindex > 0);\n  positive.sort((a, b) => a.tabindex - b.tabindex);\n  const rest = entries.filter((entry) => entry.tabindex === 0);\n  return [...positive, ...rest].flatMap((entry) => entry.stops);\n}\n\n/**\n * Whether a candidate passes the radio-group rule the engine applies: a checked radio\n * among the stops always does; an unchecked one only as the first radio of a group with\n * no checked stop, and not while focus is on a radio of that group. `tree` is the walk's\n * stops in flat-tree order, so a group is counted within the walked root only.\n */\nfunction passesRadioRule(\n  element: TabStopElement,\n  tree: TabStopElement[],\n  focusedRadio: HTMLInputElement | null,\n): boolean {\n  if (!isRadio(element) || element.checked) return true;\n  const group = tree.filter(\n    (stop): stop is HTMLInputElement =>\n      stop === element || (isRadio(stop) && sameRadioGroup(stop, element)),\n  );\n  if (group.some((radio) => radio.checked)) return false;\n  if (group[0] !== element) return false;\n  return focusedRadio === null || !sameRadioGroup(focusedRadio, element);\n}\n\n/**\n * The index in `order` a move from the walk's `from` visits first. A start the walk did\n * not meet is outside: the move enters at the first stop, or the last going backward. A\n * start that is a stop moves one place along the order. Any other start (the root, an\n * element with a negative `tabindex`) moves to the nearest stop after it in tree order,\n * or before it going backward, and wraps when there is none.\n */\nfunction startIndex(\n  order: TabStopElement[],\n  walk: OrderWalk,\n  backward: boolean,\n  isStop: (element: TabStopElement) => boolean,\n): number {\n  if (walk.fromAt < 0) return backward ? order.length - 1 : 0;\n  const at = order.indexOf(walk.from as TabStopElement);\n  if (at >= 0) return backward ? at - 1 : at + 1;\n  const neighbour = backward\n    ? walk.tree.slice(0, walk.fromAt).reverse().find(isStop)\n    : walk.tree.slice(walk.fromAt).find(isStop);\n  if (neighbour) return order.indexOf(neighbour);\n  return backward ? order.length - 1 : 0;\n}\n\n/**\n * The stops below `root` in the order a sequential move from `from` visits them: the\n * next stop first (the previous one when `backward`), wrapping at the ends, with `from`\n * itself left out. Without a `from` — or with one outside `root` — the list starts at the\n * first stop, or at the last one when `backward`.\n *\n * The order is HTML's sequential navigation order within `root`: positive `tabindex`\n * first, ascending, then `tabindex=\"0\"` and native stops in tree order. Open shadow roots\n * are walked in flat-tree order, slots expanded, each scope ordered on its own; a closed\n * shadow root is not read. A radio group, counted within `root`, stops once: on its\n * checked radio when that radio can take focus, even with focus elsewhere in the group,\n * and otherwise on its first radio that can, unless focus is already in the group.\n * A link inside editable content without its own `tabindex` is not a stop. Every stop\n * also passes its applicable focusability and rendering checks.\n *\n * @param root - The element whose descendants are ordered; it is not a stop itself.\n * @param from - Where the move starts, usually {@link deepActiveElement}.\n * @param backward - Whether the move goes backward (`Shift+Tab`).\n */\nexport function sequentialTabStops(\n  root: Element,\n  from: Element | null = null,\n  backward = false,\n): TabStopElement[] {\n  const walk: OrderWalk = { from, tree: [], fromAt: from === root ? 0 : -1 };\n  const order = orderScope(ownedScope(root) ?? Array.from(root.children), walk);\n  const focusedRadio = walk.fromAt >= 0 && isRadio(from) ? from : null;\n  const isStop = (element: TabStopElement): boolean =>\n    passesRadioRule(element, walk.tree, focusedRadio);\n  const start = startIndex(order, walk, backward, isStop);\n  const visited = backward\n    ? [...order.slice(0, start + 1).reverse(), ...order.slice(start + 1).reverse()]\n    : [...order.slice(start), ...order.slice(0, start)];\n  return visited.filter((element) => element !== from && isStop(element));\n}\n\n/**\n * The element that holds focus in `ownerDocument`, looking through open shadow roots:\n * `document.activeElement` stops at a shadow host. A closed shadow root cannot be read,\n * so focus inside one reads as its host.\n */\nexport function deepActiveElement(ownerDocument: Document): Element | null {\n  let active = ownerDocument.activeElement;\n  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;\n  return active;\n}\n","/** The distance between a full-width ASCII code point and its half-width twin. */\nconst FULL_WIDTH_SHIFT = 0xfee0;\n\n/**\n * The half-width form of `char`, or `char` itself when it has none.\n *\n * An IME confirming in full-width mode produces U+FF01–U+FF5E (and U+3000 for\n * the space) where the page means ASCII — the digits of a phone number, the\n * letters of a code, the separators between them. Reading those as their ASCII\n * equivalents keeps confirmed text usable instead of discarding it. Characters\n * outside that block, including kana and astral code points, are returned\n * unchanged, so this never rewrites text a consumer meant to keep as typed.\n */\nexport function halfWidthChar(char: string): string {\n  if (char >= \"！\" && char <= \"～\") {\n    return String.fromCharCode(char.charCodeAt(0) - FULL_WIDTH_SHIFT);\n  }\n  return char === \"　\" ? \" \" : char;\n}\n\n/** Every full-width ASCII character in `text` rewritten by {@link halfWidthChar}. */\nexport function toHalfWidth(text: string): string {\n  let out = \"\";\n  for (const char of text) out += halfWidthChar(char);\n  return out;\n}\n","/**\n * Owns every listener a controller attaches for one connected lifetime and\n * releases them together, so an event name is spelled once and the release\n * cannot drift from the registration.\n *\n * Detaching by hand repeats three things at the release site — the type, the\n * handler reference and the capture flag — and any one of them drifting leaves\n * a listener alive on an element the controller no longer drives. Aborting the\n * signal a registration was created with releases it whatever it was made of,\n * so the release site names nothing.\n *\n * One set per lifetime, held as a field and never rebuilt. {@link\n * ListenerSet.dispose} is the only thing that closes a generation, and it opens\n * the next one in the same step, so the lifecycle hooks can call `add` and\n * `dispose` in any order any number of times, and no `add` ever meets an\n * already aborted signal — a DOM that registers a listener on such a signal\n * would keep it forever. Rebuilding the set instead would leak:\n * `addEventListener` matches an existing registration on target, type, callback\n * and capture alone, so re-adding the same handler while the first registration\n * is live is discarded, and that live registration keeps the signal it was\n * attached with — a set built by a second `connect()` can never release what it\n * appears to own.\n *\n * Scope is the registration only. Timers, observers, leases and the order they\n * are unwound in stay with the controller, which places `dispose()` in its\n * cleanup sequence. A receiver that changes at runtime (a\n * swapped target) is rebound by calling `dispose()` and then `add()` again from\n * the rebind, not by a second set.\n *\n * The set must own every registration of a tuple it holds: a listener the same\n * target already carries for the same type, callback and capture flag keeps the\n * right to remove it, and this set's `add` for that tuple is discarded. A\n * subscription shared between instances behind a participant count, or one that\n * lives for less than the connection, keeps its own pair of calls.\n *\n * @example\n * ```ts\n * readonly #listeners = new ListenerSet();\n *\n * connect(): void {\n *   this.#listeners.add(this.element, \"submit\", this.#onNativeSubmit, { capture: true });\n *   this.#listeners.add(this.element, \"turbo:submit-start\", this.#onSubmitStart);\n *   this.#listeners.add(this.element, \"turbo:submit-end\", this.#onSubmitEnd);\n * }\n *\n * disconnect(): void {\n *   this.#listeners.dispose();\n * }\n * ```\n */\nexport class ListenerSet {\n  /** The generation every `add` joins until the next `dispose()`. */\n  #abort = new AbortController();\n\n  /**\n   * Attaches `handler` to the open generation, exactly as the caller spelled it.\n   *\n   * The set supplies the signal, so `options` carries everything else the DOM\n   * accepts — `capture` included, which has to match at release time and no\n   * longer has a second place to drift from.\n   */\n  add(\n    target: EventTarget,\n    type: string,\n    handler: EventListener,\n    options?: Omit<AddEventListenerOptions, \"signal\">,\n  ): void {\n    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });\n  }\n\n  /**\n   * Releases every listener of the open generation, synchronously, and opens the\n   * next one. Idempotent, and safe before anything has been added.\n   */\n  dispose(): void {\n    this.#abort.abort();\n    this.#abort = new AbortController();\n  }\n}\n","/**\n * Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n *\n * Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n *\n * **A microtask is the right horizon, and the reason is specific.** Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n *\n * **The two guards are not the same guard.** Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n *\n * - **Before `connect()`** — Stimulus delivers initial target and Value callbacks\n *   ahead of `connect()`. Reconciling there would compute output against a\n *   controller whose own state has not been initialised, and `connect()` is\n *   about to do a full pass anyway.\n * - **After `disconnect()`** — Stimulus fires a callback for **every** target\n *   during teardown, and a microtask queued just before it would otherwise run\n *   against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n *   teardown path to drop the pending pass outright.\n *\n * Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n *\n * Scope is the scheduling only. *What* to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n *\n * @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n *\n * connect()    { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n *\n * optionTargetConnected()    { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n */\nexport class MicrotaskCoalescer {\n  readonly #run: () => void;\n  #queued = false;\n  #active = false;\n  #generation = 0;\n\n  /** @param run - the single reconciliation pass, invoked at most once per batch. */\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */\n  activate(): void {\n    this.#active = true;\n  }\n\n  /** Closes the window and drops any pending pass; call from `disconnect()`. */\n  cancel(): void {\n    this.#active = false;\n    this.#queued = false;\n    this.#generation += 1;\n  }\n\n  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */\n  schedule(): void {\n    if (!this.#active || this.#queued) return;\n    this.#queued = true;\n    const generation = this.#generation;\n    queueMicrotask(() => {\n      // A cancelled callback must not consume a pass queued after reconnect.\n      if (generation !== this.#generation || !this.#queued || !this.#active) return;\n      this.#queued = false;\n      this.#run();\n    });\n  }\n}\n","import { ListenerSet } from \"./listener_set\";\nimport { MicrotaskCoalescer } from \"./microtask_coalescer\";\n\n/**\n * Coalesces retained-element morphs and explicit lifecycle requests into one pass.\n *\n * Observe the controller's element after its initial state is settled. Morphs on\n * that element and bubbling morphs on its descendants share the same microtask\n * as {@link schedule}. The callback repairs derived output; the controller owns\n * any logical transition reporting. {@link disconnect} releases the listener and\n * cancels pending work, including work from an earlier connected lifetime.\n */\nexport class MorphRenderWatcher {\n  readonly #listeners = new ListenerSet();\n  readonly #pass: MicrotaskCoalescer;\n  #element: Element | null = null;\n  readonly #onMorph = (): void => this.#pass.schedule();\n\n  /** @param run - the single pass that repairs the settled controller's output. */\n  constructor(run: () => void) {\n    this.#pass = new MicrotaskCoalescer(run);\n  }\n\n  /** Opens observation; observing the same element again preserves queued work. */\n  observe(element: Element): void {\n    if (this.#element === element) return;\n    this.disconnect();\n    this.#element = element;\n    this.#pass.activate();\n    this.#listeners.add(element, \"turbo:morph-element\", this.#onMorph);\n  }\n\n  /** Requests one pass; requests outside an observed lifetime are ignored. */\n  schedule(): void {\n    this.#pass.schedule();\n  }\n\n  /** Releases observation and pending work synchronously; safe to repeat. */\n  disconnect(): void {\n    this.#listeners.dispose();\n    this.#pass.cancel();\n    this.#element = null;\n  }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { CompositionTracker } from \"../utils/composition_tracker\";\nimport { compileRegExp, parseJsonObject } from \"../utils/declared_value\";\nimport { inheritsFieldsetDisabled } from \"../utils/focus_candidate\";\nimport { halfWidthChar } from \"../utils/half_width\";\nimport { MorphRenderWatcher } from \"../utils/morph_render_watcher\";\n\n/** Default placeholder tokens → single-char regex sources (user tokens merge over these). */\nconst DEFAULT_TOKENS: Readonly<Record<string, string>> = {\n  \"9\": \"\\\\d\",\n  a: \"[A-Za-z]\",\n  \"*\": \"[A-Za-z0-9]\",\n};\n\n/**\n * Suffix of the attribute marking the hidden raw-value sink; its value may name the\n * paired input's `id`.\n */\nconst UNMASK_ATTR = \"unmask\";\n\n/** Which neighbour a deleting keystroke aimed at, when the platform names one. */\ntype Deletion = \"backward\" | \"forward\";\n\n/** Who moved the value: the user editing the field, or the controller re-deciding it. */\ntype Cause = \"edit\" | \"reconcile\";\n\n/** The outcome of applying a fixed mask to a raw string. */\nexport interface MaskResult {\n  /** The formatted (masked) string. */\n  readonly masked: string;\n  /** The significant characters only (literals/separators removed). */\n  readonly unmasked: string;\n  /** Whether every token slot in the pattern is filled. */\n  readonly complete: boolean;\n  /** Per-output-char flag: true where the char fills a token (not a literal). */\n  readonly tokenFlags: readonly boolean[];\n}\n\n/**\n * The form of `char` this token takes: as typed when the token accepts it, else\n * its half-width form when *that* is what the token accepts, else `null` for a\n * rejected character. Trying the character as typed first keeps a token written\n * for full-width text (or for text an IME leaves as kana) authoritative.\n */\nfunction acceptedForm(regex: RegExp, char: string): string | null {\n  if (regex.test(char)) return char;\n  const half = halfWidthChar(char);\n  return half !== char && regex.test(half) ? half : null;\n}\n\n/**\n * Applies a fixed mask `pattern` to `value` using `tokens` (placeholder → regex).\n * Non-matching input characters are rejected (skipped); literals are auto-inserted\n * and a typed literal that matches is consumed. A character an IME confirmed in\n * full-width form fills a token — or consumes a literal — when its half-width\n * form is the one the mask asked for, and the half-width form is what the output\n * carries. Pure and exported for direct testing.\n */\nexport function applyMask(\n  value: string,\n  pattern: string,\n  tokens: ReadonlyMap<string, RegExp>,\n): MaskResult {\n  let masked = \"\";\n  let unmasked = \"\";\n  const tokenFlags: boolean[] = [];\n  let valueIndex = 0;\n  let totalTokens = 0;\n\n  for (const patternChar of pattern) {\n    const regex = tokens.get(patternChar);\n    if (regex) totalTokens += 1;\n    if (valueIndex >= value.length) continue;\n\n    if (regex) {\n      // Skip rejected characters until one fills this token (or input runs out).\n      let taken: string | null = null;\n      while (valueIndex < value.length) {\n        taken = acceptedForm(regex, value[valueIndex] ?? \"\");\n        if (taken !== null) break;\n        valueIndex += 1;\n      }\n      if (taken === null) continue;\n      masked += taken;\n      unmasked += taken;\n      tokenFlags.push(true);\n      valueIndex += 1;\n    } else {\n      masked += patternChar;\n      tokenFlags.push(false);\n      // The literal is already in the output, so the typed character only has to\n      // be the one that renders it — in either width.\n      if (halfWidthChar(value[valueIndex] ?? \"\") === halfWidthChar(patternChar)) valueIndex += 1;\n    }\n  }\n\n  return {\n    masked,\n    unmasked,\n    complete: totalTokens > 0 && unmasked.length === totalTokens,\n    tokenFlags,\n  };\n}\n\n/**\n * The token map a `tokens` declaration selects: the defaults with the declared\n * single-char regex sources compiled over them.\n *\n * A declaration that is not a JSON object of string sources declares no tokens,\n * leaving the defaults. A source that is not a valid regex is answered per key:\n * a key that has a default keeps that default, and a key that has none is left\n * out so the character stays a literal. Either way the rest of the mask, and the\n * field, keep working instead of going down with the broken source.\n */\nfunction compileTokens(declaration: string): Map<string, RegExp> {\n  const map = new Map<string, RegExp>();\n  for (const [key, source] of Object.entries(DEFAULT_TOKENS)) {\n    const compiled = compileRegExp(source, \"exact\");\n    if (compiled) map.set(key, compiled);\n  }\n  for (const [key, source] of Object.entries(parseTokens(declaration))) {\n    const compiled = compileRegExp(source, \"exact\");\n    // A broken source declares nothing: the default this key may already carry\n    // is what it falls back to, and a key without one holds no token at all.\n    if (compiled) map.set(key, compiled);\n  }\n  return map;\n}\n\n/** The `{ token: source }` pairs a declaration holds; anything else reads as none. */\nfunction parseTokens(declaration: string): Record<string, string> {\n  const parsed = parseJsonObject(declaration);\n  if (parsed === null) return {};\n\n  const tokens: Record<string, string> = {};\n  for (const [key, source] of Object.entries(parsed)) {\n    if (typeof source === \"string\") tokens[key] = source;\n  }\n  return tokens;\n}\n\n/** The direction an `input` event deleted in, or `null` when it is not a deletion. */\nfunction deletionOf(event: Event | undefined): Deletion | null {\n  const inputType = event instanceof InputEvent ? event.inputType : \"\";\n  if (!inputType.startsWith(\"delete\")) return null;\n  // Word, line, and content deletions all name their direction; the ones that\n  // name none (a cut, a drag-out) took a selection, so read them as backward.\n  return inputType.endsWith(\"Forward\") ? \"forward\" : \"backward\";\n}\n\n/** The offset of the `n`-th token char in a masked string, or `-1` when there is none. */\nfunction tokenCharOffset(tokenFlags: readonly boolean[], n: number): number {\n  let seen = 0;\n  for (let i = 0; i < tokenFlags.length; i += 1) {\n    if (!tokenFlags[i]) continue;\n    seen += 1;\n    if (seen === n) return i;\n  }\n  return -1;\n}\n\n/**\n * Headless **input mask** — formats a field in place against a fixed pattern\n * (`9`=digit, `a`=letter, `*`=alphanumeric, others literal), preserving the caret,\n * rejecting invalid characters, and syncing the raw value to a hidden field. No\n * dedicated APG pattern; `stimeo--currency-input` owns money-specific formatting.\n *\n * Markup contract (identifier: `stimeo--input-mask`, on the `<input>`):\n *   <input type=\"text\" inputmode=\"numeric\"\n *          data-controller=\"stimeo--input-mask\"\n *          data-stimeo--input-mask-pattern-value=\"999-9999\"\n *          data-action=\"input->stimeo--input-mask#format\">\n *   <input type=\"hidden\" name=\"zip\" data-stimeo--input-mask-unmask>\n *\n * `change` and `reconcile` dispatch `{ masked, unmasked, complete }`.\n *\n * @remarks\n * Behavior only and **idempotent** — the formatted value lives only in the input and\n * the hidden field (no module-scope state), so `connect()` re-formats the existing\n * value and is stable across Turbo restore/morph. The controller sits on the\n * `<input>` itself (a void element), so the raw-value sink is not a Stimulus target;\n * it is the `[data-stimeo--input-mask-unmask]` field resolved nearest-first among\n * the associated form's own controls (an explicit pairing by the sink attribute's\n * value naming the input's `id` wins; otherwise the closest ancestor's value-less\n * sink) — when one form holds several masked inputs, wrap each input+sink pair in a\n * container or pair them by `id`.\n *\n * Formatting never steals keys: it rejects disallowed characters silently and keeps\n * the caret on insert, Backspace, and range replacement (WCAG 2.2 3.3.2 / 1.3.5;\n * the expected format is the consumer's `aria-describedby`). The caret anchors on\n * the token slots the text before it fills, so a rejected character leaves it\n * exactly where it was. Backspace and Delete always progress: when the keystroke\n * only removed literals the mask re-inserts, the significant character it aimed at\n * goes instead. Events fired mid-IME-composition are ignored; the confirmed text is\n * formatted once on `compositionend`. A `pattern` / `tokens` / `unmaskToHidden`\n * change that arrives mid-composition leaves the uncommitted text alone and applies\n * with that same format: as the user's `change` when the composition committed\n * text, as `reconcile` when it ended on the text it began with.\n *\n * It reflects `data-mask-complete` / `data-mask-empty`, dispatches\n * `stimeo--input-mask:change` only when a user edit moves the committed value, and\n * `stimeo--input-mask:reconcile` when the controller itself decides that value —\n * a server-rendered or restored value normalized on connection, or a re-format\n * after `pattern` / `tokens` / `unmaskToHidden` changed. A malformed `tokens`\n * declaration falls back to the default tokens, and a single broken source falls\n * back to that key's default: it is parsed once in `tokensValueChanged`, and the\n * hot path only ever sees the validated map. A field\n * the user cannot edit (`readonly`, `disabled`, or inside a disabled `<fieldset>`)\n * keeps the value the page authored — the sink and the state hooks still follow it,\n * but the field itself is never rewritten. The composition listener is released on\n * `disconnect()`.\n */\nexport class InputMaskController extends Controller<HTMLInputElement> {\n  /** The attribute above, in the namespace this controller is registered under. */\n  get #unmaskAttribute(): string {\n    return `data-${this.identifier}-${UNMASK_ATTR}`;\n  }\n\n  static override values = {\n    pattern: { type: String, default: \"\" },\n    tokens: { type: String, default: \"\" },\n    unmaskToHidden: { type: Boolean, default: true },\n  };\n  static actions = [\"format\"] as const;\n  static events = [\"change\", \"reconcile\"] as const;\n\n  declare patternValue: string;\n  declare tokensValue: string;\n  declare unmaskToHiddenValue: boolean;\n\n  /** The value this controller last committed, and the baseline both events compare. */\n  #lastValue: string | null = null;\n  #started = false;\n\n  /** Validated token map; the hot path never parses the `tokens` declaration. */\n  #tokens = compileTokens(\"\");\n\n  /** The field's text when the running composition began. */\n  #textBeforeComposition = \"\";\n\n  /**\n   * Holds mid-composition input so the IME's uncommitted text is never rewritten,\n   * and formats the confirmed text once when the composition ends. A composition\n   * that ends on the text it began with committed nothing, so a re-format then is\n   * the page's: the mask changed while it ran.\n   */\n  readonly #composition = new CompositionTracker({\n    onStart: () => {\n      this.#textBeforeComposition = this.element.value;\n    },\n    onEnd: () => {\n      const committedNothing = this.element.value === this.#textBeforeComposition;\n      this.#reformat(committedNothing ? \"reconcile\" : \"edit\");\n    },\n  });\n\n  /** Re-parses the declaration and re-formats under the tokens it now selects. */\n  tokensValueChanged(): void {\n    this.#tokens = compileTokens(this.tokensValue);\n    if (this.#started) this.#reformat(\"reconcile\");\n  }\n\n  patternValueChanged(): void {\n    if (this.#started) this.#reformat(\"reconcile\");\n  }\n\n  /** Clears a sink it stops maintaining so a submit cannot carry a stale raw value. */\n  unmaskToHiddenValueChanged(): void {\n    if (!this.#started) return;\n    if (!this.unmaskToHiddenValue) {\n      const sink = this.#resolveSink();\n      if (sink) sink.value = \"\";\n    }\n    this.#reformat(\"reconcile\");\n  }\n\n  readonly #morph = new MorphRenderWatcher(() => this.#reformat(\"reconcile\"));\n\n  override connect(): void {\n    this.#morph.observe(this.element);\n    this.#started = true;\n    this.#composition.observe(this.element);\n    // Seed the baseline from the DOM so a value that is already masked stays\n    // silent, then re-format any server-rendered/restored value.\n    this.#lastValue = this.element.value;\n    this.#reformat(\"reconcile\");\n  }\n\n  override disconnect(): void {\n    this.#morph.disconnect();\n    this.#started = false;\n    this.#composition.disconnect();\n  }\n\n  /** Formats the field on input, preserving the caret. Bound via `data-action`. */\n  format(event?: Event): void {\n    if (this.#composition.isComposing(event as InputEvent | undefined)) return;\n    this.#reformat(\"edit\", deletionOf(event));\n  }\n\n  /**\n   * Core reformat: mask the current value, restore the caret, sync the sink and\n   * the state hooks, and report a moved value under the event `cause` selects.\n   *\n   * @stimeoRenderRoot\n   */\n  #reformat(cause: Cause, deletion: Deletion | null = null): void {\n    // The IME owns the text until it commits; the composition's end re-formats it.\n    if (this.#composition.isComposing()) return;\n    const input = this.element;\n    const raw = input.value;\n\n    // No pattern → act as a pass-through. Without this branch `applyMask` would\n    // produce an empty string and blank a misconfigured field's value; the hooks\n    // still describe the field so a pattern removed at runtime cannot leave a\n    // stale `data-mask-complete` behind.\n    if (this.patternValue === \"\") {\n      this.#flag(\"data-mask-complete\", false);\n      this.#flag(\"data-mask-empty\", raw.length === 0);\n      this.#lastValue = raw;\n      return;\n    }\n\n    const caret = input.selectionStart ?? raw.length;\n    let anchor = this.#significantBefore(raw.slice(0, caret));\n    let result = applyMask(raw, this.patternValue, this.#tokens);\n\n    // A deletion that only took literals the mask re-inserts would land back on\n    // the value it started from, so that keystroke could never delete anything:\n    // drop the significant character it aimed at instead.\n    if (deletion !== null && result.masked === this.#lastValue) {\n      const target = deletion === \"backward\" ? anchor : anchor + 1;\n      const offset = tokenCharOffset(result.tokenFlags, target);\n      if (offset >= 0) {\n        anchor = target - 1;\n        result = applyMask(\n          result.masked.slice(0, offset) + result.masked.slice(offset + 1),\n          this.patternValue,\n          this.#tokens,\n        );\n      }\n    }\n\n    // The value of a field the user cannot edit belongs to the page: publish the\n    // derived outputs against it, but never rewrite it and never report a move.\n    if (input.readOnly || input.disabled || inheritsFieldsetDisabled(input)) {\n      this.#publish(result, raw);\n      this.#lastValue = raw;\n      return;\n    }\n\n    if (input.value !== result.masked) {\n      input.value = result.masked;\n      this.#restoreCaret(result.tokenFlags, anchor);\n    }\n    this.#publish(result, result.masked);\n\n    if (result.masked === this.#lastValue) return;\n    this.#lastValue = result.masked;\n    const detail = { masked: result.masked, unmasked: result.unmasked, complete: result.complete };\n    if (cause === \"edit\") this.dispatch(\"change\", { detail });\n    else this.dispatch(\"reconcile\", { detail });\n  }\n\n  /** Syncs the raw-value sink and the state hooks for the `shown` field text. */\n  #publish(result: MaskResult, shown: string): void {\n    if (this.unmaskToHiddenValue) {\n      const sink = this.#resolveSink();\n      if (sink) sink.value = result.unmasked;\n    }\n    this.#flag(\"data-mask-complete\", result.complete);\n    this.#flag(\"data-mask-empty\", shown.length === 0);\n  }\n\n  /**\n   * How many token slots the text before the caret fills. Masking that prefix is\n   * what makes a rejected character — or a literal that also matches a token —\n   * count exactly as the rendering counts it, so the caret cannot drift.\n   */\n  #significantBefore(prefix: string): number {\n    return applyMask(prefix, this.patternValue, this.#tokens).unmasked.length;\n  }\n\n  /** Places the caret after the `n`-th token char (skipping following literals). */\n  #restoreCaret(tokenFlags: readonly boolean[], n: number): void {\n    let position: number;\n    if (n <= 0) {\n      // Sit after any leading literals, before the first token slot.\n      let i = 0;\n      while (i < tokenFlags.length && !tokenFlags[i]) i += 1;\n      position = i;\n    } else {\n      const offset = tokenCharOffset(tokenFlags, n);\n      if (offset < 0) {\n        position = tokenFlags.length;\n      } else {\n        let j = offset + 1;\n        while (j < tokenFlags.length && !tokenFlags[j]) j += 1;\n        position = j;\n      }\n    }\n    try {\n      this.element.setSelectionRange(position, position);\n    } catch {\n      /* selection unsupported for this input type — value formatting still applies */\n    }\n  }\n\n  /**\n   * The hidden raw-value sink for this input, resolved so several masked inputs\n   * can coexist in one form:\n   *\n   * 1. **Explicit pairing** — a sink whose attribute value names this input's\n   *    `id` (`data-stimeo--input-mask-unmask=\"zip\"`).\n   * 2. **Nearest container** — otherwise, walking up from the input, the first\n   *    *value-less* sink in the closest ancestor. Wrapped input+sink pairs each\n   *    find their own sink, and a single form-level sink is found the same\n   *    way. A sink claimed by another input's id is never matched here.\n   *\n   * Both steps only ever consider the associated form's own controls, so a sink\n   * belonging to a different form (or to none) is never written, while one the\n   * `form` attribute associates from elsewhere in the document still resolves —\n   * for either the input or the sink, neither of which needs to contain or be\n   * contained by the form. A form-less input reads the document instead.\n   */\n  #resolveSink(): HTMLInputElement | null {\n    const candidates = this.#sinkCandidates();\n    const id = this.element.id;\n    if (id.length > 0) {\n      const paired = candidates.find((sink) => sink.getAttribute(this.#unmaskAttribute) === id);\n      if (paired) return paired;\n    }\n\n    // A bare (value-less) attribute is unclaimed, so a sink naming another\n    // input's id can never be taken by this fallback.\n    const free = candidates.filter((sink) => sink.getAttribute(this.#unmaskAttribute) === \"\");\n    for (let node = this.element.parentElement; node !== null; node = node.parentElement) {\n      const ancestor = node;\n      const sink = free.find((candidate) => ancestor.contains(candidate));\n      if (sink) return sink;\n    }\n    return null;\n  }\n\n  /**\n   * Every sink the input's form owns, in document order — one collection read per\n   * resolution, so the cost tracks the form's own controls and not the depth of\n   * the markup around it. `form.elements` lists controls the `form` attribute\n   * associates from anywhere in the document, and lists nothing another form owns.\n   */\n  #sinkCandidates(): HTMLInputElement[] {\n    const form = this.element.form;\n    if (form === null) {\n      return Array.from(\n        document.querySelectorAll<HTMLInputElement>(`input[${this.#unmaskAttribute}]`),\n      );\n    }\n    return Array.from(form.elements).filter(\n      (element): element is HTMLInputElement =>\n        element instanceof HTMLInputElement && element.hasAttribute(this.#unmaskAttribute),\n    );\n  }\n\n  /** Sets a boolean `data-*` flag to `\"true\"` when `on`, else removes it. */\n  #flag(name: string, on: boolean): void {\n    if (on) this.element.setAttribute(name, \"true\");\n    else this.element.removeAttribute(name);\n  }\n}\n"]}

package/dist/controllers/intersection_controller.d.ts

@@ -31,12 +31,17 @@ import { Controller } from '@hotwired/stimulus';
  * idempotent: the previous state is read back from `data-intersecting`/
  * `data-passed`, so a Turbo cache restore does not re-fire `enter` for an
  * element that was already visible (and with `once`, an element whose enter
- * already fired is not observed again). `threshold` is re-read when Turbo morphs
- * the attribute in place, and a `rootSelector` that does not parse observes the
- * viewport rather than leaving the element unobserved. Without
- * `IntersectionObserver` (very old browsers) the controller stays inert —
- * consumers keep whatever no-JS fallback their markup provides. The observer is
- * disconnected on `disconnect()` (Turbo navigation included).
+ * already fired is not observed again). Every Value follows a runtime change —
+ * a Turbo morph, a Stream, an author script: the observer is rebuilt once per
+ * batch from the current declaration, and only when the root node, `rootMargin`
+ * or the lines it observes differ from the live one. `once` follows the same
+ * way: turned off after its enter, the element is observed again and the first
+ * callback is measured against the recorded hooks, exactly as on a reconnect;
+ * turned on once an enter is recorded, observing stops. A `rootSelector` that
+ * does not parse observes the viewport rather than leaving the element
+ * unobserved. Without `IntersectionObserver` (very old browsers) the controller
+ * stays inert — consumers keep whatever no-JS fallback their markup provides.
+ * The observer is disconnected on `disconnect()` (Turbo navigation included).
  */
 declare class IntersectionController extends Controller<HTMLElement> {
     #private;
@@ -62,6 +67,16 @@ declare class IntersectionController extends Controller<HTMLElement> {
             default: boolean;
         };
     };
+    static valueConstraints: {
+        threshold: {
+            readonly finite: true;
+        };
+        ratioSteps: {
+            finite: true;
+            min: number;
+            max: number;
+        };
+    };
     static actions: readonly ["refresh"];
     static events: readonly ["enter", "exit", "change", "passed"];
     thresholdValue: number;
@@ -72,15 +87,19 @@ declare class IntersectionController extends Controller<HTMLElement> {
     connect(): void;
     disconnect(): void;
     /**
-     * Re-reads the visibility line and rebuilds the observer. Turbo 8 morphing
-     * rewrites the attribute in place without a reconnect, and the line is what
-     * the intersection callback compares every ratio against, so a value frozen at
-     * connect time would decide `data-intersecting` wrongly for the rest of the
-     * page's life. Nothing to rebuild before the first `connect()`; after a spent
-     * one-shot the watcher is deliberately stopped, and re-observing would deliver
-     * the current state and fire `enter` a second time.
+     * Follows the visibility line: the intersection callback compares every ratio
+     * against it, so a line frozen at connect time would decide
+     * `data-intersecting` wrongly for the rest of the page's life.
      */
     thresholdValueChanged(): void;
+    /** Follows the fine-grained `change` steps the observer notifies at. */
+    ratioStepsValueChanged(): void;
+    /** Follows the margin the observer grows or shrinks its root by. */
+    rootMarginValueChanged(): void;
+    /** Validates `rootSelector` once per change, then follows the root it names. */
+    rootSelectorValueChanged(): void;
+    /** Follows whether one recorded enter ends the observation. */
+    onceValueChanged(): void;
     /**
      * Re-delivers the current intersection state as a fresh transition. Bound via
      * `data-action` (e.g. `my-feed:appended@window->stimeo--intersection#refresh`).