stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/textarea_autosize_controller.js

@@ -1,19 +1,14 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/textarea_autosize_controller.ts
-
-// src/utils/layout_observer.ts
 var LayoutObserver = class {
   #callback;
   #resizeObserverFactory;
   #resizeObserver = null;
   #observingViewport = false;
   #loadContainer = null;
-  /** Stable bound handler so add/removeEventListener target the same reference. */
   #handleViewportResize = () => {
     this.#callback();
   };
-  /** Stable bound handler for the capture-phase `load`; see {@link observeDescendantLoads}. */
   #handleDescendantLoad = () => {
     this.#callback();
   };
@@ -21,11 +16,6 @@ var LayoutObserver = class {
     this.#callback = callback;
     this.#resizeObserverFactory = options.resizeObserverFactory ?? (typeof ResizeObserver === "undefined" ? null : (cb) => new ResizeObserver(cb));
   }
-  /**
-   * Starts observing an element's size. Repeated calls observe additional
-   * elements through the same shared observer. No-ops when no
-   * `ResizeObserver` implementation is available.
-   */
   observe(element) {
     if (!this.#resizeObserverFactory) return;
     if (!this.#resizeObserver) {
@@ -35,47 +25,28 @@ var LayoutObserver = class {
     }
     this.#resizeObserver.observe(element);
   }
-  /** Stops observing a single element while leaving any others in place. */
   unobserve(element) {
     this.#resizeObserver?.unobserve(element);
   }
-  /** Starts observing viewport resizes. Idempotent: the listener is added once. */
   observeViewport() {
     if (this.#observingViewport) return;
     this.#observingViewport = true;
     window.addEventListener("resize", this.#handleViewportResize);
   }
-  /** Stops observing viewport resizes without affecting element observation. */
   unobserveViewport() {
     if (!this.#observingViewport) return;
     this.#observingViewport = false;
     window.removeEventListener("resize", this.#handleViewportResize);
   }
-  /**
-   * Starts reporting a `load` from anywhere inside `container` — an image or a
-   * frame settling changes the box it sits in, and it measures as zero high until
-   * then. `load` does not bubble, so the subscription is a capture-phase listener
-   * on the container itself and nothing the caller spells.
-   *
-   * **One container at a time.** A further call moves the observation, so a widget
-   * whose content element is swapped at runtime releases the element it let go by
-   * naming the new one — there is no second place for the release to drift from.
-   */
   observeDescendantLoads(container) {
     this.unobserveDescendantLoads();
     this.#loadContainer = container;
     container.addEventListener("load", this.#handleDescendantLoad, true);
   }
-  /** Stops reporting descendant loads without affecting element or viewport observation. */
   unobserveDescendantLoads() {
     this.#loadContainer?.removeEventListener("load", this.#handleDescendantLoad, true);
     this.#loadContainer = null;
   }
-  /**
-   * Releases every observation: disconnects the {@link ResizeObserver} and removes
-   * the viewport and descendant-load listeners. Safe to call multiple times. Call
-   * this from a controller's `disconnect()`.
-   */
   disconnect() {
     this.#resizeObserver?.disconnect();
     this.#resizeObserver = null;
@@ -84,16 +55,64 @@ var LayoutObserver = class {
   }
 };
 
-// src/controllers/textarea_autosize_controller.ts
+var NUMBER_BOUNDS = {
+  nonNegative: { finite: true, min: 0 }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+var NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 function px(value) {
   const n = Number.parseFloat(value);
   return Number.isNaN(n) ? 0 : n;
 }
-var TextareaAutosizeController = class extends Controller {
+var TextareaAutosizeController = class _TextareaAutosizeController extends Controller {
+  #numbers = new NumberValueReader();
   static values = {
     minRows: { type: Number, default: 1 },
     maxRows: { type: Number, default: 0 }
   };
+  static valueConstraints = {
+    minRows: { finite: true, min: 1 },
+    maxRows: NUMBER_BOUNDS.nonNegative
+  };
   static actions = ["resize"];
   static events = ["resize"];
   #lastHeight = -1;
@@ -101,12 +120,6 @@ var TextareaAutosizeController = class extends Controller {
   #started = false;
   #pending = false;
   #fonts = null;
-  /**
-   * Content triggers arriving while the box is collapsed (`display: none`
-   * ancestors) are deferred: `scrollHeight` is 0 there, so measuring would
-   * clamp the kept height to the `minRows` floor and dispatch a bogus
-   * `resize`. The next report from a rendered box flushes the deferral.
-   */
   #remeasure = () => {
     if (this.element.clientWidth === 0) {
       this.#pending = true;
@@ -114,16 +127,6 @@ var TextareaAutosizeController = class extends Controller {
     }
     this.resize();
   };
-  /**
-   * Re-measures when the content width changed (re-wrapping, including a
-   * horizontal padding change under `border-box`), the applied inline height
-   * was stripped (a Turbo morph syncing attributes from server HTML that has no
-   * `style`), or a content trigger was deferred while the box was collapsed.
-   * This instance's own height writes match none of these signals, so they
-   * cannot re-enter; an authored inline height (e.g. a user dragging the native
-   * resize handle) is left alone until the next content trigger. Reports from a
-   * still-collapsed box are skipped (nothing is measurable there).
-   */
   #layout = new LayoutObserver(() => {
     if (this.element.clientWidth === 0) return;
     const width = this.#contentWidth();
@@ -149,15 +152,12 @@ var TextareaAutosizeController = class extends Controller {
     this.#layout.disconnect();
     this.#unbindFonts();
   }
-  /** Re-clamps when application code or a Turbo morph changes `minRows`. */
   minRowsValueChanged() {
     if (this.#started) this.#remeasure();
   }
-  /** Re-clamps when application code or a Turbo morph changes `maxRows`. */
   maxRowsValueChanged() {
     if (this.#started) this.#remeasure();
   }
-  /** Re-measures the content and applies the clamped height. */
   resize() {
     this.#pending = false;
     const el = this.element;
@@ -169,10 +169,10 @@ var TextareaAutosizeController = class extends Controller {
     el.style.height = "auto";
     const contentHeight = Math.max(0, el.scrollHeight - paddingV);
     const rows = Math.max(1, Math.round(contentHeight / lineHeight));
-    let targetContent = Math.max(contentHeight, this.minRowsValue * lineHeight);
+    let targetContent = Math.max(contentHeight, this.#safeMinRows * lineHeight);
     let atMax = false;
-    if (this.maxRowsValue > 0) {
-      const maxContent = this.maxRowsValue * lineHeight;
+    if (this.#safeMaxRows > 0) {
+      const maxContent = this.#safeMaxRows * lineHeight;
       if (targetContent > maxContent) {
         targetContent = maxContent;
         atMax = true;
@@ -193,19 +193,16 @@ var TextareaAutosizeController = class extends Controller {
       this.dispatch("resize", { detail: { height, rows } });
     }
   }
-  /** Content-box width — the wrapping input, unaffected by this instance's height writes. */
   #contentWidth() {
     const style = window.getComputedStyle(this.element);
     return Math.max(0, this.element.clientWidth - px(style.paddingLeft) - px(style.paddingRight));
   }
-  /** Resolved line height, falling back to ~1.2× font-size when `normal`. */
   #lineHeight(style) {
     const lh = px(style.lineHeight);
     if (lh > 0) return lh;
     const fontSize = px(style.fontSize);
     return fontSize > 0 ? fontSize * 1.2 : 16;
   }
-  /** Subscribes to font completion when the current engine exposes `document.fonts`. */
   #bindFonts() {
     const fonts = this.element.ownerDocument.fonts;
     if (!fonts) return;
@@ -213,14 +210,30 @@ var TextareaAutosizeController = class extends Controller {
     fonts.addEventListener("loadingdone", this.#remeasure);
     fonts.addEventListener("loadingerror", this.#remeasure);
   }
-  /** Removes the font completion subscriptions. */
   #unbindFonts() {
     this.#fonts?.removeEventListener("loadingdone", this.#remeasure);
     this.#fonts?.removeEventListener("loadingerror", this.#remeasure);
     this.#fonts = null;
   }
+  get #safeMinRows() {
+    return this.#numbers.read(
+      this,
+      "minRows",
+      this.minRowsValue,
+      _TextareaAutosizeController.values.minRows.default,
+      _TextareaAutosizeController.valueConstraints.minRows
+    );
+  }
+  get #safeMaxRows() {
+    return this.#numbers.read(
+      this,
+      "maxRows",
+      this.maxRowsValue,
+      _TextareaAutosizeController.values.maxRows.default,
+      _TextareaAutosizeController.valueConstraints.maxRows
+    );
+  }
 };
 
 export { TextareaAutosizeController };
-//# sourceMappingURL=textarea_autosize_controller.js.map
 //# sourceMappingURL=textarea_autosize_controller.js.map

data/dist/controllers/theme_controller.js

@@ -1,13 +1,31 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/theme_controller.ts
+var FOCUS_EVENTS = /* @__PURE__ */ new Set(["blur", "focus", "focusin", "focusout"]);
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["mouseenter", "mouseleave", "pointerenter", "pointerleave"]);
+function stateReasonFor(event) {
+  if (!event) return "api";
+  if (FOCUS_EVENTS.has(event.type)) return "focus";
+  if (POINTER_EVENTS.has(event.type)) return "pointer";
+  return "user";
+}
+
+function actionSource(source) {
+  if (source instanceof HTMLElement) {
+    return { event: null, host: source, origin: source, reason: "api" };
+  }
+  const event = source ?? null;
+  return {
+    event,
+    host: event?.currentTarget instanceof Element ? event.currentTarget : null,
+    origin: event?.target instanceof Element ? event.target : null,
+    reason: stateReasonFor(event)
+  };
+}
 
-// src/utils/logical_scroll.ts
 function isRtl(element) {
   return window.getComputedStyle(element).direction === "rtl";
 }
 
-// src/utils/arrow_step.ts
 function logicalArrowStep(key, element) {
   if (key === "ArrowDown") return 1;
   if (key === "ArrowUp") return -1;
@@ -23,7 +41,6 @@ function hasModifierChord(event) {
   return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 }
 
-// src/utils/declared_value.ts
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -43,31 +60,78 @@ function validSelector(element, raw, fallback) {
   );
 }
 
-// src/utils/roving_tabindex.ts
+var ListenerSet = class {
+  #abort = new AbortController();
+  add(target, type, handler, options) {
+    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
+  }
+  dispose() {
+    this.#abort.abort();
+    this.#abort = new AbortController();
+  }
+};
+
+var MicrotaskCoalescer = class {
+  #run;
+  #queued = false;
+  #active = false;
+  #generation = 0;
+  constructor(run) {
+    this.#run = run;
+  }
+  activate() {
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
+  }
+  schedule() {
+    if (!this.#active || this.#queued) return;
+    this.#queued = true;
+    const generation = this.#generation;
+    queueMicrotask(() => {
+      if (generation !== this.#generation || !this.#queued || !this.#active) return;
+      this.#queued = false;
+      this.#run();
+    });
+  }
+};
+
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(run);
+  }
+  observe(element) {
+    if (this.#element === element) return;
+    this.disconnect();
+    this.#element = element;
+    this.#pass.activate();
+    this.#listeners.add(element, "turbo:morph-element", this.#onMorph);
+  }
+  schedule() {
+    this.#pass.schedule();
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
 var RovingTabindex = class {
-  /** Returns the current ordered item elements; called on every operation. */
   #getItems;
-  /**
-   * @param getItems - Returns the current ordered item elements. Called on every
-   *   operation so the live target list is always used.
-   */
   constructor(getItems) {
     this.#getItems = getItems;
   }
-  /** Index of the currently tabbable item (`tabindex="0"`), or `-1` if none. */
   get activeIndex() {
     return this.#getItems().findIndex((item) => item.tabIndex === 0);
   }
-  /**
-   * Makes exactly the item at `index` tabbable (`tabindex="0"`) and removes every
-   * other item from the Tab sequence (`tabindex="-1"`). An out-of-range `index`
-   * (e.g. `-1`) leaves all items at `-1`, which a controller can use to express
-   * "nothing is currently tabbable".
-   *
-   * @param index - Position of the item to make tabbable.
-   * @param options - Pass `{ focus: true }` to also move DOM focus to that item,
-   *   and `items` to reuse an event-scoped collection snapshot.
-   */
   setActive(index, options = {}) {
     const { focus = false } = options;
     const items = options.items ?? this.#getItems();
@@ -83,7 +147,6 @@ function rovingMove(current, length, delta, wrap) {
   return (next + length) % length;
 }
 
-// src/utils/safe_storage.ts
 function readLocalStorage(key) {
   try {
     return { ok: true, value: window.localStorage.getItem(key) };
@@ -100,7 +163,10 @@ function writeLocalStorage(key, value) {
   }
 }
 
-// src/controllers/theme_controller.ts
+function targetSelector(identifier, name) {
+  return `[data-${identifier}-target~="${name}"]`;
+}
+
 var MODES = ["light", "dark", "system"];
 var isMode = (value) => typeof value === "string" && MODES.includes(value);
 var DEFAULT_MODE = "system";
@@ -114,30 +180,19 @@ var ThemeController = class extends Controller {
   };
   static actions = ["set", "toggle"];
   static events = ["change", "reconcile"];
-  /** The OS dark-mode query, watched so `system` tracks live changes. */
   #media = null;
-  /** Gate for the target and `mode` callbacks, which Stimulus runs before `connect()`. */
   #connected = false;
-  /** The `target` declaration after validation; the default when unparsable. */
   #targetSelector = DEFAULT_TARGET;
-  /** Owns the single Tab stop across the option set (APG radiogroup). */
+  #storageKeyRead = null;
   #roving = new RovingTabindex(() => this.optionTargets);
-  /**
-   * The pair on screen as last reported or re-seeded, so a move can be told from a
-   * repeat. Neither side is readable after the fact — assigning the Value updates the
-   * mode before any comparison, and the OS query has already flipped by the time it
-   * notifies — so what was reported has to be kept rather than recomputed.
-   */
   #published = {
     mode: DEFAULT_MODE,
     resolved: "light"
   };
-  /** Re-resolves while in `system` mode when the OS preference flips. */
   #onMediaChange = () => {
     if (this.#mode !== "system") return;
-    this.#commit();
+    this.#commit("media");
   };
-  /** Arrow/Home/End navigation for the radiogroup (APG radio pattern). */
   #onKeydown = (event) => {
     if (event.defaultPrevented) return;
     if (isReservedArrowChord(event)) return;
@@ -169,7 +224,13 @@ var ThemeController = class extends Controller {
     const mode = this.#optionMode(option);
     if (mode) this.#setMode(mode);
   };
+  #morph = new MorphRenderWatcher(() => {
+    this.#applyTheme();
+    this.#reconcileControls();
+  });
   connect() {
+    this.#morph.observe(this.element);
+    this.#storageKeyRead = this.storageKeyValue;
     const stored = this.#readStored();
     if (stored) this.modeValue = stored;
     this.#media = window.matchMedia?.("(prefers-color-scheme: dark)") ?? null;
@@ -181,25 +242,15 @@ var ThemeController = class extends Controller {
     this.#published = this.#current;
   }
   disconnect() {
+    this.#morph.disconnect();
     this.#connected = false;
     this.#media?.removeEventListener("change", this.#onMediaChange);
     this.element.removeEventListener("keydown", this.#onKeydown);
   }
-  /** Validates the `target` declaration once, so the render path never parses. */
   targetValueChanged() {
     this.#targetSelector = validSelector(this.element, this.targetValue, DEFAULT_TARGET);
+    this.#morph.schedule();
   }
-  /**
-   * Re-renders for a `mode` declaration changed after connect — a Turbo morph
-   * re-rendering the server's markup over the live element, or a script.
-   *
-   * A stored choice outranks the declaration: a Value that disagrees with it is written
-   * back to it, so a morph that brings the server's default never overrides what the
-   * user saved. Without one, the declaration is applied. Either way storage is left
-   * alone, and a pair on screen that moved is reported as `reconcile`, not `change` —
-   * the page moved the declaration, not a selection. The reported pair is re-seeded
-   * first, so the next selection is compared with what is on screen.
-   */
   modeValueChanged() {
     if (!this.#connected) return;
     if (this.modeValue === this.#published.mode) return;
@@ -208,67 +259,53 @@ var ThemeController = class extends Controller {
     this.#applyTheme();
     this.#reconcileControls();
   }
-  /** Re-derives the single Tab stop and ARIA for an option set that changed. */
+  storageKeyValueChanged() {
+    if (!this.#connected) return;
+    const key = this.storageKeyValue;
+    if (key === this.#storageKeyRead) return;
+    this.#storageKeyRead = key;
+    const stored = this.#readStored();
+    if (stored === null || stored === this.modeValue) return;
+    this.modeValue = stored;
+    this.#applyTheme();
+    this.#reconcileControls();
+  }
   optionTargetConnected() {
-    if (this.#connected) this.#reconcileControls();
+    if (this.#connected) this.#morph.schedule();
   }
-  /** Re-derives them again when an option leaves, so a Tab stop always remains. */
   optionTargetDisconnected() {
-    if (this.#connected) this.#reconcileControls();
-  }
-  /**
-   * Selects the mode the activated 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;
-    if (!(option instanceof HTMLElement)) return;
+    if (this.#connected) this.#morph.schedule();
+  }
+  set(source) {
+    const { host, origin, reason } = actionSource(source);
+    const option = host?.closest(targetSelector(this.identifier, "option"));
+    if (!option || !this.optionTargets.includes(option)) return;
+    if (origin && origin.closest(`[data-controller~="${this.identifier}"]`) !== this.element)
+      return;
     const mode = this.#optionMode(option);
-    if (mode) this.#setMode(mode);
+    if (mode) this.#setMode(mode, reason);
   }
-  /** Toggles light↔dark for the 2-value single-button contract. */
-  toggle() {
-    this.#setMode(this.#resolved() === "dark" ? "light" : "dark");
+  toggle(event) {
+    const mode = this.#readStored() ?? this.#mode;
+    const dark = mode === "dark" || mode === "system" && this.#media?.matches === true;
+    this.#setMode(dark ? "light" : "dark", stateReasonFor(event));
   }
-  /** Central mode change: persist, apply to the root, resync controls, announce. */
-  #setMode(mode) {
+  #setMode(mode, reason = "user") {
     this.modeValue = mode;
     this.#writeStored(mode);
-    this.#commit();
-  }
-  /**
-   * Applies the current mode and reports it, but reports only a real move: the
-   * event means "the selection or the effective theme moved", so re-choosing the
-   * option already chosen is not one.
-   */
-  #commit() {
+    this.#commit(reason);
+  }
+  #commit(reason) {
     this.#applyTheme();
     this.#syncControls();
     const moved = this.#settle();
-    if (moved) this.dispatch("change", { detail: moved });
-  }
-  /**
-   * Re-derives the controls from the mode on screen for a change the page made — a
-   * `mode` declaration or an option set — and reports a pair that moved since the
-   * last report as `reconcile`. An option coming or going moves neither half of the
-   * pair, so of these changes only a declaration reports.
-   */
+    if (moved) this.dispatch("change", { detail: { ...moved, reason } });
+  }
   #reconcileControls() {
     this.#syncControls();
     const moved = this.#settle();
     if (moved) this.dispatch("reconcile", { detail: moved });
   }
-  /**
-   * Takes the pair on screen as the reported one and returns it when it differs
-   * from the one reported before, or `null` when neither half moved.
-   *
-   * The baseline moves before anything is dispatched, so a listener that selects
-   * another mode is measured from the pair it was just told about. What is
-   * returned is a copy: the baseline has to survive a listener that writes to what
-   * it was handed, or the next unchanged operation reads as a move.
-   */
   #settle() {
     const next = this.#current;
     const last = this.#published;
@@ -276,15 +313,9 @@ var ThemeController = class extends Controller {
     if (last.mode === next.mode && last.resolved === next.resolved) return null;
     return { ...next };
   }
-  /** The pair the `change` and `reconcile` details carry, read from current state. */
   get #current() {
     return { mode: this.#mode, resolved: this.#resolved() };
   }
-  /**
-   * Writes `data-theme` + `color-scheme` (the resolved theme) onto the target.
-   *
-   * @stimeoRenderRoot
-   */
   #applyTheme() {
     const root = this.#targetElement();
     if (!root) return;
@@ -292,11 +323,6 @@ var ThemeController = class extends Controller {
     root.setAttribute("data-theme", resolved);
     root.style.setProperty("color-scheme", resolved);
   }
-  /**
-   * Keeps the radiogroup (aria-checked + roving tabindex) or toggle (aria-pressed) in sync.
-   *
-   * @stimeoRenderRoot
-   */
   #syncControls() {
     const options = this.optionTargets;
     if (options.length > 0) {
@@ -314,43 +340,35 @@ var ThemeController = class extends Controller {
       this.element.setAttribute("aria-pressed", String(this.#resolved() === "dark"));
     }
   }
-  /** Whether the controller element is the button of the 2-value contract. */
   get #isToggleButton() {
     return this.element.tagName === "BUTTON" || this.element.getAttribute("role") === "button";
   }
-  /** The selected mode after validation; an unreadable declaration is the default. */
   get #mode() {
     return isMode(this.modeValue) ? this.modeValue : DEFAULT_MODE;
   }
-  /** The effective theme: the OS preference when `system`, else the mode itself. */
   #resolved() {
     const mode = this.#mode;
     if (mode === "dark") return "dark";
     if (mode === "light") return "light";
     return this.#media?.matches ? "dark" : "light";
   }
-  /** An option's mode from its `data-value`, or `null` when that is not one of the three. */
   #optionMode(option) {
     const mode = option.getAttribute("data-value");
     return isMode(mode) ? mode : null;
   }
-  /** Resolves the state-hook target (`<html>` by default). */
   #targetElement() {
     const selector = this.#targetSelector;
     if (selector === DEFAULT_TARGET || selector === ":root") return document.documentElement;
     return document.querySelector(selector);
   }
-  /** Reads a persisted, validated mode from `localStorage` (null when absent/blocked). */
   #readStored() {
     const result = readLocalStorage(this.storageKeyValue);
     return result.ok && isMode(result.value) ? result.value : null;
   }
-  /** Persists the mode, swallowing storage errors (private mode / quota). */
   #writeStored(mode) {
     writeLocalStorage(this.storageKeyValue, mode);
   }
 };
 
 export { ThemeController };
-//# sourceMappingURL=theme_controller.js.map
 //# sourceMappingURL=theme_controller.js.map