@wcstack/wakelock 1.12.1

package/dist/index.esm.js

@@ -0,0 +1,524 @@
+const _config = {
+    tagNames: {
+        wakelock: "wcs-wakelock",
+    },
+};
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    Object.freeze(obj);
+    for (const key of Object.keys(obj)) {
+        deepFreeze(obj[key]);
+    }
+    return obj;
+}
+function deepClone(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    const clone = {};
+    for (const key of Object.keys(obj)) {
+        clone[key] = deepClone(obj[key]);
+    }
+    return clone;
+}
+let frozenConfig = null;
+// Note: this is the live, mutable internal config. It is not part of the public
+// package exports (see exports.ts) — only `getConfig()` (frozen snapshot) and
+// `setConfig()` are surfaced — but a deep path import (`.../src/config.js`) can still
+// reach and mutate it. Accepted as-is for cross-package consistency: every @wcstack
+// package follows this same shape. Use `getConfig()` for a frozen, safe read.
+const config = _config;
+function getConfig() {
+    if (!frozenConfig) {
+        frozenConfig = deepFreeze(deepClone(_config));
+    }
+    return frozenConfig;
+}
+function setConfig(partialConfig) {
+    if (partialConfig.tagNames) {
+        Object.assign(_config.tagNames, partialConfig.tagNames);
+    }
+    frozenConfig = null;
+}
+
+/**
+ * Headless screen-wake-lock primitive — a thin, framework-agnostic wrapper around
+ * the Screen Wake Lock API exposed through the wc-bindable protocol.
+ *
+ * Unlike the other @wcstack sensors (geolocation / intersection), the wake lock is
+ * a pure *sink*: nothing is read from the device. A bound state drives the desired
+ * intent (`request()` / `release()`), and the only observable outputs are `held`
+ * (whether a sentinel is actually held) and `error`.
+ *
+ * The OS releases the lock whenever the page stops being visible (tab hidden,
+ * window minimized). To honor the declarative intent ("keep awake *while* active"),
+ * the Core keeps the desired flag (`_active`) and re-acquires the lock on the next
+ * `visibilitychange` back to visible. So `_active` (desired) and `held` (actual)
+ * diverge across an auto-release — and only `held` is published, because desired
+ * does not change when the OS drops the lock.
+ *
+ * Never-throw: `request()` never rejects (a failure surfaces via `error`), and an
+ * unsupported environment is a silent no-op (`held` stays false), consistent with
+ * the other @wcstack sensors.
+ */
+class WakeLockCore extends EventTarget {
+    static wcBindable = {
+        protocol: "wc-bindable",
+        version: 1,
+        properties: [
+            { name: "held", event: "wcs-wakelock:held-changed" },
+            { name: "error", event: "wcs-wakelock:error" },
+        ],
+        commands: [
+            { name: "request", async: true },
+            { name: "release" },
+        ],
+    };
+    _target;
+    _type;
+    // `_active` is the desired intent (input); `_held` is whether a sentinel is
+    // actually held right now (output). They diverge across an OS auto-release.
+    _active = false;
+    _held = false;
+    _error = null;
+    _sentinel = null;
+    // Bumped on every release()/new acquire so an in-flight async request() that
+    // resolves late can detect it was superseded and drop its sentinel (mirrors the
+    // generation guards in GeolocationCore).
+    _gen = 0;
+    // True while an `_acquire()` is awaiting `navigator.wakeLock.request()`. The
+    // `_held` flag is only set *after* that await resolves, so it cannot guard
+    // against concurrent entry: two rapid visibilitychange events (or a Shell toggle
+    // overlapping an in-flight request) would both pass `!this._held` and each call
+    // `request()`. This in-flight flag closes that window — a re-entrant acquire is a
+    // no-op. The `_gen` guard still ensures the *final* state is correct; this just
+    // avoids the redundant `request()` call (and its duplicate error path on a denied
+    // environment).
+    _acquiring = false;
+    _visibilityBound = false;
+    constructor(target, type = "screen") {
+        super();
+        this._target = target ?? this;
+        this._type = type;
+    }
+    get held() {
+        return this._held;
+    }
+    get error() {
+        return this._error;
+    }
+    /** The desired intent. Read-only reflection; not a wc-bindable property (it does
+     * not change on an OS auto-release, so there is nothing to observe). */
+    get active() {
+        return this._active;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        // Currently effectively a no-op: "screen" is the only standardized lock type,
+        // so `WakeLockKind` is a single value and this setter never observes a real
+        // change. Kept as a forward-compatible seam for when the spec adds lock types.
+        //
+        // Takes effect on the next acquire. Changing the type mid-hold deliberately does
+        // NOT re-acquire — the live sentinel is left as is, so a type change applies only
+        // from the following acquire. If multiple lock types are ever added this becomes
+        // an observable behavior gap (a held lock keeps its old type until release/re-
+        // acquire) and must be re-examined — likely re-acquire here when held.
+        this._type = value;
+    }
+    // --- State setters with event dispatch ---
+    _setHeld(held) {
+        if (this._held === held)
+            return;
+        this._held = held;
+        this._target.dispatchEvent(new CustomEvent("wcs-wakelock:held-changed", {
+            detail: held,
+            bubbles: true,
+        }));
+    }
+    _setError(error) {
+        // Value guard, not just reference: a denied request rejects with a *fresh*
+        // Error on every visibility-driven retry, so a reference compare would let a
+        // permanently-denied environment re-dispatch the same failure on each
+        // hidden→visible toggle. Compare name+message too. Transitions through null (a
+        // success clears the error) always re-fire, so a genuinely new failure is seen.
+        if (this._sameError(this._error, error))
+            return;
+        this._error = error;
+        this._target.dispatchEvent(new CustomEvent("wcs-wakelock:error", {
+            detail: error,
+            bubbles: true,
+        }));
+    }
+    _sameError(a, b) {
+        if (a === b)
+            return true;
+        if (a !== null && b !== null)
+            return a.name === b.name && a.message === b.message;
+        return false;
+    }
+    // --- Public API ---
+    /**
+     * Mark the lock as desired and acquire it. Idempotent while already held. If the
+     * API is unavailable or the page is currently hidden, the desired flag is still
+     * set (so the lock is acquired on the next return to visibility) but nothing is
+     * acquired now. Never rejects — a request failure surfaces via `error`.
+     */
+    async request() {
+        this._active = true;
+        this._ensureVisibilityListener();
+        await this._acquire();
+    }
+    /** Mark the lock as no longer desired and release any held sentinel. */
+    release() {
+        this._active = false;
+        // Invalidate any in-flight acquire so a late-resolving request() drops its
+        // sentinel instead of leaving a lock held after release.
+        this._gen++;
+        const sentinel = this._sentinel;
+        if (sentinel) {
+            this._sentinel = null;
+            sentinel.removeEventListener("release", this._onRelease);
+            void sentinel.release().catch(() => { });
+        }
+        this._setHeld(false);
+    }
+    /**
+     * Full teardown: remove the visibility listener and release any held sentinel.
+     * Call from the Shell's `disconnectedCallback`.
+     *
+     * Semantics: this is a terminal teardown, not a pause. After `dispose()` the Core
+     * is meant to be discarded — there is no re-arm step, and the visibility listener
+     * is gone, so an OS auto-release will no longer be followed by a re-acquire. A
+     * later `request()` would still work in isolation (it re-attaches the listener via
+     * `_ensureVisibilityListener`), but reusing a disposed Core is not an intended path;
+     * the Shell always constructs a fresh Core per element instead.
+     */
+    dispose() {
+        if (this._visibilityBound) {
+            document.removeEventListener("visibilitychange", this._onVisibilityChange);
+            this._visibilityBound = false;
+        }
+        this.release();
+    }
+    // --- Internal ---
+    async _acquire() {
+        if (this._held)
+            return; // idempotent: already holding a sentinel
+        if (this._acquiring)
+            return; // an acquire is already in flight — don't double-request
+        const wakeLock = this._wakeLock();
+        if (!wakeLock)
+            return; // unsupported — stay active, never acquire (silent no-op)
+        if (!this._isVisible())
+            return; // hidden — defer to the next visibilitychange
+        const gen = ++this._gen;
+        this._acquiring = true;
+        // Flag management is centralized in `finally` and the coalesced retry is invoked
+        // exactly once, AFTER the try/catch/finally settles. This keeps the reject and
+        // resolve paths symmetric: neither calls `_retryIfStillDesired()` from inside the
+        // try/catch (which would let `finally` re-clear the `_acquiring=true` the retry's
+        // synchronous re-entry just set, reopening the double-request window). `superseded`
+        // records that a newer release()/request() bumped `_gen` mid-flight so its still-
+        // live intent — blocked by the in-flight guard at the time — gets one retry here.
+        // NOTE: no early `return` inside the try/catch below — every branch must fall
+        // through to the post-`finally` retry. A `return` from inside the try would run
+        // `finally` and then exit the function, skipping the `if (superseded)` retry.
+        let superseded = false;
+        let sentinel = null;
+        let failed = null;
+        try {
+            sentinel = await wakeLock.request(this._type);
+        }
+        catch (e) {
+            if (gen !== this._gen) {
+                // Superseded while awaiting — drop this stale failure (do not clobber the
+                // newer state) and let the post-finally retry honor the live intent.
+                superseded = true;
+            }
+            else {
+                failed = this._normalizeError(e);
+            }
+        }
+        finally {
+            // The sole owner of the flag clears it here — on every exit path. A concurrent
+            // re-entrant `_acquire()` was a no-op at the `_acquiring` guard, so it never owns
+            // the flag; a superseding release()/acquire only bumps `_gen` and does not start
+            // its own in-flight cycle until this clears the flag. Because this runs before
+            // the retry below, the retry's `_acquiring=true` is never clobbered.
+            this._acquiring = false;
+        }
+        if (sentinel !== null && gen !== this._gen) {
+            // release() (or a newer acquire) ran while we awaited — this sentinel is
+            // unwanted; drop it so no lock lingers, and retry the newer intent below.
+            void sentinel.release().catch(() => { });
+            superseded = true;
+        }
+        else if (sentinel !== null) {
+            this._sentinel = sentinel;
+            sentinel.addEventListener("release", this._onRelease);
+            this._setError(null);
+            this._setHeld(true);
+        }
+        else if (failed !== null) {
+            // A live (non-superseded) failure: surface it. Never retried — the intent is
+            // honored but the environment denied it, so looping would spin.
+            this._setError(failed);
+            this._setHeld(false);
+        }
+        // Coalesced retry: at most one re-attempt per supersession, after the flag is
+        // clear. The `_acquiring` guard inside still protects any concurrent re-entry that
+        // overlaps THIS retry's own in-flight window (reject- and resolve-retry alike).
+        if (superseded)
+            this._retryIfStillDesired();
+    }
+    /**
+     * Re-attempt an acquire after an in-flight one was *superseded* (its generation no
+     * longer matches), but only if the lock is still desired, not already held, and the
+     * page is visible. This recovers a request() that was coalesced away by the
+     * in-flight `_acquiring` guard: during a release()→request() overlap, the second
+     * request() bumps `_gen` and is a no-op at the guard, so without this retry its
+     * still-live intent would be lost until the next visibilitychange or manual call.
+     *
+     * Bounded — cannot loop forever: a retry runs ONLY on supersession, and a
+     * supersession requires an external release()/request() to bump `_gen` mid-flight.
+     * A retry's own `_acquire()`, if it is itself not superseded, terminates by either
+     * acquiring (held=true) or recording the live failure (held=false, error set) —
+     * neither path retries. So a denied environment that keeps rejecting does not
+     * recurse; the retry chain length is bounded by the number of external overlaps.
+     */
+    _retryIfStillDesired() {
+        if (this._active && !this._held && this._isVisible()) {
+            void this._acquire();
+        }
+    }
+    // Fired for an OS release of a held sentinel — which the spec allows for several
+    // reasons, NOT only a visibility change: tab hidden / window minimized, but also
+    // battery-low, power-saver mode, etc. while the page stays visible. We reflect
+    // held=false, then (lease renewal) re-acquire immediately IF the page is still
+    // visible and the lock is still desired — because a visible-context release emits no
+    // `visibilitychange`, so the visibilitychange listener (②) would never fire and the
+    // lock would stay stuck at desired=true / held=false. The hidden case is the no-op
+    // here: re-acquire is gated on `_isVisible()`, so a hide-driven release defers to ②
+    // (re-acquire on the return to visibility), avoiding a release→acquire loop while
+    // hidden.
+    _onRelease = () => {
+        // The `if (this._sentinel)` false branch is defensive and unreachable in practice:
+        // this listener is only ever attached to the live `_sentinel`, and the only paths
+        // that null `_sentinel` (this handler itself, and release()) remove this listener
+        // in the same step — so the listener and a non-null `_sentinel` are coupled and
+        // this never fires with `_sentinel === null`. Guarded anyway in case a host
+        // dispatches a spurious second "release". (c8 ignore the unhittable else.)
+        /* c8 ignore next */
+        if (this._sentinel) {
+            this._sentinel.removeEventListener("release", this._onRelease);
+            this._sentinel = null;
+        }
+        this._setHeld(false);
+        this._reacquireAfterRelease();
+    };
+    /**
+     * Lease renewal after an OS release while the page is still visible. Honors the
+     * "keep awake *while* active" promise for releases that do NOT coincide with a
+     * visibility change (battery-low / power-saver), which otherwise leave the lock
+     * stuck at desired=true / held=false until the next hide→show cycle.
+     *
+     * Bounded on failure: this only runs from `_onRelease`, which only fires when a
+     * sentinel was genuinely acquired and then released. A re-acquire that FAILS takes
+     * `_acquire()`'s live-failure path (error recorded, held=false) and attaches no
+     * listener, so it cannot re-enter `_onRelease` — a denied environment records the
+     * error once and stops. This is the dominant real path: per the Wake Lock spec a
+     * re-request under battery-low / power-saver is rejected (`NotAllowedError`), so the
+     * renewal terminates there.
+     *
+     * The one path NOT bounded by a counter is a pathological host that keeps GRANTING
+     * the re-request and then immediately auto-releasing it (grant→release reflux). Each
+     * iteration yields to the event loop and consumes a real OS grant, so it is not a
+     * tight/synchronous loop, but it would churn request() calls. We deliberately do NOT
+     * add a debounce or renewal cap: that reflux is not documented browser behavior
+     * (real browsers reject, not grant-then-revoke), and the extra timing state would
+     * complicate the pure-sink design to defend a case that does not occur in practice.
+     *
+     * The `_isVisible()` / `!_acquiring` guards (doubled by `_acquire()`'s own in-flight
+     * and held guards) prevent re-entry during an in-flight acquire and while hidden.
+     */
+    _reacquireAfterRelease() {
+        if (this._active && this._isVisible() && !this._acquiring) {
+            void this._acquire();
+        }
+    }
+    // ② Re-acquire when the page becomes visible again while the lock is still
+    // desired but was auto-released. This is what makes `active` a durable intent.
+    _onVisibilityChange = () => {
+        if (this._isVisible() && this._active && !this._held) {
+            void this._acquire();
+        }
+    };
+    _ensureVisibilityListener() {
+        if (this._visibilityBound)
+            return;
+        document.addEventListener("visibilitychange", this._onVisibilityChange);
+        this._visibilityBound = true;
+    }
+    _wakeLock() {
+        return navigator.wakeLock ?? null;
+    }
+    _isVisible() {
+        return document.visibilityState === "visible";
+    }
+    _normalizeError(e) {
+        return e instanceof Error ? e : new Error(String(e));
+    }
+}
+
+/**
+ * `<wcs-wakelock>` — declarative Screen Wake Lock.
+ *
+ * The first @wcstack tag that is a pure *sink*: every other sensor is an
+ * element→state producer, but the wake lock is state→element. The headline
+ * binding is `active@isPlaying` — hold the screen awake while a bound boolean is
+ * true. `active` is the single input knob (a mirrored attribute); `held` and
+ * `error` are the observable outputs.
+ *
+ * The OS auto-releases the lock when the page is hidden; the Core re-acquires it
+ * on the next return to visibility while `active` is still set, so the binding
+ * means "keep awake *while* active", not just "acquire once".
+ */
+class WcsWakeLock extends HTMLElement {
+    // SSR contract (@wcstack/server): the renderer awaits elements declaring
+    // `hasConnectedCallbackPromise = true` before snapshotting. The wake lock has no
+    // connect-time async fix to await (acquire is fire-and-forget and meaningless
+    // server-side), so this is `false` — same as the other synchronous sensor Shells
+    // (sse / intersection / worker). Kept (not deleted) because it is the protocol
+    // contract surface the server renderer reads via `ctor.hasConnectedCallbackPromise`.
+    static hasConnectedCallbackPromise = false;
+    // `active` drives request/release; `type` propagates to the Core's next acquire.
+    // `manual` is intentionally excluded: it is a connect-time policy ("don't auto-
+    // acquire on connect"), not a live switch.
+    static observedAttributes = ["active", "type"];
+    static wcBindable = {
+        ...WakeLockCore.wcBindable,
+        // Settable surface. `active` is the declarative intent; `type` selects the lock
+        // kind; `manual` opts out of auto-acquire on connect. The request / release
+        // commands are inherited from the Core via the spread above.
+        inputs: [
+            { name: "active", attribute: "active" },
+            { name: "type", attribute: "type" },
+            { name: "manual", attribute: "manual" },
+        ],
+        // Core の commands をそのまま継承（単一情報源）。<wcs-intersect>/<wcs-sse> と同型。
+        // spread でも継承されるが、Core に command 追加時の追従漏れを防ぐため明示参照する。
+        commands: WakeLockCore.wcBindable.commands,
+    };
+    _core;
+    constructor() {
+        super();
+        this._core = new WakeLockCore(this);
+    }
+    // --- Attribute accessors ---
+    get active() {
+        // Reflects the *attribute*, not the Core's desired intent (`_core.active`). These
+        // can diverge: invoking the `request` / `release` commands directly (e.g. via a
+        // command-token binding) flips the Core's desired flag without touching the
+        // attribute, so `el.active` may read false while `el.held` is true (or vice
+        // versa). The attribute is the declarative input surface; the commands are an
+        // imperative side door. Bind via `active@...` for a single source of truth.
+        return this.hasAttribute("active");
+    }
+    set active(value) {
+        if (value) {
+            this.setAttribute("active", "");
+        }
+        else {
+            this.removeAttribute("active");
+        }
+    }
+    get type() {
+        // Only "screen" is standardized; an absent/empty attribute defaults to it.
+        return this.getAttribute("type") || "screen";
+    }
+    set type(value) {
+        this.setAttribute("type", value);
+    }
+    get manual() {
+        return this.hasAttribute("manual");
+    }
+    set manual(value) {
+        if (value) {
+            this.setAttribute("manual", "");
+        }
+        else {
+            this.removeAttribute("manual");
+        }
+    }
+    // --- Core delegated getters ---
+    get held() {
+        return this._core.held;
+    }
+    get error() {
+        return this._core.error;
+    }
+    // --- Commands ---
+    /** Acquire (and keep) the wake lock. Never rejects — see the `error` property. */
+    request() {
+        return this._core.request();
+    }
+    /** Release the wake lock and stop re-acquiring it. */
+    release() {
+        this._core.release();
+    }
+    // --- Lifecycle ---
+    connectedCallback() {
+        // Headless resource: no layout box (mirrors the @wcstack sensor convention).
+        this.style.display = "none";
+        // Propagate the requested lock type to the Core. Currently a no-op in effect:
+        // "screen" is the only standardized type, so `type` is always "screen". Wired
+        // up as a forward-compatible seam (observedAttributes + setter + this line) for
+        // when the spec adds lock types; until then it carries a constant.
+        this._core.type = this.type;
+        if (!this.manual && this.active) {
+            void this._core.request();
+        }
+    }
+    disconnectedCallback() {
+        this._core.dispose();
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (oldValue === newValue)
+            return;
+        // Ignore changes applied before connect (e.g. createElement + setAttribute);
+        // connectedCallback applies the initial state. Acquiring a lock for a detached
+        // element would be wrong.
+        if (!this.isConnected)
+            return;
+        if (name === "type") {
+            this._core.type = this.type;
+            return;
+        }
+        // name === "active": a live toggle always drives request/release. `manual` only
+        // gates the connect-time auto-acquire, not an explicit author toggle.
+        if (this.active) {
+            void this._core.request();
+        }
+        else {
+            this._core.release();
+        }
+    }
+}
+
+function registerComponents() {
+    if (!customElements.get(config.tagNames.wakelock)) {
+        customElements.define(config.tagNames.wakelock, WcsWakeLock);
+    }
+}
+
+function bootstrapWakeLock(userConfig) {
+    if (userConfig) {
+        setConfig(userConfig);
+    }
+    registerComponents();
+}
+
+export { WakeLockCore, WcsWakeLock, bootstrapWakeLock, getConfig };
+//# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../src/config.ts","../src/core/WakeLockCore.ts","../src/components/WakeLock.ts","../src/registerComponents.ts","../src/bootstrapWakeLock.ts"],"sourcesContent":["import { IConfig, IWritableConfig } from \"./types.js\";\n\ninterface IInternalConfig extends IConfig {\n  tagNames: {\n    wakelock: string;\n  };\n}\n\nconst _config: IInternalConfig = {\n  tagNames: {\n    wakelock: \"wcs-wakelock\",\n  },\n};\n\nfunction deepFreeze<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  Object.freeze(obj);\n  for (const key of Object.keys(obj)) {\n    deepFreeze((obj as Record<string, unknown>)[key]);\n  }\n  return obj;\n}\n\nfunction deepClone<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  const clone: Record<string, unknown> = {};\n  for (const key of Object.keys(obj)) {\n    clone[key] = deepClone((obj as Record<string, unknown>)[key]);\n  }\n  return clone as T;\n}\n\nlet frozenConfig: IConfig | null = null;\n\n// Note: this is the live, mutable internal config. It is not part of the public\n// package exports (see exports.ts) — only `getConfig()` (frozen snapshot) and\n// `setConfig()` are surfaced — but a deep path import (`.../src/config.js`) can still\n// reach and mutate it. Accepted as-is for cross-package consistency: every @wcstack\n// package follows this same shape. Use `getConfig()` for a frozen, safe read.\nexport const config: IConfig = _config as IConfig;\n\nexport function getConfig(): IConfig {\n  if (!frozenConfig) {\n    frozenConfig = deepFreeze(deepClone(_config));\n  }\n  return frozenConfig;\n}\n\nexport function setConfig(partialConfig: IWritableConfig): void {\n  if (partialConfig.tagNames) {\n    Object.assign(_config.tagNames, partialConfig.tagNames);\n  }\n  frozenConfig = null;\n}\n","import { IWcBindable, WakeLockKind } from \"../types.js\";\n\n/**\n * Minimal structural views of the Screen Wake Lock API. Declared locally (rather\n * than relying on `lib.dom`'s experimental `WakeLock` types) so the package type-\n * checks the same across TypeScript lib versions, and so a runtime where\n * `navigator.wakeLock` is absent is just a value check, never a type error.\n */\ninterface WakeLockSentinelLike extends EventTarget {\n  readonly released: boolean;\n  readonly type: string;\n  release(): Promise<void>;\n}\ninterface WakeLockLike {\n  request(type?: string): Promise<WakeLockSentinelLike>;\n}\n\n/**\n * Headless screen-wake-lock primitive — a thin, framework-agnostic wrapper around\n * the Screen Wake Lock API exposed through the wc-bindable protocol.\n *\n * Unlike the other @wcstack sensors (geolocation / intersection), the wake lock is\n * a pure *sink*: nothing is read from the device. A bound state drives the desired\n * intent (`request()` / `release()`), and the only observable outputs are `held`\n * (whether a sentinel is actually held) and `error`.\n *\n * The OS releases the lock whenever the page stops being visible (tab hidden,\n * window minimized). To honor the declarative intent (\"keep awake *while* active\"),\n * the Core keeps the desired flag (`_active`) and re-acquires the lock on the next\n * `visibilitychange` back to visible. So `_active` (desired) and `held` (actual)\n * diverge across an auto-release — and only `held` is published, because desired\n * does not change when the OS drops the lock.\n *\n * Never-throw: `request()` never rejects (a failure surfaces via `error`), and an\n * unsupported environment is a silent no-op (`held` stays false), consistent with\n * the other @wcstack sensors.\n */\nexport class WakeLockCore extends EventTarget {\n  static wcBindable: IWcBindable = {\n    protocol: \"wc-bindable\",\n    version: 1,\n    properties: [\n      { name: \"held\", event: \"wcs-wakelock:held-changed\" },\n      { name: \"error\", event: \"wcs-wakelock:error\" },\n    ],\n    commands: [\n      { name: \"request\", async: true },\n      { name: \"release\" },\n    ],\n  };\n\n  private _target: EventTarget;\n  private _type: WakeLockKind;\n\n  // `_active` is the desired intent (input); `_held` is whether a sentinel is\n  // actually held right now (output). They diverge across an OS auto-release.\n  private _active: boolean = false;\n  private _held: boolean = false;\n  private _error: Error | null = null;\n  private _sentinel: WakeLockSentinelLike | null = null;\n\n  // Bumped on every release()/new acquire so an in-flight async request() that\n  // resolves late can detect it was superseded and drop its sentinel (mirrors the\n  // generation guards in GeolocationCore).\n  private _gen: number = 0;\n  // True while an `_acquire()` is awaiting `navigator.wakeLock.request()`. The\n  // `_held` flag is only set *after* that await resolves, so it cannot guard\n  // against concurrent entry: two rapid visibilitychange events (or a Shell toggle\n  // overlapping an in-flight request) would both pass `!this._held` and each call\n  // `request()`. This in-flight flag closes that window — a re-entrant acquire is a\n  // no-op. The `_gen` guard still ensures the *final* state is correct; this just\n  // avoids the redundant `request()` call (and its duplicate error path on a denied\n  // environment).\n  private _acquiring: boolean = false;\n  private _visibilityBound: boolean = false;\n\n  constructor(target?: EventTarget, type: WakeLockKind = \"screen\") {\n    super();\n    this._target = target ?? this;\n    this._type = type;\n  }\n\n  get held(): boolean {\n    return this._held;\n  }\n\n  get error(): Error | null {\n    return this._error;\n  }\n\n  /** The desired intent. Read-only reflection; not a wc-bindable property (it does\n   * not change on an OS auto-release, so there is nothing to observe). */\n  get active(): boolean {\n    return this._active;\n  }\n\n  get type(): WakeLockKind {\n    return this._type;\n  }\n\n  set type(value: WakeLockKind) {\n    // Currently effectively a no-op: \"screen\" is the only standardized lock type,\n    // so `WakeLockKind` is a single value and this setter never observes a real\n    // change. Kept as a forward-compatible seam for when the spec adds lock types.\n    //\n    // Takes effect on the next acquire. Changing the type mid-hold deliberately does\n    // NOT re-acquire — the live sentinel is left as is, so a type change applies only\n    // from the following acquire. If multiple lock types are ever added this becomes\n    // an observable behavior gap (a held lock keeps its old type until release/re-\n    // acquire) and must be re-examined — likely re-acquire here when held.\n    this._type = value;\n  }\n\n  // --- State setters with event dispatch ---\n\n  private _setHeld(held: boolean): void {\n    if (this._held === held) return;\n    this._held = held;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-wakelock:held-changed\", {\n      detail: held,\n      bubbles: true,\n    }));\n  }\n\n  private _setError(error: Error | null): void {\n    // Value guard, not just reference: a denied request rejects with a *fresh*\n    // Error on every visibility-driven retry, so a reference compare would let a\n    // permanently-denied environment re-dispatch the same failure on each\n    // hidden→visible toggle. Compare name+message too. Transitions through null (a\n    // success clears the error) always re-fire, so a genuinely new failure is seen.\n    if (this._sameError(this._error, error)) return;\n    this._error = error;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-wakelock:error\", {\n      detail: error,\n      bubbles: true,\n    }));\n  }\n\n  private _sameError(a: Error | null, b: Error | null): boolean {\n    if (a === b) return true;\n    if (a !== null && b !== null) return a.name === b.name && a.message === b.message;\n    return false;\n  }\n\n  // --- Public API ---\n\n  /**\n   * Mark the lock as desired and acquire it. Idempotent while already held. If the\n   * API is unavailable or the page is currently hidden, the desired flag is still\n   * set (so the lock is acquired on the next return to visibility) but nothing is\n   * acquired now. Never rejects — a request failure surfaces via `error`.\n   */\n  async request(): Promise<void> {\n    this._active = true;\n    this._ensureVisibilityListener();\n    await this._acquire();\n  }\n\n  /** Mark the lock as no longer desired and release any held sentinel. */\n  release(): void {\n    this._active = false;\n    // Invalidate any in-flight acquire so a late-resolving request() drops its\n    // sentinel instead of leaving a lock held after release.\n    this._gen++;\n    const sentinel = this._sentinel;\n    if (sentinel) {\n      this._sentinel = null;\n      sentinel.removeEventListener(\"release\", this._onRelease);\n      void sentinel.release().catch(() => { /* never-throw */ });\n    }\n    this._setHeld(false);\n  }\n\n  /**\n   * Full teardown: remove the visibility listener and release any held sentinel.\n   * Call from the Shell's `disconnectedCallback`.\n   *\n   * Semantics: this is a terminal teardown, not a pause. After `dispose()` the Core\n   * is meant to be discarded — there is no re-arm step, and the visibility listener\n   * is gone, so an OS auto-release will no longer be followed by a re-acquire. A\n   * later `request()` would still work in isolation (it re-attaches the listener via\n   * `_ensureVisibilityListener`), but reusing a disposed Core is not an intended path;\n   * the Shell always constructs a fresh Core per element instead.\n   */\n  dispose(): void {\n    if (this._visibilityBound) {\n      document.removeEventListener(\"visibilitychange\", this._onVisibilityChange);\n      this._visibilityBound = false;\n    }\n    this.release();\n  }\n\n  // --- Internal ---\n\n  private async _acquire(): Promise<void> {\n    if (this._held) return; // idempotent: already holding a sentinel\n    if (this._acquiring) return; // an acquire is already in flight — don't double-request\n    const wakeLock = this._wakeLock();\n    if (!wakeLock) return; // unsupported — stay active, never acquire (silent no-op)\n    if (!this._isVisible()) return; // hidden — defer to the next visibilitychange\n    const gen = ++this._gen;\n    this._acquiring = true;\n    // Flag management is centralized in `finally` and the coalesced retry is invoked\n    // exactly once, AFTER the try/catch/finally settles. This keeps the reject and\n    // resolve paths symmetric: neither calls `_retryIfStillDesired()` from inside the\n    // try/catch (which would let `finally` re-clear the `_acquiring=true` the retry's\n    // synchronous re-entry just set, reopening the double-request window). `superseded`\n    // records that a newer release()/request() bumped `_gen` mid-flight so its still-\n    // live intent — blocked by the in-flight guard at the time — gets one retry here.\n    // NOTE: no early `return` inside the try/catch below — every branch must fall\n    // through to the post-`finally` retry. A `return` from inside the try would run\n    // `finally` and then exit the function, skipping the `if (superseded)` retry.\n    let superseded = false;\n    let sentinel: WakeLockSentinelLike | null = null;\n    let failed: Error | null = null;\n    try {\n      sentinel = await wakeLock.request(this._type);\n    } catch (e) {\n      if (gen !== this._gen) {\n        // Superseded while awaiting — drop this stale failure (do not clobber the\n        // newer state) and let the post-finally retry honor the live intent.\n        superseded = true;\n      } else {\n        failed = this._normalizeError(e);\n      }\n    } finally {\n      // The sole owner of the flag clears it here — on every exit path. A concurrent\n      // re-entrant `_acquire()` was a no-op at the `_acquiring` guard, so it never owns\n      // the flag; a superseding release()/acquire only bumps `_gen` and does not start\n      // its own in-flight cycle until this clears the flag. Because this runs before\n      // the retry below, the retry's `_acquiring=true` is never clobbered.\n      this._acquiring = false;\n    }\n\n    if (sentinel !== null && gen !== this._gen) {\n      // release() (or a newer acquire) ran while we awaited — this sentinel is\n      // unwanted; drop it so no lock lingers, and retry the newer intent below.\n      void sentinel.release().catch(() => { /* never-throw */ });\n      superseded = true;\n    } else if (sentinel !== null) {\n      this._sentinel = sentinel;\n      sentinel.addEventListener(\"release\", this._onRelease);\n      this._setError(null);\n      this._setHeld(true);\n    } else if (failed !== null) {\n      // A live (non-superseded) failure: surface it. Never retried — the intent is\n      // honored but the environment denied it, so looping would spin.\n      this._setError(failed);\n      this._setHeld(false);\n    }\n\n    // Coalesced retry: at most one re-attempt per supersession, after the flag is\n    // clear. The `_acquiring` guard inside still protects any concurrent re-entry that\n    // overlaps THIS retry's own in-flight window (reject- and resolve-retry alike).\n    if (superseded) this._retryIfStillDesired();\n  }\n\n  /**\n   * Re-attempt an acquire after an in-flight one was *superseded* (its generation no\n   * longer matches), but only if the lock is still desired, not already held, and the\n   * page is visible. This recovers a request() that was coalesced away by the\n   * in-flight `_acquiring` guard: during a release()→request() overlap, the second\n   * request() bumps `_gen` and is a no-op at the guard, so without this retry its\n   * still-live intent would be lost until the next visibilitychange or manual call.\n   *\n   * Bounded — cannot loop forever: a retry runs ONLY on supersession, and a\n   * supersession requires an external release()/request() to bump `_gen` mid-flight.\n   * A retry's own `_acquire()`, if it is itself not superseded, terminates by either\n   * acquiring (held=true) or recording the live failure (held=false, error set) —\n   * neither path retries. So a denied environment that keeps rejecting does not\n   * recurse; the retry chain length is bounded by the number of external overlaps.\n   */\n  private _retryIfStillDesired(): void {\n    if (this._active && !this._held && this._isVisible()) {\n      void this._acquire();\n    }\n  }\n\n  // Fired for an OS release of a held sentinel — which the spec allows for several\n  // reasons, NOT only a visibility change: tab hidden / window minimized, but also\n  // battery-low, power-saver mode, etc. while the page stays visible. We reflect\n  // held=false, then (lease renewal) re-acquire immediately IF the page is still\n  // visible and the lock is still desired — because a visible-context release emits no\n  // `visibilitychange`, so the visibilitychange listener (②) would never fire and the\n  // lock would stay stuck at desired=true / held=false. The hidden case is the no-op\n  // here: re-acquire is gated on `_isVisible()`, so a hide-driven release defers to ②\n  // (re-acquire on the return to visibility), avoiding a release→acquire loop while\n  // hidden.\n  private _onRelease = (): void => {\n    // The `if (this._sentinel)` false branch is defensive and unreachable in practice:\n    // this listener is only ever attached to the live `_sentinel`, and the only paths\n    // that null `_sentinel` (this handler itself, and release()) remove this listener\n    // in the same step — so the listener and a non-null `_sentinel` are coupled and\n    // this never fires with `_sentinel === null`. Guarded anyway in case a host\n    // dispatches a spurious second \"release\". (c8 ignore the unhittable else.)\n    /* c8 ignore next */\n    if (this._sentinel) {\n      this._sentinel.removeEventListener(\"release\", this._onRelease);\n      this._sentinel = null;\n    }\n    this._setHeld(false);\n    this._reacquireAfterRelease();\n  };\n\n  /**\n   * Lease renewal after an OS release while the page is still visible. Honors the\n   * \"keep awake *while* active\" promise for releases that do NOT coincide with a\n   * visibility change (battery-low / power-saver), which otherwise leave the lock\n   * stuck at desired=true / held=false until the next hide→show cycle.\n   *\n   * Bounded on failure: this only runs from `_onRelease`, which only fires when a\n   * sentinel was genuinely acquired and then released. A re-acquire that FAILS takes\n   * `_acquire()`'s live-failure path (error recorded, held=false) and attaches no\n   * listener, so it cannot re-enter `_onRelease` — a denied environment records the\n   * error once and stops. This is the dominant real path: per the Wake Lock spec a\n   * re-request under battery-low / power-saver is rejected (`NotAllowedError`), so the\n   * renewal terminates there.\n   *\n   * The one path NOT bounded by a counter is a pathological host that keeps GRANTING\n   * the re-request and then immediately auto-releasing it (grant→release reflux). Each\n   * iteration yields to the event loop and consumes a real OS grant, so it is not a\n   * tight/synchronous loop, but it would churn request() calls. We deliberately do NOT\n   * add a debounce or renewal cap: that reflux is not documented browser behavior\n   * (real browsers reject, not grant-then-revoke), and the extra timing state would\n   * complicate the pure-sink design to defend a case that does not occur in practice.\n   *\n   * The `_isVisible()` / `!_acquiring` guards (doubled by `_acquire()`'s own in-flight\n   * and held guards) prevent re-entry during an in-flight acquire and while hidden.\n   */\n  private _reacquireAfterRelease(): void {\n    if (this._active && this._isVisible() && !this._acquiring) {\n      void this._acquire();\n    }\n  }\n\n  // ② Re-acquire when the page becomes visible again while the lock is still\n  // desired but was auto-released. This is what makes `active` a durable intent.\n  private _onVisibilityChange = (): void => {\n    if (this._isVisible() && this._active && !this._held) {\n      void this._acquire();\n    }\n  };\n\n  private _ensureVisibilityListener(): void {\n    if (this._visibilityBound) return;\n    document.addEventListener(\"visibilitychange\", this._onVisibilityChange);\n    this._visibilityBound = true;\n  }\n\n  private _wakeLock(): WakeLockLike | null {\n    return (navigator as Navigator & { wakeLock?: WakeLockLike }).wakeLock ?? null;\n  }\n\n  private _isVisible(): boolean {\n    return document.visibilityState === \"visible\";\n  }\n\n  private _normalizeError(e: unknown): Error {\n    return e instanceof Error ? e : new Error(String(e));\n  }\n}\n","import { IWcBindable, WakeLockKind } from \"../types.js\";\nimport { WakeLockCore } from \"../core/WakeLockCore.js\";\n\n/**\n * `<wcs-wakelock>` — declarative Screen Wake Lock.\n *\n * The first @wcstack tag that is a pure *sink*: every other sensor is an\n * element→state producer, but the wake lock is state→element. The headline\n * binding is `active@isPlaying` — hold the screen awake while a bound boolean is\n * true. `active` is the single input knob (a mirrored attribute); `held` and\n * `error` are the observable outputs.\n *\n * The OS auto-releases the lock when the page is hidden; the Core re-acquires it\n * on the next return to visibility while `active` is still set, so the binding\n * means \"keep awake *while* active\", not just \"acquire once\".\n */\nexport class WcsWakeLock extends HTMLElement {\n  // SSR contract (@wcstack/server): the renderer awaits elements declaring\n  // `hasConnectedCallbackPromise = true` before snapshotting. The wake lock has no\n  // connect-time async fix to await (acquire is fire-and-forget and meaningless\n  // server-side), so this is `false` — same as the other synchronous sensor Shells\n  // (sse / intersection / worker). Kept (not deleted) because it is the protocol\n  // contract surface the server renderer reads via `ctor.hasConnectedCallbackPromise`.\n  static hasConnectedCallbackPromise = false;\n  // `active` drives request/release; `type` propagates to the Core's next acquire.\n  // `manual` is intentionally excluded: it is a connect-time policy (\"don't auto-\n  // acquire on connect\"), not a live switch.\n  static observedAttributes = [\"active\", \"type\"];\n\n  static wcBindable: IWcBindable = {\n    ...WakeLockCore.wcBindable,\n    // Settable surface. `active` is the declarative intent; `type` selects the lock\n    // kind; `manual` opts out of auto-acquire on connect. The request / release\n    // commands are inherited from the Core via the spread above.\n    inputs: [\n      { name: \"active\", attribute: \"active\" },\n      { name: \"type\", attribute: \"type\" },\n      { name: \"manual\", attribute: \"manual\" },\n    ],\n    // Core の commands をそのまま継承（単一情報源）。<wcs-intersect>/<wcs-sse> と同型。\n    // spread でも継承されるが、Core に command 追加時の追従漏れを防ぐため明示参照する。\n    commands: WakeLockCore.wcBindable.commands,\n  };\n\n  private _core: WakeLockCore;\n\n  constructor() {\n    super();\n    this._core = new WakeLockCore(this);\n  }\n\n  // --- Attribute accessors ---\n\n  get active(): boolean {\n    // Reflects the *attribute*, not the Core's desired intent (`_core.active`). These\n    // can diverge: invoking the `request` / `release` commands directly (e.g. via a\n    // command-token binding) flips the Core's desired flag without touching the\n    // attribute, so `el.active` may read false while `el.held` is true (or vice\n    // versa). The attribute is the declarative input surface; the commands are an\n    // imperative side door. Bind via `active@...` for a single source of truth.\n    return this.hasAttribute(\"active\");\n  }\n\n  set active(value: boolean) {\n    if (value) {\n      this.setAttribute(\"active\", \"\");\n    } else {\n      this.removeAttribute(\"active\");\n    }\n  }\n\n  get type(): WakeLockKind {\n    // Only \"screen\" is standardized; an absent/empty attribute defaults to it.\n    return (this.getAttribute(\"type\") as WakeLockKind) || \"screen\";\n  }\n\n  set type(value: WakeLockKind) {\n    this.setAttribute(\"type\", value);\n  }\n\n  get manual(): boolean {\n    return this.hasAttribute(\"manual\");\n  }\n\n  set manual(value: boolean) {\n    if (value) {\n      this.setAttribute(\"manual\", \"\");\n    } else {\n      this.removeAttribute(\"manual\");\n    }\n  }\n\n  // --- Core delegated getters ---\n\n  get held(): boolean {\n    return this._core.held;\n  }\n\n  get error(): Error | null {\n    return this._core.error;\n  }\n\n  // --- Commands ---\n\n  /** Acquire (and keep) the wake lock. Never rejects — see the `error` property. */\n  request(): Promise<void> {\n    return this._core.request();\n  }\n\n  /** Release the wake lock and stop re-acquiring it. */\n  release(): void {\n    this._core.release();\n  }\n\n  // --- Lifecycle ---\n\n  connectedCallback(): void {\n    // Headless resource: no layout box (mirrors the @wcstack sensor convention).\n    this.style.display = \"none\";\n    // Propagate the requested lock type to the Core. Currently a no-op in effect:\n    // \"screen\" is the only standardized type, so `type` is always \"screen\". Wired\n    // up as a forward-compatible seam (observedAttributes + setter + this line) for\n    // when the spec adds lock types; until then it carries a constant.\n    this._core.type = this.type;\n    if (!this.manual && this.active) {\n      void this._core.request();\n    }\n  }\n\n  disconnectedCallback(): void {\n    this._core.dispose();\n  }\n\n  attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void {\n    if (oldValue === newValue) return;\n    // Ignore changes applied before connect (e.g. createElement + setAttribute);\n    // connectedCallback applies the initial state. Acquiring a lock for a detached\n    // element would be wrong.\n    if (!this.isConnected) return;\n    if (name === \"type\") {\n      this._core.type = this.type;\n      return;\n    }\n    // name === \"active\": a live toggle always drives request/release. `manual` only\n    // gates the connect-time auto-acquire, not an explicit author toggle.\n    if (this.active) {\n      void this._core.request();\n    } else {\n      this._core.release();\n    }\n  }\n}\n","import { WcsWakeLock } from \"./components/WakeLock.js\";\nimport { config } from \"./config.js\";\n\nexport function registerComponents(): void {\n  if (!customElements.get(config.tagNames.wakelock)) {\n    customElements.define(config.tagNames.wakelock, WcsWakeLock);\n  }\n}\n","import { setConfig } from \"./config.js\";\nimport { registerComponents } from \"./registerComponents.js\";\nimport { IWritableConfig } from \"./types.js\";\n\nexport function bootstrapWakeLock(userConfig?: IWritableConfig): void {\n  if (userConfig) {\n    setConfig(userConfig);\n  }\n  registerComponents();\n}\n"],"names":[],"mappings":"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"}

