stimeo-ui 0.12.0 → 0.14.0

data/dist/index.js

@@ -1853,6 +1853,36 @@ var BulkSelectController = class extends Controller {
   }
 };
 
+// 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, fallbackLocale);
+  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;
+    if (fallbackLocale === void 0) return null;
+    return new factory(fallbackLocale, options);
+  }
+}
+
 // src/utils/dates.ts
 function toISODateString(date) {
   const year = date.getFullYear();
@@ -1886,6 +1916,10 @@ function parseISOMonthString(monthStr) {
 function toISOMonthString(date) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`;
 }
+var MONTH_LABEL_OPTIONS = { month: "long", year: "numeric" };
+function monthLabelFormatter(locale) {
+  return intlFormatter(Intl.DateTimeFormat, locale, MONTH_LABEL_OPTIONS, "en");
+}
 
 // src/controllers/calendar_controller.ts
 var OWNED_DISABLED = "data-stimeo--calendar-owns-disabled";
@@ -2070,8 +2104,7 @@ var CalendarController = class extends Controller {
     const month = monthStart.getMonth() + 1;
     if (this.hasLabelTarget) {
       const lang = document.documentElement.lang || "en";
-      const formatter = new Intl.DateTimeFormat(lang, { month: "long", year: "numeric" });
-      this.labelTarget.textContent = formatter.format(monthStart);
+      this.labelTarget.textContent = monthLabelFormatter(lang).format(monthStart);
     }
     const days = this.#calculateGridDays(year, month);
     const dayElements = this.dayTargets;
@@ -2238,6 +2271,15 @@ var CalendarController = class extends Controller {
   }
 };
 
+// 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/reduced_motion.ts
 function prefersReducedMotion() {
   return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
@@ -2323,7 +2365,7 @@ var CarouselController = class extends Controller {
   #handledEvents = /* @__PURE__ */ new WeakSet();
   /**
    * Whether `connect()` has run. Scheduling is already inert outside that window
-   * ({@link MicrotaskCoalescer}), so this gates the Value callbacks Stimulus
+   * (`MicrotaskCoalescer`), so this gates the Value callbacks Stimulus
    * delivers ahead of `connect()`.
    */
   #connected = false;
@@ -2581,9 +2623,7 @@ var CarouselController = class extends Controller {
   }
   /** Position of the picker that is or contains `node`, or `-1` when none does. */
   #pickerIndexFor(node) {
-    return this.pickerTargets.findIndex(
-      (picker) => node instanceof Node && (picker === node || picker.contains(node))
-    );
+    return ownerIndex(this.pickerTargets, node);
   }
   /** Whether a focus transition lands on another control of this same carousel. */
   #focusStaysInside(event) {
@@ -2802,9 +2842,7 @@ function hasModifier(event) {
   return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 }
 function hits(elements, node) {
-  return elements.some(
-    (element) => node instanceof Node && (element === node || element.contains(node))
-  );
+  return ownerIndex(elements, node) !== -1;
 }
 function setAttributeIfChanged(element, name, value) {
   if (element.getAttribute(name) !== value) element.setAttribute(name, value);
@@ -4383,7 +4421,7 @@ var CommandPaletteController = class _CommandPaletteController extends Controlle
    * re-deriving from the declarative `open` Value (which would slam a user-opened
    * palette shut). The `open` Value only seeds the initial state of a genuinely
    * fresh render. We normalize to a clean closed baseline first so {@link open}
-   * runs its full setup — the {@link FocusTrap} is a fresh instance after a
+   * runs its full setup — the `FocusTrap` is a fresh instance after a
    * reconnect and must be re-activated.
    */
   connect() {
@@ -4488,7 +4526,7 @@ var CommandPaletteController = class _CommandPaletteController extends Controlle
   }
   /**
    * Combobox navigation keys (arrows / Home / End / Enter), bound to the input.
-   * `Tab` (focus trap) and `Escape` (close) are owned by the {@link FocusTrap} at
+   * `Tab` (focus trap) and `Escape` (close) are owned by the shared `FocusTrap` at
    * the document level, so they work no matter which element inside the dialog has
    * focus — not only the input.
    */
@@ -5060,7 +5098,7 @@ var ConditionalFieldsController = class extends Controller {
   }
   /** Whether an authored mutation target belongs to a trigger, region, or managed control. */
   #elementAffectsState(target, triggers, regions) {
-    return triggers.some((trigger) => trigger === target || trigger.contains(target)) || regions.some((region) => region === target || region.contains(target));
+    return ownerIndex(triggers, target) !== -1 || ownerIndex(regions, target) !== -1;
   }
   /** Whether a form owns at least one current trigger, including `form=` associations. */
   #hasTriggerOwnedBy(form) {
@@ -5920,37 +5958,52 @@ var CurrencyInputController = class extends Controller {
    * formatters from the validated set.
    */
   #revalidate() {
-    this.#locale = "en-US";
-    try {
-      new Intl.NumberFormat(this.localeValue);
-      this.#locale = this.localeValue;
-    } catch {
-    }
+    const declaredLocale = intlFormatter(Intl.NumberFormat, this.localeValue, {});
+    this.#locale = declaredLocale === null ? "en-US" : this.localeValue;
     const precision = this.precisionValue;
     this.#precision = Number.isInteger(precision) && precision >= 0 && precision <= 100 ? precision : 2;
     this.#currency = "";
     if (this.currencyValue !== "") {
-      try {
-        new Intl.NumberFormat(this.#locale, { style: "currency", currency: this.currencyValue });
-        this.#currency = this.currencyValue;
-      } catch {
-      }
+      const declaredCurrency = intlFormatter(Intl.NumberFormat, this.#locale, {
+        style: "currency",
+        currency: this.currencyValue
+      });
+      if (declaredCurrency !== null) this.#currency = this.currencyValue;
     }
-    this.#grouping = new Intl.NumberFormat(this.#locale, {
-      useGrouping: true,
-      maximumFractionDigits: 0
-    });
-    this.#fixed = new Intl.NumberFormat(this.#locale, {
-      useGrouping: true,
-      minimumFractionDigits: this.#precision,
-      maximumFractionDigits: this.#precision
-    });
-    this.#accessible = this.#currency ? new Intl.NumberFormat(this.#locale, { style: "currency", currency: this.#currency }) : this.#fixed;
-    const parts = new Intl.NumberFormat(this.#locale).formatToParts(11111.1);
+    this.#grouping = intlFormatter(
+      Intl.NumberFormat,
+      this.#locale,
+      { useGrouping: true, maximumFractionDigits: 0 },
+      this.#locale
+    );
+    this.#fixed = intlFormatter(
+      Intl.NumberFormat,
+      this.#locale,
+      {
+        useGrouping: true,
+        minimumFractionDigits: this.#precision,
+        maximumFractionDigits: this.#precision
+      },
+      this.#locale
+    );
+    this.#accessible = this.#currency ? intlFormatter(
+      Intl.NumberFormat,
+      this.#locale,
+      { style: "currency", currency: this.#currency },
+      this.#locale
+    ) : this.#fixed;
+    const parts = intlFormatter(Intl.NumberFormat, this.#locale, {}, this.#locale).formatToParts(
+      11111.1
+    );
     this.#group = parts.find((p) => p.type === "group")?.value ?? ",";
     this.#decimal = parts.find((p) => p.type === "decimal")?.value ?? ".";
     this.#digits.clear();
-    const digitFormatter = new Intl.NumberFormat(this.#locale, { useGrouping: false });
+    const digitFormatter = intlFormatter(
+      Intl.NumberFormat,
+      this.#locale,
+      { useGrouping: false },
+      this.#locale
+    );
     for (let i = 0; i <= 9; i++) {
       const digit = digitFormatter.format(i);
       if (digit !== String(i)) this.#digits.set(digit, String(i));
@@ -6566,7 +6619,7 @@ var DateRangePickerController = class extends Controller {
     if (this.#previewDate && !this.#isSelectable(this.#previewDate)) this.#previewDate = "";
     if (this.hasMonthLabelTarget) {
       const lang = document.documentElement.lang || "en";
-      const formatter = monthFormatter(lang);
+      const formatter = monthLabelFormatter(lang);
       this.monthLabelTarget.textContent = formatter.format(new Date(year, month - 1, 1));
     }
     const [rangeStart, rangeEnd] = this.#visualRange();
@@ -6721,15 +6774,6 @@ function normalizeISO(value) {
 function orderRange(start, end) {
   return start && end && end < start ? [end, start] : [start, end];
 }
-function monthFormatter(locale) {
-  const options = { month: "long", year: "numeric" };
-  try {
-    return new Intl.DateTimeFormat(locale, options);
-  } catch (error) {
-    if (!(error instanceof RangeError)) throw error;
-    return new Intl.DateTimeFormat("en", options);
-  }
-}
 function computePreset(name) {
   const today = /* @__PURE__ */ new Date();
   const todayStr = toISODateString(today);
@@ -6791,6 +6835,43 @@ var DialogController = class extends Controller {
     return this.hasDialogTarget && !this.dialogTarget.hidden;
   }
 };
+
+// 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
+  );
+}
+function compileRegExp(source, anchor = "none") {
+  return parseDeclared(
+    source,
+    (text) => {
+      const bare = new RegExp(text);
+      return anchor === "exact" ? new RegExp(`^(?:${text})$`) : bare;
+    },
+    null
+  );
+}
+function parseJsonObject(raw) {
+  const parsed = parseDeclared(raw, (text) => JSON.parse(text), null);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  return parsed;
+}
+
+// src/controllers/direct_upload_controller.ts
 var REMOVE_DELAY = 4e3;
 var DirectUploadController = class extends Controller {
   static targets = ["list", "row"];
@@ -6845,16 +6926,7 @@ var DirectUploadController = class extends Controller {
   }
   /** Validates `scope` once so the per-event path never parses or throws. */
   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, "");
   }
   /** Updates a row's progress and the aggregate, emitting `progress`. */
   #updateProgress(id, percent, name) {
@@ -7411,7 +7483,7 @@ var DrawerController = class extends Controller {
    * rather than being re-derived from the declarative `open` Value (which would
    * close a user-opened drawer). The `open` Value only seeds a genuinely fresh
    * render. We normalize to a clean closed baseline first so {@link open} runs its
-   * full reveal + trap activation — the {@link FocusTrap} is inactive after a
+   * full reveal + trap activation — the `FocusTrap` is inactive after a
    * disconnect and must be re-activated.
    */
   connect() {
@@ -7544,7 +7616,7 @@ var DrawerController = class extends Controller {
    * Runs once the close transition has finished: applies `hidden` to the panel
    * and overlay, then reverts the modal side effects (scroll lock, background
    * `inert`, keydown listener) and restores focus to the opener. Deferring the
-   * {@link FocusTrap} teardown to here — rather than at {@link close} time — keeps
+   * `FocusTrap` teardown to here — rather than at {@link close} time — keeps
    * the background unreachable and focus trapped for the whole exit animation.
    */
   #applyHidden(panel) {
@@ -9089,7 +9161,7 @@ var FormFieldController = class _FormFieldController extends Controller {
         return this.errorTargets.includes(target);
       return record.attributeName === "id" && [...this.descriptionTargets, ...this.errorTargets].includes(target);
     }
-    return this.errorTargets.some((error) => error === target || error.contains(target));
+    return ownerIndex(this.errorTargets, target) !== -1;
   }
   /** Returns borrowed control ARIA before Turbo snapshots the page. */
   #rewindForCache() {
@@ -10009,22 +10081,19 @@ function applyMask(value, pattern, tokens) {
 }
 function compileTokens(declaration) {
   const map = /* @__PURE__ */ new Map();
-  for (const [key, source] of Object.entries({ ...DEFAULT_TOKENS, ...parseTokens(declaration) })) {
-    try {
-      map.set(key, new RegExp(`^(?:${source})$`));
-    } catch {
-    }
+  for (const [key, source] of Object.entries(DEFAULT_TOKENS)) {
+    const compiled = compileRegExp(source, "exact");
+    if (compiled) map.set(key, compiled);
+  }
+  for (const [key, source] of Object.entries(parseTokens(declaration))) {
+    const compiled = compileRegExp(source, "exact");
+    if (compiled) map.set(key, compiled);
   }
   return map;
 }
 function parseTokens(declaration) {
-  let parsed;
-  try {
-    parsed = JSON.parse(declaration);
-  } catch {
-    return {};
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const parsed = parseJsonObject(declaration);
+  if (parsed === null) return {};
   const tokens = {};
   for (const [key, source] of Object.entries(parsed)) {
     if (typeof source === "string") tokens[key] = source;
@@ -10236,11 +10305,7 @@ function isBeforeRootStart(entry) {
 }
 function queryRoot(selector) {
   if (!selector) return null;
-  try {
-    return document.querySelector(selector);
-  } catch {
-  }
-  return null;
+  return parseDeclared(selector, (raw) => document.querySelector(raw), null);
 }
 var IntersectionWatcher = class {
   #onEntries;
@@ -11071,8 +11136,9 @@ var LocalTimeController = class extends Controller {
   /**
    * Formats `date` with `Intl.DateTimeFormat`, including each style only when it
    * is a valid keyword (so a consumer can show date-only or time-only by clearing
-   * the other). Returns `null` when neither style is usable or `Intl` throws, so
-   * the caller can leave the authored text untouched.
+   * the other). Returns `null` when neither style is usable or the declaration
+   * names a locale or time zone `Intl` rejects, so the caller can leave the
+   * authored text untouched.
    */
   #applyFormat(date, dateStyle, timeStyle) {
     const options = {
@@ -11081,11 +11147,8 @@ var LocalTimeController = class extends Controller {
     };
     if (options.dateStyle === void 0 && options.timeStyle === void 0) return null;
     if (this.timeZoneValue.length > 0) options.timeZone = this.timeZoneValue;
-    try {
-      return new Intl.DateTimeFormat(this.#locale, options).format(date);
-    } catch {
-      return null;
-    }
+    const formatter = intlFormatter(Intl.DateTimeFormat, this.#locale, options);
+    return formatter === null ? null : formatter.format(date);
   }
   /** Locale precedence: the value, then the nearest `lang` up the ancestor chain. */
   get #locale() {
@@ -11153,7 +11216,7 @@ var MasonryController = class extends Controller {
    *
    * The removal is queued rather than immediate because teardown reports every
    * target as disconnected: doing it here would strip the whole grid just before
-   * a Turbo snapshot is taken. {@link MicrotaskCoalescer.cancel} drops the queue
+   * a Turbo snapshot is taken. The coalescer's `cancel` drops the queue
    * with the pass, so only a genuine target change reaches it.
    */
   itemTargetDisconnected(item) {
@@ -11434,8 +11497,7 @@ var MenuController = class extends Controller {
   };
   /** The item target that is, or contains, `node`; `null` when it is neither. */
   #itemFrom(node) {
-    if (!(node instanceof Node)) return null;
-    return this.itemTargets.find((item) => item === node || item.contains(node)) ?? null;
+    return ownerOf(this.itemTargets, node);
   }
   /**
    * First look at every click inside the controller, and the only point at which
@@ -11811,8 +11873,7 @@ var MenubarController = class extends Controller {
    * menu without moving focus.
    */
   #dismissOpenMenu() {
-    const active = document.activeElement;
-    const menu = this.menuTargets.find((candidate) => candidate.contains(active));
+    const menu = ownerOf(this.menuTargets, document.activeElement);
     if (menu) {
       const top = this.#topFor(menu);
       this.#closeMenu(top);
@@ -13226,7 +13287,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);
@@ -13296,7 +13357,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)),
@@ -14221,32 +14282,58 @@ var NumberInputController = class _NumberInputController extends Controller {
     this.#ariaValueMax.returnAll();
   }
 };
-var TOGGLED_MARKER = "data-optimistic-toggled";
+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 {
@@ -14254,32 +14341,64 @@ 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);
+  }
+  /**
+   * 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);
   }
-  /** Reverts exactly the mutations this controller made (marker-owned only). */
+  /**
+   * 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);
     }
   }
 };
 var DEFAULT_PATTERN = "[0-9]";
-function compilePattern(source) {
-  try {
-    return new RegExp(`^${source}$`);
-  } catch {
-    return null;
-  }
-}
+var DEFAULT_MATCHER = new RegExp(`^(?:${DEFAULT_PATTERN})$`);
 function hasModifier2(event) {
   return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 }
@@ -14294,7 +14413,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. */
@@ -14367,9 +14486,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) {
@@ -15253,7 +15372,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) {
@@ -16770,9 +16889,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;
@@ -16953,16 +17070,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();
@@ -17688,9 +17796,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) {
@@ -18597,6 +18704,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: "" },
@@ -18704,11 +18812,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() {
@@ -18757,16 +18861,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);
@@ -18868,8 +18963,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();
@@ -19121,9 +19215,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) {
@@ -19878,11 +19970,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() {
@@ -19954,17 +20046,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;
@@ -20098,7 +20179,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.
    */
@@ -21148,7 +21229,7 @@ var SmartStickyHeaderController = class extends Controller {
   #onFocusin = () => this.#apply(false);
   /** Validates `containerSelector` once so connect never parses a selector that throws. */
   containerSelectorValueChanged() {
-    this.#containerSelector = this.#validSelector(this.containerSelectorValue);
+    this.#containerSelector = validSelector(this.element, this.containerSelectorValue, "");
   }
   /** Re-decides when application code (or a Turbo morph) changes `offset` at runtime. */
   offsetValueChanged() {
@@ -21178,17 +21259,6 @@ var SmartStickyHeaderController = class extends Controller {
     }
     return window;
   }
-  /** 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 "";
-  }
   get #scrollY() {
     const scroller = this.#scrollerEl;
     return scroller === window ? window.scrollY : scroller.scrollTop;
@@ -23136,16 +23206,7 @@ var ThemeController = class extends Controller {
   }
   /** Validates the `target` declaration once, so the render path never parses. */
   targetValueChanged() {
-    const selector = this.targetValue;
-    if (selector.length > 0) {
-      try {
-        this.element.matches(selector);
-        this.#targetSelector = selector;
-        return;
-      } catch {
-      }
-    }
-    this.#targetSelector = DEFAULT_TARGET;
+    this.#targetSelector = validSelector(this.element, this.targetValue, DEFAULT_TARGET);
   }
   /** Re-derives the single Tab stop and ARIA for an option set that changed. */
   optionTargetConnected() {
@@ -23158,9 +23219,8 @@ var ThemeController = class extends Controller {
   /**
    * Selects the mode the activated option declares.
    *
-   * Read through {@link ThemeController.#optionMode}, the same lane that decides
-   * which option is checked, so the two can never disagree about what an option
-   * declares.
+   * Read through the same lane that decides which option is checked, so the two
+   * can never disagree about what an option declares.
    */
   set(event) {
     const option = event.currentTarget;
@@ -23635,7 +23695,7 @@ var ToastController = class extends Controller {
   static events = ["dismiss", "show"];
   /**
    * Registry for every auto-dismiss and transition-finalize timer the controller
-   * schedules. {@link SafeTimeout} owns *registration and teardown only*; the
+   * schedules. `SafeTimeout` owns *registration and teardown only*; the
    * pause/resume remaining-time accounting stays in `#activeTimeouts` so the
    * per-widget WCAG 2.2.1 semantics are not flattened into the helper.
    */
@@ -24217,9 +24277,8 @@ var ToggleGroupController = class extends Controller {
   }
   /** Finds this group's item containing an event target, excluding nested groups. */
   #itemForEventTarget(target) {
-    if (!this.#ownsEventTarget(target)) return void 0;
-    const node = target;
-    return this.itemTargets.find((item) => item === node || item.contains(node));
+    if (!this.#ownsEventTarget(target)) return null;
+    return ownerOf(this.itemTargets, target);
   }
   /** Whether the closest Toggle Group scope around a target is this instance. */
   #ownsEventTarget(target) {
@@ -24477,9 +24536,7 @@ var ToolbarController = class extends Controller {
   }
   /** Index in `controlTargets` of the control owning `target` (it or a descendant). */
   #indexOf(target) {
-    const node = target;
-    if (!node) return -1;
-    return this.controlTargets.findIndex((control) => control === node || control.contains(node));
+    return ownerIndex(this.controlTargets, target);
   }
   /** Controls eligible for the roving tab stop (excludes native disabled / hidden). */
   get #navigableControls() {