stimeo-ui 0.12.0 → 0.14.0

data/dist/controllers/navigation_menu_controller.js

@@ -103,6 +103,12 @@ var EscapeLayer = class _EscapeLayer {
   }
 };
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+
 // src/utils/safe_timeout.ts
 var TimerRegistry = class {
   /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
@@ -395,7 +401,7 @@ var NavigationMenuController = class extends Controller {
    */
   #onPointerLeave = (event) => {
     const next = event instanceof MouseEvent ? event.relatedTarget : null;
-    if (next instanceof Node && this.#hoverElements.some((el) => el.contains(next))) return;
+    if (ownerIndex(this.#hoverElements, next) !== -1) return;
     this.#hoveredTrigger = null;
     this.#hoverTimers.clearAll();
     this.#hoverTimers.set(() => this.#closeFromHover(), this.hoverDelayValue);
@@ -465,7 +471,7 @@ var NavigationMenuController = class extends Controller {
    */
   get #hoverElements() {
     const areas = this.hoverAreaTargets;
-    const covered = (element) => areas.some((area) => area.contains(element));
+    const covered = (element) => ownerIndex(areas, element) !== -1;
     return [
       ...areas,
       ...this.triggerTargets.filter((trigger) => !covered(trigger)),

data/dist/controllers/optimistic_controller.js

@@ -1,32 +1,115 @@
 import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/optimistic_controller.ts
-var TOGGLED_MARKER = "data-optimistic-toggled";
+
+// src/utils/detach_gate.ts
+var DetachGate = class _DetachGate {
+  /** Set while a probe is queued, waiting for a reconnect to cancel it. */
+  #pending = false;
+  /**
+   * True while a probe is queued — the last disconnect was ambiguous and no
+   * reconnect has cancelled it yet. Read it from `connect()` to tell the
+   * reconnect half of an in-page move from a first connect: a controller whose
+   * initialisation restarts a measurement (a min-duration floor, an elapsed
+   * counter) must skip it for the move, where nothing actually restarted.
+   */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+   * True when the disconnect is definitely a real detach — the element left
+   * the document, or `data-controller` no longer lists the identifier. False
+   * means ambiguous (in-page move or observed-root exit), NOT "alive".
+   */
+  static isDetached(host) {
+    if (!host.element.isConnected) return true;
+    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
+    return !tokens.includes(host.identifier);
+  }
+  /**
+   * Call from `disconnect()`: runs `teardown` synchronously on a definite
+   * detach (fast path), otherwise defers it one microtask — a reconnect
+   * ({@link cancel} from `connect()`) keeps the state, no reconnect runs it.
+   * One microtask is the whole probe window: Stimulus reconnects a moved
+   * element within the same mutation batch, before the checkpoint drains.
+   */
+  disconnected(host, teardown) {
+    if (_DetachGate.isDetached(host)) {
+      this.#pending = false;
+      teardown();
+      return;
+    }
+    this.#pending = true;
+    queueMicrotask(() => {
+      if (!this.#pending) return;
+      this.#pending = false;
+      teardown();
+    });
+  }
+  /**
+   * Disarms a pending probe. Call from `connect()` (the reconnect that proves
+   * an in-page move) and from the head of any teardown path not routed through
+   * {@link disconnected} (disabled-toggle, Escape), so an orphaned probe can
+   * never run the teardown a second time.
+   */
+  cancel() {
+    this.#pending = false;
+  }
+};
+
+// src/controllers/optimistic_controller.ts
+var HIDDEN_MARKER = "data-optimistic-toggled";
+var BUSY_MARKER = "data-optimistic-busy";
+var AUTHORED_ABSENT = "absent";
+var AUTHORED_VALUE = "value:";
+var SYNTHETIC_SUBMISSION = {};
+function submissionOf(event) {
+  const detail = event.detail;
+  return detail?.formSubmission ?? SYNTHETIC_SUBMISSION;
+}
 var OptimisticController = class extends Controller {
   static targets = ["show", "hide"];
   static events = ["commit", "rollback"];
+  /** The submission that owns the applied optimistic state, if any. */
+  #pending = null;
+  #gate = new DetachGate();
+  /** True between `connect()` and `disconnect()`, so a repeat connect rewinds nothing. */
+  #connected = false;
   connect() {
-    if (this.element.hasAttribute("data-optimistic")) this.#revert();
+    const restored = !this.#connected && !this.#gate.pending;
+    this.#gate.cancel();
+    this.#connected = true;
+    if (restored && this.element.hasAttribute("data-optimistic")) this.#revert();
     this.element.addEventListener("turbo:submit-start", this.#onSubmitStart);
     this.element.addEventListener("turbo:submit-end", this.#onSubmitEnd);
   }
   disconnect() {
+    this.#connected = false;
     this.element.removeEventListener("turbo:submit-start", this.#onSubmitStart);
     this.element.removeEventListener("turbo:submit-end", this.#onSubmitEnd);
+    this.#gate.disconnected(this, () => {
+      this.#pending = null;
+    });
   }
-  #onSubmitStart = () => {
+  #onSubmitStart = (event) => {
+    this.#pending = submissionOf(event);
+    if (this.element instanceof HTMLFormElement && !this.element.hasAttribute(BUSY_MARKER)) {
+      this.element.setAttribute(BUSY_MARKER, AUTHORED_ABSENT);
+    }
+    this.#write(this.element, "aria-busy", "true", BUSY_MARKER);
     this.element.setAttribute("data-optimistic", "true");
-    this.element.setAttribute("aria-busy", "true");
-    for (const target of this.showTargets) this.#toggleHidden(target, false);
-    for (const target of this.hideTargets) this.#toggleHidden(target, true);
+    for (const target of this.showTargets) this.#setHidden(target, false);
+    for (const target of this.hideTargets) this.#setHidden(target, true);
   };
   #onSubmitEnd = (event) => {
+    if (submissionOf(event) !== this.#pending) return;
+    this.#pending = null;
     const success = event.detail?.success === true;
-    this.element.removeAttribute("aria-busy");
     if (success) {
       this.element.removeAttribute("data-optimistic");
+      this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
       for (const target of [...this.showTargets, ...this.hideTargets]) {
-        target.removeAttribute(TOGGLED_MARKER);
+        target.removeAttribute(HIDDEN_MARKER);
       }
       this.dispatch("commit");
     } else {
@@ -34,21 +117,59 @@ var OptimisticController = class extends Controller {
       this.dispatch("rollback");
     }
   };
-  /** Sets `hidden` only when it actually changes, marker-tracking the mutation. */
-  #toggleHidden(target, hidden) {
-    if (target.hidden === hidden) return;
-    target.hidden = hidden;
-    target.setAttribute(TOGGLED_MARKER, "true");
+  /** Hides or reveals a target, recording the authored `hidden` on first write. */
+  #setHidden(target, hidden) {
+    if (target.hasAttribute("hidden") === hidden) return;
+    this.#write(target, "hidden", hidden ? "" : null, HIDDEN_MARKER);
+  }
+  /** Writes an attribute, recording what it displaced under `marker` once. */
+  #write(element, attribute, value, marker) {
+    if (!element.hasAttribute(marker)) {
+      const authored = element.getAttribute(attribute);
+      element.setAttribute(
+        marker,
+        authored === null ? AUTHORED_ABSENT : `${AUTHORED_VALUE}${authored}`
+      );
+    }
+    if (value === null) element.removeAttribute(attribute);
+    else element.setAttribute(attribute, value);
   }
-  /** Reverts exactly the mutations this controller made (marker-owned only). */
+  /**
+   * Puts back the value `marker` recorded and drops the record.
+   *
+   * `written` is what this controller last put in the attribute. Anything else
+   * there now belongs to whoever wrote it — Turbo owns `aria-busy` on a form and
+   * clears it before the terminal arrives, and a consumer may have moved a face
+   * mid-flight — so the record is dropped without touching the attribute. A
+   * marker this build did not write names no authored value, so the attribute
+   * goes back to being absent.
+   */
+  #restore(element, attribute, marker, written) {
+    const recorded = element.getAttribute(marker);
+    if (recorded === null) return;
+    element.removeAttribute(marker);
+    if (element.getAttribute(attribute) !== written) return;
+    if (recorded.startsWith(AUTHORED_VALUE)) {
+      element.setAttribute(attribute, recorded.slice(AUTHORED_VALUE.length));
+      return;
+    }
+    element.removeAttribute(attribute);
+  }
+  /**
+   * Puts back exactly the markup this controller displaced (record-owned only).
+   *
+   * A face can be registered on both sides, and the hide pass runs last, so what
+   * this controller wrote there is `hidden` — matching it against the reveal's
+   * absent value instead would read as someone else's write and leave the face
+   * hidden. Each target is therefore restored once, against the write it last
+   * received.
+   */
   #revert() {
     this.element.removeAttribute("data-optimistic");
-    this.element.removeAttribute("aria-busy");
-    for (const target of [...this.showTargets, ...this.hideTargets]) {
-      if (target.hasAttribute(TOGGLED_MARKER)) {
-        target.hidden = !target.hidden;
-        target.removeAttribute(TOGGLED_MARKER);
-      }
+    this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
+    const hidden = new Set(this.hideTargets);
+    for (const target of /* @__PURE__ */ new Set([...this.showTargets, ...this.hideTargets])) {
+      this.#restore(target, "hidden", HIDDEN_MARKER, hidden.has(target) ? "" : null);
     }
   }
 };

data/dist/controllers/otp_controller.js

@@ -152,6 +152,25 @@ var CompositionTracker = class {
   };
 };
 
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function compileRegExp(source, anchor = "none") {
+  return parseDeclared(
+    source,
+    (text) => {
+      const bare = new RegExp(text);
+      return anchor === "exact" ? new RegExp(`^(?:${text})$`) : bare;
+    },
+    null
+  );
+}
+
 // src/utils/half_width.ts
 var FULL_WIDTH_SHIFT = 65248;
 function halfWidthChar(char) {
@@ -201,13 +220,7 @@ var MicrotaskCoalescer = class {
 
 // src/controllers/otp_controller.ts
 var DEFAULT_PATTERN = "[0-9]";
-function compilePattern(source) {
-  try {
-    return new RegExp(`^${source}$`);
-  } catch {
-    return null;
-  }
-}
+var DEFAULT_MATCHER = new RegExp(`^(?:${DEFAULT_PATTERN})$`);
 function hasModifier(event) {
   return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 }
@@ -222,7 +235,7 @@ var OtpController = class extends Controller {
   static actions = ["onInput", "onKeydown", "onPaste", "onPointerDown", "clear"];
   static events = ["change", "complete", "invalid", "reconcile"];
   /** Validated matcher; the hot path never compiles a raw declaration. */
-  #pattern = new RegExp(`^${DEFAULT_PATTERN}$`);
+  #pattern = DEFAULT_MATCHER;
   /** Source of {@link #pattern}, reported in `invalid` so consumers can word it. */
   #patternSource = DEFAULT_PATTERN;
   /** Public state carried by the last dispatch; keeps a no-op sync silent. */
@@ -295,9 +308,9 @@ var OtpController = class extends Controller {
    * the new pattern no longer accepts, so the combined value stays interpretable.
    */
   patternValueChanged() {
-    const compiled = compilePattern(this.patternValue);
+    const compiled = compileRegExp(this.patternValue, "exact");
     this.#patternSource = compiled ? this.patternValue : DEFAULT_PATTERN;
-    this.#pattern = compiled ?? new RegExp(`^${DEFAULT_PATTERN}$`);
+    this.#pattern = compiled ?? DEFAULT_MATCHER;
     if (!this.#connected) return;
     let dropped = false;
     for (const field of this.fieldTargets) {

data/dist/controllers/overflow_menu_controller.js

@@ -31,6 +31,15 @@ var BeforeCacheReset = class _BeforeCacheReset {
   }
 };
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
 // src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
@@ -502,7 +511,7 @@ var OverflowMenuController = class extends Controller {
   }
   /** The managed item that is, or contains, `el` — focus rescue works on either. */
   #ownerOf(el) {
-    return this.#items.find((item) => item === el || item.contains(el)) ?? null;
+    return ownerOf(this.#items, el);
   }
   /** Whether the item takes up room in the bar; an authored `hidden` one does not. */
   #rendered(item) {

data/dist/controllers/pointer_drag_controller.js

@@ -63,6 +63,15 @@ var DetachGate = class _DetachGate {
   }
 };
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
 // src/controllers/pointer_drag_controller.ts
 var NATIVE_KEY_OWNERS = "input, textarea, select, button, a[href], summary, [contenteditable]";
 var PointerDragController = class _PointerDragController extends Controller {
@@ -406,9 +415,7 @@ var PointerDragController = class _PointerDragController extends Controller {
   }
   /** Resolves the handle owning an event target (the handle or a descendant). */
   #handleFor(target) {
-    const node = target;
-    if (!node) return null;
-    return this.#handles().find((handle) => handle === node || handle.contains(node)) ?? null;
+    return ownerOf(this.#handles(), target);
   }
   #pointerTypeOf(event) {
     const type = event.pointerType;

data/dist/controllers/portal_controller.js

@@ -2,6 +2,26 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/portal_controller.ts
 
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function validSelector(element, raw, fallback) {
+  if (raw.length === 0) return fallback;
+  return parseDeclared(
+    raw,
+    (selector) => {
+      element.matches(selector);
+      return selector;
+    },
+    fallback
+  );
+}
+
 // src/utils/detach_gate.ts
 var DetachGate = class _DetachGate {
   /** Set while a probe is queued, waiting for a reconnect to cancel it. */
@@ -81,16 +101,7 @@ var PortalController = class extends Controller {
    * instead, which reads as a mistake and can be traced back to the declaration.
    */
   toValueChanged() {
-    const selector = this.toValue;
-    if (selector.length > 0) {
-      try {
-        this.element.matches(selector);
-        this.#toSelector = selector;
-        return;
-      } catch {
-      }
-    }
-    this.#toSelector = "body";
+    this.#toSelector = validSelector(this.element, this.toValue, "body");
   }
   connect() {
     this.#gate.cancel();

data/dist/controllers/radio_group_controller.js

@@ -20,6 +20,15 @@ function isReservedArrowChord(event, allow = []) {
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
 // src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
@@ -479,9 +488,8 @@ var RadioGroupController = class extends Controller {
   }
   /** Finds this group's radio containing an event target, excluding nested groups. */
   #radioForEventTarget(target) {
-    if (!this.#ownsEventTarget(target)) return void 0;
-    const node = target;
-    return this.radioTargets.find((radio) => radio === node || radio.contains(node));
+    if (!this.#ownsEventTarget(target)) return null;
+    return ownerOf(this.radioTargets, target);
   }
   /** Whether the closest Radio Group scope around a target is this instance. */
   #ownsEventTarget(target) {

data/dist/controllers/relative_time_controller.js

@@ -31,6 +31,35 @@ var BeforeCacheReset = class _BeforeCacheReset {
   }
 };
 
+// src/utils/intl_format.ts
+var formatters = /* @__PURE__ */ new WeakMap();
+function intlFormatter(factory, locale, options, fallbackLocale) {
+  const cache = cacheFor(factory);
+  const key = cacheKey(locale, options, fallbackLocale);
+  if (cache.has(key)) return cache.get(key);
+  const formatter = construct(factory, locale, options);
+  cache.set(key, formatter);
+  return formatter;
+}
+function cacheFor(factory) {
+  const existing = formatters.get(factory);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  formatters.set(factory, created);
+  return created;
+}
+function cacheKey(locale, options, fallbackLocale) {
+  return JSON.stringify([locale, options, fallbackLocale]);
+}
+function construct(factory, locale, options, fallbackLocale) {
+  try {
+    return new factory(locale, options);
+  } catch (error) {
+    if (!(error instanceof RangeError)) throw error;
+    return null;
+  }
+}
+
 // src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
@@ -128,6 +157,7 @@ var UNITS = [
   { limit: 31557600, unit: "month", ms: 26298e5 },
   YEAR_SCALE
 ];
+var RELATIVE_OPTIONS = { numeric: "auto" };
 var RelativeTimeController = class extends Controller {
   static values = {
     locale: { type: String, default: "" },
@@ -235,11 +265,7 @@ var RelativeTimeController = class extends Controller {
    * when the runtime rejects that locale.
    */
   get #formatter() {
-    try {
-      return new Intl.RelativeTimeFormat(this.#locale, { numeric: "auto" });
-    } catch {
-      return null;
-    }
+    return intlFormatter(Intl.RelativeTimeFormat, this.#locale, RELATIVE_OPTIONS);
   }
   /** Locale precedence: the value, then the nearest `lang` up the ancestor chain. */
   get #locale() {

data/dist/controllers/reset_before_cache_controller.js

@@ -1,5 +1,27 @@
 import { Controller } from '@hotwired/stimulus';
 
+// src/controllers/reset_before_cache_controller.ts
+
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function validSelector(element, raw, fallback) {
+  if (raw.length === 0) return fallback;
+  return parseDeclared(
+    raw,
+    (selector) => {
+      element.matches(selector);
+      return selector;
+    },
+    fallback
+  );
+}
+
 // src/controllers/reset_before_cache_controller.ts
 var STATELESS_INPUT_TYPES = /* @__PURE__ */ new Set(["hidden", "submit", "reset", "button", "image"]);
 function restoreField(element) {
@@ -43,16 +65,7 @@ var ResetBeforeCacheController = class extends Controller {
    * silently taking the sweep down.
    */
   scopeValueChanged() {
-    const selector = this.scopeValue;
-    if (selector.length > 0) {
-      try {
-        this.element.matches(selector);
-        this.#scopeSelector = selector;
-        return;
-      } catch {
-      }
-    }
-    this.#scopeSelector = "";
+    this.#scopeSelector = validSelector(this.element, this.scopeValue, "");
   }
   connect() {
     document.addEventListener("turbo:before-cache", this.#onBeforeCache);

data/dist/controllers/resizable_controller.js

@@ -8,6 +8,12 @@ function isReservedArrowChord(event, allow = []) {
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+
 // src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
@@ -154,8 +160,7 @@ var ResizableController = class extends Controller {
     const panes = [];
     if (this.hasPrimaryTarget) panes.push(this.primaryTarget);
     if (this.hasSecondaryTarget) panes.push(this.secondaryTarget);
-    const target = event.target;
-    const current = panes.findIndex((pane) => target instanceof Node && pane.contains(target));
+    const current = ownerIndex(panes, event.target);
     const next = panes[(current + 1) % panes.length];
     if (!next) return;
     event.preventDefault();

data/dist/controllers/roving_controller.js

@@ -16,6 +16,12 @@ function hasModifierChord(event) {
   return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 }
 
+// src/utils/event_owner.ts
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+
 // src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
@@ -182,9 +188,7 @@ var RovingController = class extends Controller {
   };
   /** Resolves the item index owning an event target (the item or a descendant). */
   #indexOf(target) {
-    const node = target;
-    if (!node) return -1;
-    return this.itemTargets.findIndex((item) => item === node || item.contains(node));
+    return ownerIndex(this.itemTargets, target);
   }
   /** Makes `index` the tab stop (optionally focusing it), emitting `change` once. */
   #activate(index, focus) {

data/dist/controllers/scroll_visibility_controller.js

@@ -57,6 +57,26 @@ var BlurDeferral = class {
   }
 };
 
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function validSelector(element, raw, fallback) {
+  if (raw.length === 0) return fallback;
+  return parseDeclared(
+    raw,
+    (selector) => {
+      element.matches(selector);
+      return selector;
+    },
+    fallback
+  );
+}
+
 // src/utils/reduced_motion.ts
 function prefersReducedMotion() {
   return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
@@ -223,11 +243,11 @@ var ScrollVisibilityController = class extends Controller {
   }
   /** Validates `root` once so connect never parses a selector that throws. */
   rootValueChanged() {
-    this.#rootSelector = this.#validSelector(this.rootValue);
+    this.#rootSelector = validSelector(this.element, this.rootValue, "");
   }
   /** Validates `focusSelector` once so `toTop` never parses a selector that throws. */
   focusSelectorValueChanged() {
-    this.#focusSelector = this.#validSelector(this.focusSelectorValue);
+    this.#focusSelector = validSelector(this.element, this.focusSelectorValue, "");
   }
   /** Scrolls the source to the top and, optionally, moves focus to a safe target. */
   toTop() {
@@ -299,17 +319,6 @@ var ScrollVisibilityController = class extends Controller {
     if (focused instanceof HTMLElement && this.elementTarget.contains(focused)) return focused;
     return null;
   }
-  /** Returns `declared` when it parses as a selector, and `""` when it does not. */
-  #validSelector(declared) {
-    if (declared.length > 0) {
-      try {
-        this.element.matches(declared);
-        return declared;
-      } catch {
-      }
-    }
-    return "";
-  }
   #scrollY() {
     if (this.#scrollSource === window) {
       return window.scrollY ?? window.pageYOffset ?? 0;

data/dist/controllers/scrollspy_controller.js

@@ -2,14 +2,19 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/scrollspy_controller.ts
 
-// src/utils/intersection_watcher.ts
-function queryRoot(selector) {
-  if (!selector) return null;
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
   try {
-    return document.querySelector(selector);
+    return parse(raw);
   } catch {
+    return fallback;
   }
-  return null;
+}
+
+// src/utils/intersection_watcher.ts
+function queryRoot(selector) {
+  if (!selector) return null;
+  return parseDeclared(selector, (raw) => document.querySelector(raw), null);
 }
 var IntersectionWatcher = class {
   #onEntries;
@@ -239,7 +244,7 @@ var ScrollspyController = class extends Controller {
    * only rewrites attributes, so Stimulus fires no target callback: without
    * this, a link re-pointed from `#intro` to `#faq` would keep the controller
    * observing `#intro` for the rest of the page's life. The filter is exactly
-   * {@link ANCHOR_ATTRIBUTES}; guarding on `MutationObserver` keeps the
+   * `href` and `data-href`; guarding on `MutationObserver` keeps the
    * controller usable where the API is absent, matching `IntersectionWatcher`'s
    * own support guard.
    */