stimeo-ui 0.12.0 → 0.14.0

data/dist/controllers/calendar_controller.js

@@ -18,6 +18,35 @@ 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/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;
+    return new factory(fallbackLocale, options);
+  }
+}
+
 // src/utils/dates.ts
 function toISODateString(date) {
   const year = date.getFullYear();
@@ -51,6 +80,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/utils/safe_timeout.ts
 var TimerRegistry = class {
@@ -288,8 +321,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;

data/dist/controllers/carousel_controller.js

@@ -90,6 +90,12 @@ 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));
+}
+
 // src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
@@ -252,7 +258,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;
@@ -510,9 +516,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) {
@@ -731,9 +735,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);

data/dist/controllers/command_palette_controller.js

@@ -512,7 +512,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() {
@@ -617,7 +617,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.
    */

data/dist/controllers/conditional_fields_controller.js

@@ -2,6 +2,12 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/conditional_fields_controller.ts
 
+// 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]");
@@ -393,7 +399,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) {

data/dist/controllers/currency_input_controller.js

@@ -58,6 +58,36 @@ function halfWidthChar(char) {
   return char === "\u3000" ? " " : char;
 }
 
+// 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/controllers/currency_input_controller.ts
 var CurrencyInputController = class extends Controller {
   static targets = ["display", "field", "srValue"];
@@ -309,37 +339,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));

data/dist/controllers/date_range_picker_controller.js

@@ -47,6 +47,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, 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;
+    return new factory(fallbackLocale, options);
+  }
+}
+
 // src/utils/dates.ts
 function toISODateString(date) {
   const year = date.getFullYear();
@@ -80,6 +109,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/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
@@ -433,7 +466,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();
@@ -588,15 +621,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);

data/dist/controllers/direct_upload_controller.js

@@ -48,6 +48,26 @@ var BeforeCacheReset = class _BeforeCacheReset {
   }
 };
 
+// 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/safe_timeout.ts
 var TimerRegistry = class {
   /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
@@ -156,16 +176,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) {

data/dist/controllers/drawer_controller.js

@@ -586,7 +586,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() {
@@ -719,7 +719,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) {

data/dist/controllers/form_field_controller.js

@@ -100,6 +100,12 @@ 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));
+}
+
 // src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
@@ -357,7 +363,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() {

data/dist/controllers/input_mask_controller.js

@@ -49,6 +49,30 @@ 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
+  );
+}
+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/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
@@ -118,22 +142,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;

data/dist/controllers/intersection_controller.js

@@ -2,6 +2,15 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/intersection_controller.ts
 
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
 // src/utils/intersection_watcher.ts
 function isBeforeRootStart(entry) {
   const rect = entry.boundingClientRect;
@@ -11,11 +20,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;

data/dist/controllers/lazy_frame_controller.js

@@ -2,14 +2,19 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/lazy_frame_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;

data/dist/controllers/local_time_controller.js

@@ -2,6 +2,35 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/local_time_controller.ts
 
+// 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;
@@ -150,8 +179,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 = {
@@ -160,11 +190,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() {

data/dist/controllers/masonry_controller.js

@@ -153,7 +153,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) {

data/dist/controllers/menu_controller.js

@@ -98,6 +98,15 @@ 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));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
 // src/utils/safe_timeout.ts
 var TimerRegistry = class {
   /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
@@ -338,8 +347,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

data/dist/controllers/menubar_controller.js

@@ -103,6 +103,15 @@ 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));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
 // src/utils/roving_tabindex.ts
 var RovingTabindex = class {
   /** Returns the current ordered item elements; called on every operation. */
@@ -577,8 +586,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);