package/dist/index.esm.min.js

@@ -0,0 +1,2 @@
+const e={tagNames:{wakelock:"wcs-wakelock"}};function t(e){if(null===e||"object"!=typeof e)return e;Object.freeze(e);for(const i of Object.keys(e))t(e[i]);return e}function i(e){if(null===e||"object"!=typeof e)return e;const t={};for(const s of Object.keys(e))t[s]=i(e[s]);return t}let s=null;const r=e;function n(){return s||(s=t(i(e))),s}class a extends EventTarget{static wcBindable={protocol:"wc-bindable",version:1,properties:[{name:"held",event:"wcs-wakelock:held-changed"},{name:"error",event:"wcs-wakelock:error"}],commands:[{name:"request",async:!0},{name:"release"}]};_target;_type;_active=!1;_held=!1;_error=null;_sentinel=null;_gen=0;_acquiring=!1;_visibilityBound=!1;constructor(e,t="screen"){super(),this._target=e??this,this._type=t}get held(){return this._held}get error(){return this._error}get active(){return this._active}get type(){return this._type}set type(e){this._type=e}_setHeld(e){this._held!==e&&(this._held=e,this._target.dispatchEvent(new CustomEvent("wcs-wakelock:held-changed",{detail:e,bubbles:!0})))}_setError(e){this._sameError(this._error,e)||(this._error=e,this._target.dispatchEvent(new CustomEvent("wcs-wakelock:error",{detail:e,bubbles:!0})))}_sameError(e,t){return e===t||null!==e&&null!==t&&(e.name===t.name&&e.message===t.message)}async request(){this._active=!0,this._ensureVisibilityListener(),await this._acquire()}release(){this._active=!1,this._gen++;const e=this._sentinel;e&&(this._sentinel=null,e.removeEventListener("release",this._onRelease),e.release().catch(()=>{})),this._setHeld(!1)}dispose(){this._visibilityBound&&(document.removeEventListener("visibilitychange",this._onVisibilityChange),this._visibilityBound=!1),this.release()}async _acquire(){if(this._held)return;if(this._acquiring)return;const e=this._wakeLock();if(!e)return;if(!this._isVisible())return;const t=++this._gen;this._acquiring=!0;let i=!1,s=null,r=null;try{s=await e.request(this._type)}catch(e){t!==this._gen?i=!0:r=this._normalizeError(e)}finally{this._acquiring=!1}null!==s&&t!==this._gen?(s.release().catch(()=>{}),i=!0):null!==s?(this._sentinel=s,s.addEventListener("release",this._onRelease),this._setError(null),this._setHeld(!0)):null!==r&&(this._setError(r),this._setHeld(!1)),i&&this._retryIfStillDesired()}_retryIfStillDesired(){this._active&&!this._held&&this._isVisible()&&this._acquire()}_onRelease=()=>{this._sentinel&&(this._sentinel.removeEventListener("release",this._onRelease),this._sentinel=null),this._setHeld(!1),this._reacquireAfterRelease()};_reacquireAfterRelease(){this._active&&this._isVisible()&&!this._acquiring&&this._acquire()}_onVisibilityChange=()=>{this._isVisible()&&this._active&&!this._held&&this._acquire()};_ensureVisibilityListener(){this._visibilityBound||(document.addEventListener("visibilitychange",this._onVisibilityChange),this._visibilityBound=!0)}_wakeLock(){return navigator.wakeLock??null}_isVisible(){return"visible"===document.visibilityState}_normalizeError(e){return e instanceof Error?e:new Error(String(e))}}class l extends HTMLElement{static hasConnectedCallbackPromise=!1;static observedAttributes=["active","type"];static wcBindable={...a.wcBindable,inputs:[{name:"active",attribute:"active"},{name:"type",attribute:"type"},{name:"manual",attribute:"manual"}],commands:a.wcBindable.commands};_core;constructor(){super(),this._core=new a(this)}get active(){return this.hasAttribute("active")}set active(e){e?this.setAttribute("active",""):this.removeAttribute("active")}get type(){return this.getAttribute("type")||"screen"}set type(e){this.setAttribute("type",e)}get manual(){return this.hasAttribute("manual")}set manual(e){e?this.setAttribute("manual",""):this.removeAttribute("manual")}get held(){return this._core.held}get error(){return this._core.error}request(){return this._core.request()}release(){this._core.release()}connectedCallback(){this.style.display="none",this._core.type=this.type,!this.manual&&this.active&&this._core.request()}disconnectedCallback(){this._core.dispose()}attributeChangedCallback(e,t,i){t!==i&&this.isConnected&&("type"!==e?this.active?this._core.request():this._core.release():this._core.type=this.type)}}function c(t){var i;t&&((i=t).tagNames&&Object.assign(e.tagNames,i.tagNames),s=null),customElements.get(r.tagNames.wakelock)||customElements.define(r.tagNames.wakelock,l)}export{a as WakeLockCore,l as WcsWakeLock,c as bootstrapWakeLock,n as getConfig};
+//# sourceMappingURL=index.esm.min.js.map