sibujs 1.0.0-beta.1

package/dist/browser.cjs

@@ -0,0 +1,815 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  battery: () => battery,
+  clipboard: () => clipboard,
+  colorScheme: () => colorScheme,
+  draggable: () => draggable,
+  dropZone: () => dropZone,
+  geo: () => geo,
+  idle: () => idle,
+  media: () => media,
+  online: () => online,
+  permissions: () => permissions,
+  resize: () => resize,
+  scroll: () => scroll,
+  title: () => title
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/browser/media.ts
+function media(query) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    const [matches2] = signal(false);
+    return { matches: matches2, dispose: () => {
+    } };
+  }
+  const mql = window.matchMedia(query);
+  const [matches, setMatches] = signal(mql.matches);
+  const handler = (event) => {
+    setMatches(event.matches);
+  };
+  mql.addEventListener("change", handler);
+  function dispose() {
+    mql.removeEventListener("change", handler);
+  }
+  return { matches, dispose };
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/browser/resize.ts
+function resize(target) {
+  const [width, setWidth] = signal(0);
+  const [height, setHeight] = signal(0);
+  let observer = null;
+  if (typeof window === "undefined" || typeof ResizeObserver === "undefined") {
+    return { width, height, dispose: () => {
+    } };
+  }
+  const cleanup2 = effect(() => {
+    const el = target();
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    if (!el) return;
+    observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) {
+        batch(() => {
+          setWidth(entry.contentRect.width);
+          setHeight(entry.contentRect.height);
+        });
+      }
+    });
+    observer.observe(el);
+  });
+  function dispose() {
+    cleanup2();
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  }
+  return { width, height, dispose };
+}
+
+// src/browser/scroll.ts
+function scroll(target) {
+  const [x, setX] = signal(0);
+  const [y, setY] = signal(0);
+  const [isScrolling, setIsScrolling] = signal(false);
+  let scrollTimer = null;
+  if (typeof window === "undefined") {
+    return { x, y, isScrolling, dispose: () => {
+    } };
+  }
+  const handler = () => {
+    const el = target ? target() : null;
+    batch(() => {
+      if (el) {
+        setX(el.scrollLeft);
+        setY(el.scrollTop);
+      } else {
+        setX(window.scrollX ?? window.pageXOffset ?? 0);
+        setY(window.scrollY ?? window.pageYOffset ?? 0);
+      }
+      setIsScrolling(true);
+    });
+    if (scrollTimer !== null) clearTimeout(scrollTimer);
+    scrollTimer = setTimeout(() => {
+      setIsScrolling(false);
+      scrollTimer = null;
+    }, 150);
+  };
+  const scrollTarget = target ? target() : null;
+  const eventTarget = scrollTarget || window;
+  eventTarget.addEventListener("scroll", handler, { passive: true });
+  function dispose() {
+    eventTarget.removeEventListener("scroll", handler);
+    if (scrollTimer !== null) {
+      clearTimeout(scrollTimer);
+      scrollTimer = null;
+    }
+  }
+  return { x, y, isScrolling, dispose };
+}
+
+// src/browser/online.ts
+function online() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    const [online3] = signal(true);
+    return { online: online3, dispose: () => {
+    } };
+  }
+  const [online2, setOnline] = signal(navigator.onLine);
+  const onOnline = () => setOnline(true);
+  const onOffline = () => setOnline(false);
+  window.addEventListener("online", onOnline);
+  window.addEventListener("offline", onOffline);
+  function dispose() {
+    window.removeEventListener("online", onOnline);
+    window.removeEventListener("offline", onOffline);
+  }
+  return { online: online2, dispose };
+}
+
+// src/browser/geo.ts
+function geo(options) {
+  const [latitude, setLatitude] = signal(null);
+  const [longitude, setLongitude] = signal(null);
+  const [accuracy, setAccuracy] = signal(null);
+  const [error, setError] = signal(null);
+  let watchId = null;
+  if (typeof navigator !== "undefined" && navigator.geolocation) {
+    watchId = navigator.geolocation.watchPosition(
+      (position) => {
+        batch(() => {
+          setLatitude(position.coords.latitude);
+          setLongitude(position.coords.longitude);
+          setAccuracy(position.coords.accuracy);
+          setError(null);
+        });
+      },
+      (err) => {
+        setError(err);
+      },
+      options
+    );
+  }
+  function dispose() {
+    if (watchId !== null && typeof navigator !== "undefined" && navigator.geolocation) {
+      navigator.geolocation.clearWatch(watchId);
+      watchId = null;
+    }
+  }
+  return { latitude, longitude, accuracy, error, dispose };
+}
+
+// src/browser/battery.ts
+function battery() {
+  const [level, setLevel] = signal(null);
+  const [charging, setCharging] = signal(null);
+  const [chargingTime, setChargingTime] = signal(null);
+  const [dischargingTime, setDischargingTime] = signal(null);
+  const [supported, setSupported] = signal(false);
+  let battery2 = null;
+  let onLevelChange = null;
+  let onChargingChange = null;
+  let onChargingTimeChange = null;
+  let onDischargingTimeChange = null;
+  let disposed = false;
+  if (typeof navigator !== "undefined" && "getBattery" in navigator) {
+    setSupported(true);
+    navigator.getBattery().then((bm) => {
+      if (disposed) return;
+      battery2 = bm;
+      batch(() => {
+        setLevel(bm.level);
+        setCharging(bm.charging);
+        setChargingTime(bm.chargingTime);
+        setDischargingTime(bm.dischargingTime);
+      });
+      onLevelChange = () => setLevel(bm.level);
+      onChargingChange = () => setCharging(bm.charging);
+      onChargingTimeChange = () => setChargingTime(bm.chargingTime);
+      onDischargingTimeChange = () => setDischargingTime(bm.dischargingTime);
+      bm.addEventListener("levelchange", onLevelChange);
+      bm.addEventListener("chargingchange", onChargingChange);
+      bm.addEventListener("chargingtimechange", onChargingTimeChange);
+      bm.addEventListener("dischargingtimechange", onDischargingTimeChange);
+    });
+  }
+  function dispose() {
+    disposed = true;
+    if (battery2) {
+      if (onLevelChange) battery2.removeEventListener("levelchange", onLevelChange);
+      if (onChargingChange) battery2.removeEventListener("chargingchange", onChargingChange);
+      if (onChargingTimeChange) battery2.removeEventListener("chargingtimechange", onChargingTimeChange);
+      if (onDischargingTimeChange) battery2.removeEventListener("dischargingtimechange", onDischargingTimeChange);
+      battery2 = null;
+    }
+  }
+  return { level, charging, chargingTime, dischargingTime, supported, dispose };
+}
+
+// src/browser/idle.ts
+var ACTIVITY_EVENTS = ["mousemove", "mousedown", "keydown", "touchstart", "scroll"];
+function idle(timeout = 6e4) {
+  const [idle2, setIdle] = signal(false);
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return { idle: idle2, dispose: () => {
+    } };
+  }
+  let timer = null;
+  function resetTimer() {
+    setIdle(false);
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      setIdle(true);
+    }, timeout);
+  }
+  for (const event of ACTIVITY_EVENTS) {
+    document.addEventListener(event, resetTimer, { passive: true });
+  }
+  resetTimer();
+  function dispose() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    for (const event of ACTIVITY_EVENTS) {
+      document.removeEventListener(event, resetTimer);
+    }
+  }
+  return { idle: idle2, dispose };
+}
+
+// src/browser/permissions.ts
+function permissions(name) {
+  const [state, setState] = signal("prompt");
+  let permissionStatus = null;
+  let onChange = null;
+  let disposed = false;
+  if (typeof navigator === "undefined" || !navigator.permissions) {
+    setState("unsupported");
+    return { state, dispose: () => {
+    } };
+  }
+  navigator.permissions.query({ name }).then((status) => {
+    if (disposed) return;
+    permissionStatus = status;
+    setState(status.state);
+    onChange = () => {
+      setState(status.state);
+    };
+    status.addEventListener("change", onChange);
+  }).catch(() => {
+    setState("unsupported");
+  });
+  function dispose() {
+    disposed = true;
+    if (permissionStatus && onChange) {
+      permissionStatus.removeEventListener("change", onChange);
+      permissionStatus = null;
+      onChange = null;
+    }
+  }
+  return { state, dispose };
+}
+
+// src/browser/clipboard.ts
+function clipboard() {
+  const [text, setText] = signal("");
+  const [copied, setCopied] = signal(false);
+  let copiedTimer = null;
+  async function copy(value) {
+    if (typeof navigator === "undefined" || !navigator.clipboard) {
+      return;
+    }
+    await navigator.clipboard.writeText(value);
+    setText(value);
+    setCopied(true);
+    if (copiedTimer !== null) clearTimeout(copiedTimer);
+    copiedTimer = setTimeout(() => {
+      setCopied(false);
+      copiedTimer = null;
+    }, 2e3);
+  }
+  function dispose() {
+    if (copiedTimer !== null) {
+      clearTimeout(copiedTimer);
+      copiedTimer = null;
+    }
+  }
+  return { text, copy, copied, dispose };
+}
+
+// src/browser/dragDrop.ts
+function draggable(element, data) {
+  const [isDragging, setIsDragging] = signal(false);
+  if (typeof window === "undefined") {
+    return { isDragging, dispose: () => {
+    } };
+  }
+  let currentEl = null;
+  let onDragStart = null;
+  let onDragEnd = null;
+  const cleanup2 = effect(() => {
+    if (currentEl && onDragStart && onDragEnd) {
+      currentEl.removeEventListener("dragstart", onDragStart);
+      currentEl.removeEventListener("dragend", onDragEnd);
+    }
+    const el = element();
+    currentEl = el;
+    if (!el) return;
+    el.draggable = true;
+    onDragStart = (e) => {
+      setIsDragging(true);
+      if (e.dataTransfer && data !== void 0) {
+        e.dataTransfer.setData("application/json", JSON.stringify(data));
+      }
+    };
+    onDragEnd = () => {
+      setIsDragging(false);
+    };
+    el.addEventListener("dragstart", onDragStart);
+    el.addEventListener("dragend", onDragEnd);
+  });
+  function dispose() {
+    cleanup2();
+    if (currentEl && onDragStart && onDragEnd) {
+      currentEl.removeEventListener("dragstart", onDragStart);
+      currentEl.removeEventListener("dragend", onDragEnd);
+      currentEl = null;
+    }
+  }
+  return { isDragging, dispose };
+}
+function dropZone(element, options) {
+  const [isOver, setIsOver] = signal(false);
+  if (typeof window === "undefined") {
+    return { isOver, dispose: () => {
+    } };
+  }
+  let currentEl = null;
+  let onDragOver = null;
+  let onDragEnter = null;
+  let onDragLeave = null;
+  let onDrop = null;
+  const cleanup2 = effect(() => {
+    if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
+      currentEl.removeEventListener("dragover", onDragOver);
+      currentEl.removeEventListener("dragenter", onDragEnter);
+      currentEl.removeEventListener("dragleave", onDragLeave);
+      currentEl.removeEventListener("drop", onDrop);
+    }
+    const el = element();
+    currentEl = el;
+    if (!el) return;
+    onDragOver = (e) => {
+      e.preventDefault();
+    };
+    onDragEnter = (e) => {
+      e.preventDefault();
+      setIsOver(true);
+    };
+    onDragLeave = () => {
+      setIsOver(false);
+    };
+    onDrop = (e) => {
+      e.preventDefault();
+      setIsOver(false);
+      let transferData = null;
+      if (e.dataTransfer) {
+        const raw = e.dataTransfer.getData("application/json");
+        if (raw) {
+          try {
+            transferData = JSON.parse(raw);
+          } catch {
+            transferData = raw;
+          }
+        }
+      }
+      options.onDrop(transferData, e);
+    };
+    el.addEventListener("dragover", onDragOver);
+    el.addEventListener("dragenter", onDragEnter);
+    el.addEventListener("dragleave", onDragLeave);
+    el.addEventListener("drop", onDrop);
+  });
+  function dispose() {
+    cleanup2();
+    if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
+      currentEl.removeEventListener("dragover", onDragOver);
+      currentEl.removeEventListener("dragenter", onDragEnter);
+      currentEl.removeEventListener("dragleave", onDragLeave);
+      currentEl.removeEventListener("drop", onDrop);
+      currentEl = null;
+    }
+  }
+  return { isOver, dispose };
+}
+
+// src/browser/title.ts
+function title(value) {
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const previousTitle = document.title;
+  if (typeof value === "function") {
+    const cleanup2 = effect(() => {
+      document.title = value();
+    });
+    return () => {
+      cleanup2();
+      document.title = previousTitle;
+    };
+  }
+  document.title = value;
+  return () => {
+    document.title = previousTitle;
+  };
+}
+
+// src/browser/colorScheme.ts
+function colorScheme() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    const [scheme2] = signal("light");
+    return { scheme: scheme2, dispose: () => {
+    } };
+  }
+  const mql = window.matchMedia("(prefers-color-scheme: dark)");
+  const [scheme, setScheme] = signal(mql.matches ? "dark" : "light");
+  const handler = (event) => {
+    setScheme(event.matches ? "dark" : "light");
+  };
+  mql.addEventListener("change", handler);
+  function dispose() {
+    mql.removeEventListener("change", handler);
+  }
+  return { scheme, dispose };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  battery,
+  clipboard,
+  colorScheme,
+  draggable,
+  dropZone,
+  geo,
+  idle,
+  media,
+  online,
+  permissions,
+  resize,
+  scroll,
+  title
+});