diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..298eb4d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+node_modules/
+@girs/
diff --git a/app.js b/app.js
new file mode 100644
index 0000000..5c1daaf
--- /dev/null
+++ b/app.js
@@ -0,0 +1,1177 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../../../usr/share/astal/gjs/gtk3/index.ts
+import Astal7 from "gi://Astal?version=3.0";
+import Gtk4 from "gi://Gtk?version=3.0";
+import Gdk from "gi://Gdk?version=3.0";
+
+// ../../../../usr/share/astal/gjs/variable.ts
+import Astal3 from "gi://AstalIO";
+
+// ../../../../usr/share/astal/gjs/binding.ts
+var snakeify = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+var kebabify = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replaceAll("_", "-").toLowerCase();
+var Binding = class _Binding {
+  transformFn = (v) => v;
+  #emitter;
+  #prop;
+  static bind(emitter, prop) {
+    return new _Binding(emitter, prop);
+  }
+  constructor(emitter, prop) {
+    this.#emitter = emitter;
+    this.#prop = prop && kebabify(prop);
+  }
+  toString() {
+    return `Binding<${this.#emitter}${this.#prop ? `, "${this.#prop}"` : ""}>`;
+  }
+  as(fn) {
+    const bind2 = new _Binding(this.#emitter, this.#prop);
+    bind2.transformFn = (v) => fn(this.transformFn(v));
+    return bind2;
+  }
+  get() {
+    if (typeof this.#emitter.get === "function")
+      return this.transformFn(this.#emitter.get());
+    if (typeof this.#prop === "string") {
+      const getter = `get_${snakeify(this.#prop)}`;
+      if (typeof this.#emitter[getter] === "function")
+        return this.transformFn(this.#emitter[getter]());
+      return this.transformFn(this.#emitter[this.#prop]);
+    }
+    throw Error("can not get value of binding");
+  }
+  subscribe(callback) {
+    if (typeof this.#emitter.subscribe === "function") {
+      return this.#emitter.subscribe(() => {
+        callback(this.get());
+      });
+    } else if (typeof this.#emitter.connect === "function") {
+      const signal = `notify::${this.#prop}`;
+      const id = this.#emitter.connect(signal, () => {
+        callback(this.get());
+      });
+      return () => {
+        this.#emitter.disconnect(id);
+      };
+    }
+    throw Error(`${this.#emitter} is not bindable`);
+  }
+};
+var { bind } = Binding;
+var binding_default = Binding;
+
+// ../../../../usr/share/astal/gjs/time.ts
+import Astal from "gi://AstalIO";
+var Time = Astal.Time;
+function interval(interval2, callback) {
+  return Astal.Time.interval(interval2, () => void callback?.());
+}
+
+// ../../../../usr/share/astal/gjs/process.ts
+import Astal2 from "gi://AstalIO";
+var Process = Astal2.Process;
+function subprocess(argsOrCmd, onOut = print, onErr = printerr) {
+  const args = Array.isArray(argsOrCmd) || typeof argsOrCmd === "string";
+  const { cmd, err, out } = {
+    cmd: args ? argsOrCmd : argsOrCmd.cmd,
+    err: args ? onErr : argsOrCmd.err || onErr,
+    out: args ? onOut : argsOrCmd.out || onOut
+  };
+  const proc = Array.isArray(cmd) ? Astal2.Process.subprocessv(cmd) : Astal2.Process.subprocess(cmd);
+  proc.connect("stdout", (_, stdout) => out(stdout));
+  proc.connect("stderr", (_, stderr) => err(stderr));
+  return proc;
+}
+function execAsync(cmd) {
+  return new Promise((resolve, reject) => {
+    if (Array.isArray(cmd)) {
+      Astal2.Process.exec_asyncv(cmd, (_, res) => {
+        try {
+          resolve(Astal2.Process.exec_asyncv_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } else {
+      Astal2.Process.exec_async(cmd, (_, res) => {
+        try {
+          resolve(Astal2.Process.exec_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+  });
+}
+
+// ../../../../usr/share/astal/gjs/variable.ts
+var VariableWrapper = class extends Function {
+  variable;
+  errHandler = console.error;
+  _value;
+  _poll;
+  _watch;
+  pollInterval = 1e3;
+  pollExec;
+  pollTransform;
+  pollFn;
+  watchTransform;
+  watchExec;
+  constructor(init) {
+    super();
+    this._value = init;
+    this.variable = new Astal3.VariableBase();
+    this.variable.connect("dropped", () => {
+      this.stopWatch();
+      this.stopPoll();
+    });
+    this.variable.connect("error", (_, err) => this.errHandler?.(err));
+    return new Proxy(this, {
+      apply: (target, _, args) => target._call(args[0])
+    });
+  }
+  _call(transform) {
+    const b = binding_default.bind(this);
+    return transform ? b.as(transform) : b;
+  }
+  toString() {
+    return String(`Variable<${this.get()}>`);
+  }
+  get() {
+    return this._value;
+  }
+  set(value) {
+    if (value !== this._value) {
+      this._value = value;
+      this.variable.emit("changed");
+    }
+  }
+  startPoll() {
+    if (this._poll)
+      return;
+    if (this.pollFn) {
+      this._poll = interval(this.pollInterval, () => {
+        const v = this.pollFn(this.get());
+        if (v instanceof Promise) {
+          v.then((v2) => this.set(v2)).catch((err) => this.variable.emit("error", err));
+        } else {
+          this.set(v);
+        }
+      });
+    } else if (this.pollExec) {
+      this._poll = interval(this.pollInterval, () => {
+        execAsync(this.pollExec).then((v) => this.set(this.pollTransform(v, this.get()))).catch((err) => this.variable.emit("error", err));
+      });
+    }
+  }
+  startWatch() {
+    if (this._watch)
+      return;
+    this._watch = subprocess({
+      cmd: this.watchExec,
+      out: (out) => this.set(this.watchTransform(out, this.get())),
+      err: (err) => this.variable.emit("error", err)
+    });
+  }
+  stopPoll() {
+    this._poll?.cancel();
+    delete this._poll;
+  }
+  stopWatch() {
+    this._watch?.kill();
+    delete this._watch;
+  }
+  isPolling() {
+    return !!this._poll;
+  }
+  isWatching() {
+    return !!this._watch;
+  }
+  drop() {
+    this.variable.emit("dropped");
+  }
+  onDropped(callback) {
+    this.variable.connect("dropped", callback);
+    return this;
+  }
+  onError(callback) {
+    delete this.errHandler;
+    this.variable.connect("error", (_, err) => callback(err));
+    return this;
+  }
+  subscribe(callback) {
+    const id = this.variable.connect("changed", () => {
+      callback(this.get());
+    });
+    return () => this.variable.disconnect(id);
+  }
+  poll(interval2, exec, transform = (out) => out) {
+    this.stopPoll();
+    this.pollInterval = interval2;
+    this.pollTransform = transform;
+    if (typeof exec === "function") {
+      this.pollFn = exec;
+      delete this.pollExec;
+    } else {
+      this.pollExec = exec;
+      delete this.pollFn;
+    }
+    this.startPoll();
+    return this;
+  }
+  watch(exec, transform = (out) => out) {
+    this.stopWatch();
+    this.watchExec = exec;
+    this.watchTransform = transform;
+    this.startWatch();
+    return this;
+  }
+  observe(objs, sigOrFn, callback) {
+    const f = typeof sigOrFn === "function" ? sigOrFn : callback ?? (() => this.get());
+    const set = (obj, ...args) => this.set(f(obj, ...args));
+    if (Array.isArray(objs)) {
+      for (const obj of objs) {
+        const [o, s] = obj;
+        const id = o.connect(s, set);
+        this.onDropped(() => o.disconnect(id));
+      }
+    } else {
+      if (typeof sigOrFn === "string") {
+        const id = objs.connect(sigOrFn, set);
+        this.onDropped(() => objs.disconnect(id));
+      }
+    }
+    return this;
+  }
+  static derive(deps, fn = (...args) => args) {
+    const update = () => fn(...deps.map((d) => d.get()));
+    const derived = new Variable(update());
+    const unsubs = deps.map((dep) => dep.subscribe(() => derived.set(update())));
+    derived.onDropped(() => unsubs.map((unsub) => unsub()));
+    return derived;
+  }
+};
+var Variable = new Proxy(VariableWrapper, {
+  apply: (_t, _a, args) => new VariableWrapper(args[0])
+});
+var { derive } = Variable;
+var variable_default = Variable;
+
+// ../../../../usr/share/astal/gjs/_astal.ts
+var noImplicitDestroy = Symbol("no no implicit destroy");
+var setChildren = Symbol("children setter method");
+function mergeBindings(array) {
+  function getValues(...args) {
+    let i = 0;
+    return array.map(
+      (value) => value instanceof binding_default ? args[i++] : value
+    );
+  }
+  const bindings = array.filter((i) => i instanceof binding_default);
+  if (bindings.length === 0)
+    return array;
+  if (bindings.length === 1)
+    return bindings[0].as(getValues);
+  return variable_default.derive(bindings, getValues)();
+}
+function setProp(obj, prop, value) {
+  try {
+    const setter = `set_${snakeify(prop)}`;
+    if (typeof obj[setter] === "function")
+      return obj[setter](value);
+    return obj[prop] = value;
+  } catch (error) {
+    console.error(`could not set property "${prop}" on ${obj}:`, error);
+  }
+}
+function hook(widget, object, signalOrCallback, callback) {
+  if (typeof object.connect === "function" && callback) {
+    const id = object.connect(signalOrCallback, (_, ...args) => {
+      return callback(widget, ...args);
+    });
+    widget.connect("destroy", () => {
+      object.disconnect(id);
+    });
+  } else if (typeof object.subscribe === "function" && typeof signalOrCallback === "function") {
+    const unsub = object.subscribe((...args) => {
+      signalOrCallback(widget, ...args);
+    });
+    widget.connect("destroy", unsub);
+  }
+}
+function construct(widget, config) {
+  let { setup, child, children = [], ...props } = config;
+  if (children instanceof binding_default) {
+    children = [children];
+  }
+  if (child) {
+    children.unshift(child);
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (value === void 0) {
+      delete props[key];
+    }
+  }
+  const bindings = Object.keys(props).reduce((acc, prop) => {
+    if (props[prop] instanceof binding_default) {
+      const binding = props[prop];
+      delete props[prop];
+      return [...acc, [prop, binding]];
+    }
+    return acc;
+  }, []);
+  const onHandlers = Object.keys(props).reduce((acc, key) => {
+    if (key.startsWith("on")) {
+      const sig = kebabify(key).split("-").slice(1).join("-");
+      const handler = props[key];
+      delete props[key];
+      return [...acc, [sig, handler]];
+    }
+    return acc;
+  }, []);
+  const mergedChildren = mergeBindings(children.flat(Infinity));
+  if (mergedChildren instanceof binding_default) {
+    widget[setChildren](mergedChildren.get());
+    widget.connect("destroy", mergedChildren.subscribe((v) => {
+      widget[setChildren](v);
+    }));
+  } else {
+    if (mergedChildren.length > 0) {
+      widget[setChildren](mergedChildren);
+    }
+  }
+  for (const [signal, callback] of onHandlers) {
+    const sig = signal.startsWith("notify") ? signal.replace("-", "::") : signal;
+    if (typeof callback === "function") {
+      widget.connect(sig, callback);
+    } else {
+      widget.connect(sig, () => execAsync(callback).then(print).catch(console.error));
+    }
+  }
+  for (const [prop, binding] of bindings) {
+    if (prop === "child" || prop === "children") {
+      widget.connect("destroy", binding.subscribe((v) => {
+        widget[setChildren](v);
+      }));
+    }
+    widget.connect("destroy", binding.subscribe((v) => {
+      setProp(widget, prop, v);
+    }));
+    setProp(widget, prop, binding.get());
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (value === void 0) {
+      delete props[key];
+    }
+  }
+  Object.assign(widget, props);
+  setup?.(widget);
+  return widget;
+}
+function isArrowFunction(func) {
+  return !Object.hasOwn(func, "prototype");
+}
+function jsx(ctors2, ctor, { children, ...props }) {
+  children ??= [];
+  if (!Array.isArray(children))
+    children = [children];
+  children = children.filter(Boolean);
+  if (children.length === 1)
+    props.child = children[0];
+  else if (children.length > 1)
+    props.children = children;
+  if (typeof ctor === "string") {
+    if (isArrowFunction(ctors2[ctor]))
+      return ctors2[ctor](props);
+    return new ctors2[ctor](props);
+  }
+  if (isArrowFunction(ctor))
+    return ctor(props);
+  return new ctor(props);
+}
+
+// ../../../../usr/share/astal/gjs/gtk3/astalify.ts
+import Astal4 from "gi://Astal?version=3.0";
+import Gtk from "gi://Gtk?version=3.0";
+import GObject from "gi://GObject";
+function astalify(cls, clsName = cls.name) {
+  class Widget2 extends cls {
+    get css() {
+      return Astal4.widget_get_css(this);
+    }
+    set css(css) {
+      Astal4.widget_set_css(this, css);
+    }
+    get_css() {
+      return this.css;
+    }
+    set_css(css) {
+      this.css = css;
+    }
+    get className() {
+      return Astal4.widget_get_class_names(this).join(" ");
+    }
+    set className(className) {
+      Astal4.widget_set_class_names(this, className.split(/\s+/));
+    }
+    get_class_name() {
+      return this.className;
+    }
+    set_class_name(className) {
+      this.className = className;
+    }
+    get cursor() {
+      return Astal4.widget_get_cursor(this);
+    }
+    set cursor(cursor) {
+      Astal4.widget_set_cursor(this, cursor);
+    }
+    get_cursor() {
+      return this.cursor;
+    }
+    set_cursor(cursor) {
+      this.cursor = cursor;
+    }
+    get clickThrough() {
+      return Astal4.widget_get_click_through(this);
+    }
+    set clickThrough(clickThrough) {
+      Astal4.widget_set_click_through(this, clickThrough);
+    }
+    get_click_through() {
+      return this.clickThrough;
+    }
+    set_click_through(clickThrough) {
+      this.clickThrough = clickThrough;
+    }
+    get noImplicitDestroy() {
+      return this[noImplicitDestroy];
+    }
+    set noImplicitDestroy(value) {
+      this[noImplicitDestroy] = value;
+    }
+    set actionGroup([prefix, group]) {
+      this.insert_action_group(prefix, group);
+    }
+    set_action_group(actionGroup) {
+      this.actionGroup = actionGroup;
+    }
+    getChildren() {
+      if (this instanceof Gtk.Bin) {
+        return this.get_child() ? [this.get_child()] : [];
+      } else if (this instanceof Gtk.Container) {
+        return this.get_children();
+      }
+      return [];
+    }
+    setChildren(children) {
+      children = children.flat(Infinity).map((ch) => ch instanceof Gtk.Widget ? ch : new Gtk.Label({ visible: true, label: String(ch) }));
+      if (this instanceof Gtk.Container) {
+        for (const ch of children)
+          this.add(ch);
+      } else {
+        throw Error(`can not add children to ${this.constructor.name}`);
+      }
+    }
+    [setChildren](children) {
+      if (this instanceof Gtk.Container) {
+        for (const ch of this.getChildren()) {
+          this.remove(ch);
+          if (!children.includes(ch) && !this.noImplicitDestroy)
+            ch?.destroy();
+        }
+      }
+      this.setChildren(children);
+    }
+    toggleClassName(cn, cond = true) {
+      Astal4.widget_toggle_class_name(this, cn, cond);
+    }
+    hook(object, signalOrCallback, callback) {
+      hook(this, object, signalOrCallback, callback);
+      return this;
+    }
+    constructor(...params) {
+      super();
+      const props = params[0] || {};
+      props.visible ??= true;
+      construct(this, props);
+    }
+  }
+  GObject.registerClass({
+    GTypeName: `Astal_${clsName}`,
+    Properties: {
+      "class-name": GObject.ParamSpec.string(
+        "class-name",
+        "",
+        "",
+        GObject.ParamFlags.READWRITE,
+        ""
+      ),
+      "css": GObject.ParamSpec.string(
+        "css",
+        "",
+        "",
+        GObject.ParamFlags.READWRITE,
+        ""
+      ),
+      "cursor": GObject.ParamSpec.string(
+        "cursor",
+        "",
+        "",
+        GObject.ParamFlags.READWRITE,
+        "default"
+      ),
+      "click-through": GObject.ParamSpec.boolean(
+        "click-through",
+        "",
+        "",
+        GObject.ParamFlags.READWRITE,
+        false
+      ),
+      "no-implicit-destroy": GObject.ParamSpec.boolean(
+        "no-implicit-destroy",
+        "",
+        "",
+        GObject.ParamFlags.READWRITE,
+        false
+      )
+    }
+  }, Widget2);
+  return Widget2;
+}
+
+// ../../../../usr/share/astal/gjs/gtk3/app.ts
+import Gtk2 from "gi://Gtk?version=3.0";
+import Astal5 from "gi://Astal?version=3.0";
+
+// ../../../../usr/share/astal/gjs/overrides.ts
+var snakeify2 = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+async function suppress(mod, patch2) {
+  return mod.then((m) => patch2(m.default)).catch(() => void 0);
+}
+function patch(proto, prop) {
+  Object.defineProperty(proto, prop, {
+    get() {
+      return this[`get_${snakeify2(prop)}`]();
+    }
+  });
+}
+await suppress(import("gi://AstalApps"), ({ Apps, Application }) => {
+  patch(Apps.prototype, "list");
+  patch(Application.prototype, "keywords");
+  patch(Application.prototype, "categories");
+});
+await suppress(import("gi://AstalBattery"), ({ UPower }) => {
+  patch(UPower.prototype, "devices");
+});
+await suppress(import("gi://AstalBluetooth"), ({ Adapter, Bluetooth, Device }) => {
+  patch(Adapter.prototype, "uuids");
+  patch(Bluetooth.prototype, "adapters");
+  patch(Bluetooth.prototype, "devices");
+  patch(Device.prototype, "uuids");
+});
+await suppress(import("gi://AstalHyprland"), ({ Hyprland: Hyprland4, Monitor, Workspace }) => {
+  patch(Hyprland4.prototype, "monitors");
+  patch(Hyprland4.prototype, "workspaces");
+  patch(Hyprland4.prototype, "clients");
+  patch(Monitor.prototype, "availableModes");
+  patch(Monitor.prototype, "available_modes");
+  patch(Workspace.prototype, "clients");
+});
+await suppress(import("gi://AstalMpris"), ({ Mpris, Player }) => {
+  patch(Mpris.prototype, "players");
+  patch(Player.prototype, "supported_uri_schemes");
+  patch(Player.prototype, "supportedUriSchemes");
+  patch(Player.prototype, "supported_mime_types");
+  patch(Player.prototype, "supportedMimeTypes");
+  patch(Player.prototype, "comments");
+});
+await suppress(import("gi://AstalNetwork"), ({ Wifi }) => {
+  patch(Wifi.prototype, "access_points");
+  patch(Wifi.prototype, "accessPoints");
+});
+await suppress(import("gi://AstalNotifd"), ({ Notifd, Notification }) => {
+  patch(Notifd.prototype, "notifications");
+  patch(Notification.prototype, "actions");
+});
+await suppress(import("gi://AstalPowerProfiles"), ({ PowerProfiles: PowerProfiles2 }) => {
+  patch(PowerProfiles2.prototype, "actions");
+});
+await suppress(import("gi://AstalWp"), ({ Wp, Audio, Video }) => {
+  patch(Wp.prototype, "endpoints");
+  patch(Wp.prototype, "devices");
+  patch(Audio.prototype, "streams");
+  patch(Audio.prototype, "recorders");
+  patch(Audio.prototype, "microphones");
+  patch(Audio.prototype, "speakers");
+  patch(Audio.prototype, "devices");
+  patch(Video.prototype, "streams");
+  patch(Video.prototype, "recorders");
+  patch(Video.prototype, "sinks");
+  patch(Video.prototype, "sources");
+  patch(Video.prototype, "devices");
+});
+
+// ../../../../usr/share/astal/gjs/_app.ts
+import { setConsoleLogDomain } from "console";
+import { exit, programArgs } from "system";
+import IO from "gi://AstalIO";
+import GObject2 from "gi://GObject";
+function mkApp(App) {
+  return new class AstalJS extends App {
+    static {
+      GObject2.registerClass({ GTypeName: "AstalJS" }, this);
+    }
+    eval(body) {
+      return new Promise((res, rej) => {
+        try {
+          const fn = Function(`return (async function() {
+                        ${body.includes(";") ? body : `return ${body};`}
+                    })`);
+          fn()().then(res).catch(rej);
+        } catch (error) {
+          rej(error);
+        }
+      });
+    }
+    requestHandler;
+    vfunc_request(msg, conn) {
+      if (typeof this.requestHandler === "function") {
+        this.requestHandler(msg, (response) => {
+          IO.write_sock(
+            conn,
+            String(response),
+            (_, res) => IO.write_sock_finish(res)
+          );
+        });
+      } else {
+        super.vfunc_request(msg, conn);
+      }
+    }
+    apply_css(style, reset = false) {
+      super.apply_css(style, reset);
+    }
+    quit(code) {
+      super.quit();
+      exit(code ?? 0);
+    }
+    start({ requestHandler, css, hold, main, client, icons, ...cfg } = {}) {
+      const app = this;
+      client ??= () => {
+        print(`Astal instance "${app.instanceName}" already running`);
+        exit(1);
+      };
+      Object.assign(this, cfg);
+      setConsoleLogDomain(app.instanceName);
+      this.requestHandler = requestHandler;
+      app.connect("activate", () => {
+        main?.(...programArgs);
+      });
+      try {
+        app.acquire_socket();
+      } catch (error) {
+        return client((msg) => IO.send_message(app.instanceName, msg), ...programArgs);
+      }
+      if (css)
+        this.apply_css(css, false);
+      if (icons)
+        app.add_icons(icons);
+      hold ??= true;
+      if (hold)
+        app.hold();
+      app.runAsync([]);
+    }
+  }();
+}
+
+// ../../../../usr/share/astal/gjs/gtk3/app.ts
+Gtk2.init(null);
+var app_default = mkApp(Astal5.Application);
+
+// ../../../../usr/share/astal/gjs/gtk3/widget.ts
+var widget_exports = {};
+__export(widget_exports, {
+  Box: () => Box,
+  Button: () => Button,
+  CenterBox: () => CenterBox,
+  CircularProgress: () => CircularProgress,
+  DrawingArea: () => DrawingArea,
+  Entry: () => Entry,
+  EventBox: () => EventBox,
+  Icon: () => Icon,
+  Label: () => Label,
+  LevelBar: () => LevelBar,
+  MenuButton: () => MenuButton,
+  Overlay: () => Overlay,
+  Revealer: () => Revealer,
+  Scrollable: () => Scrollable,
+  Slider: () => Slider,
+  Stack: () => Stack,
+  Switch: () => Switch,
+  Window: () => Window
+});
+import Astal6 from "gi://Astal?version=3.0";
+import Gtk3 from "gi://Gtk?version=3.0";
+import GObject3 from "gi://GObject";
+function filter(children) {
+  return children.flat(Infinity).map((ch) => ch instanceof Gtk3.Widget ? ch : new Gtk3.Label({ visible: true, label: String(ch) }));
+}
+Object.defineProperty(Astal6.Box.prototype, "children", {
+  get() {
+    return this.get_children();
+  },
+  set(v) {
+    this.set_children(v);
+  }
+});
+var Box = class extends astalify(Astal6.Box) {
+  static {
+    GObject3.registerClass({ GTypeName: "Box" }, this);
+  }
+  constructor(props, ...children) {
+    super({ children, ...props });
+  }
+  setChildren(children) {
+    this.set_children(filter(children));
+  }
+};
+var Button = class extends astalify(Astal6.Button) {
+  static {
+    GObject3.registerClass({ GTypeName: "Button" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+var CenterBox = class extends astalify(Astal6.CenterBox) {
+  static {
+    GObject3.registerClass({ GTypeName: "CenterBox" }, this);
+  }
+  constructor(props, ...children) {
+    super({ children, ...props });
+  }
+  setChildren(children) {
+    const ch = filter(children);
+    this.startWidget = ch[0] || new Gtk3.Box();
+    this.centerWidget = ch[1] || new Gtk3.Box();
+    this.endWidget = ch[2] || new Gtk3.Box();
+  }
+};
+var CircularProgress = class extends astalify(Astal6.CircularProgress) {
+  static {
+    GObject3.registerClass({ GTypeName: "CircularProgress" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+var DrawingArea = class extends astalify(Gtk3.DrawingArea) {
+  static {
+    GObject3.registerClass({ GTypeName: "DrawingArea" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var Entry = class extends astalify(Gtk3.Entry) {
+  static {
+    GObject3.registerClass({ GTypeName: "Entry" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var EventBox = class extends astalify(Astal6.EventBox) {
+  static {
+    GObject3.registerClass({ GTypeName: "EventBox" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+var Icon = class extends astalify(Astal6.Icon) {
+  static {
+    GObject3.registerClass({ GTypeName: "Icon" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var Label = class extends astalify(Astal6.Label) {
+  static {
+    GObject3.registerClass({ GTypeName: "Label" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+  setChildren(children) {
+    this.label = String(children);
+  }
+};
+var LevelBar = class extends astalify(Astal6.LevelBar) {
+  static {
+    GObject3.registerClass({ GTypeName: "LevelBar" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var MenuButton = class extends astalify(Gtk3.MenuButton) {
+  static {
+    GObject3.registerClass({ GTypeName: "MenuButton" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+Object.defineProperty(Astal6.Overlay.prototype, "overlays", {
+  get() {
+    return this.get_overlays();
+  },
+  set(v) {
+    this.set_overlays(v);
+  }
+});
+var Overlay = class extends astalify(Astal6.Overlay) {
+  static {
+    GObject3.registerClass({ GTypeName: "Overlay" }, this);
+  }
+  constructor(props, ...children) {
+    super({ children, ...props });
+  }
+  setChildren(children) {
+    const [child, ...overlays] = filter(children);
+    this.set_child(child);
+    this.set_overlays(overlays);
+  }
+};
+var Revealer = class extends astalify(Gtk3.Revealer) {
+  static {
+    GObject3.registerClass({ GTypeName: "Revealer" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+var Scrollable = class extends astalify(Astal6.Scrollable) {
+  static {
+    GObject3.registerClass({ GTypeName: "Scrollable" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+var Slider = class extends astalify(Astal6.Slider) {
+  static {
+    GObject3.registerClass({ GTypeName: "Slider" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var Stack = class extends astalify(Astal6.Stack) {
+  static {
+    GObject3.registerClass({ GTypeName: "Stack" }, this);
+  }
+  constructor(props, ...children) {
+    super({ children, ...props });
+  }
+  setChildren(children) {
+    this.set_children(filter(children));
+  }
+};
+var Switch = class extends astalify(Gtk3.Switch) {
+  static {
+    GObject3.registerClass({ GTypeName: "Switch" }, this);
+  }
+  constructor(props) {
+    super(props);
+  }
+};
+var Window = class extends astalify(Astal6.Window) {
+  static {
+    GObject3.registerClass({ GTypeName: "Window" }, this);
+  }
+  constructor(props, child) {
+    super({ child, ...props });
+  }
+};
+
+// sass:/home/protoshark/.config/astal/style.scss
+var style_default = "window {\n  background: #191919;\n  color: #E0DBF0;\n  font-family: comfortaa;\n  font-weight: bolder;\n}\nwindow > centerbox {\n  background: #191919;\n}\n\nbutton {\n  animation: none;\n  background: transparent;\n  color: #FFFFFF;\n  padding: 0;\n}\nbutton > label {\n  transition: ease-out 0.2s;\n  margin: 4px 8px 4px 8px;\n  padding: 0 8px 0 8px;\n  border-radius: 10px;\n  color: #FFFFFF;\n}\nbutton.selected > label {\n  background: #CD1D48;\n}\nbutton:hover {\n  color: transparent;\n}\nbutton:hover > label {\n  background: #515151;\n}\nbutton:hover.selected > label {\n  background: #FF5580;\n}\n\n.workspaces {\n  padding: 0 20px 0 20px;\n}\n\n.workspaceContainer {\n  min-width: 32px;\n  padding: 0;\n  margin: 0;\n}\n\n.workspaceBg {\n  background: #191919;\n  border: 2px solid #FFFFFF;\n  border-radius: 100%;\n}\n\n.workspaceIndicator {\n  transition: all cubic-bezier(0.34, 1.4, 0.64, 1) 0.4s;\n  background: #FFFFFF;\n  min-width: 24px;\n  min-height: 4px;\n  border-radius: 4px;\n}\n\n.workspaceButton {\n  background: #191919;\n  padding: 0;\n  margin: 0;\n}\n.workspaceButton > box {\n  transition: all ease-out 0.1s;\n  margin: 2px 2px 6px 2px;\n  border-radius: 8px;\n}\n.workspaceButton > box > box {\n  margin-left: 6px;\n  transition: ease-out 0.2s;\n  min-width: 8px;\n  min-height: 8px;\n  border-radius: 100%;\n  border: solid 4px;\n  color: #FFFFFF;\n}\n.workspaceButton > box > box.active {\n  min-width: 0px;\n  min-height: 0px;\n  border-width: 8px;\n}\n.workspaceButton > box > box.focused {\n  min-width: 6px;\n  min-height: 6px;\n}\n.workspaceButton:hover {\n  color: #191919;\n}\n.workspaceButton:hover > box {\n  background: #515151;\n}\n\n.popupWindow {\n  background: transparent;\n}\n.popupWindow > box {\n  background: #191919;\n  border-radius: 8px;\n  box-shadow: 0 0 10px 4px black;\n  padding: 8px;\n  margin: 48px 20px 20px 12px;\n}\n\n.popupBattery {\n  min-height: 200px;\n  min-width: 152px;\n}\n.popupBattery .percentage {\n  color: #FFFFFF;\n  background: #191919;\n  border-radius: 6px;\n  padding: 4px 6px 4px 6px;\n  box-shadow: 0 0 5px -1px black;\n}\n.popupBattery levelbar block {\n  background: #00FFAA;\n  border-radius: 8px;\n}\n.popupBattery levelbar block.empty {\n  background: #515151;\n}\n.popupBattery .info {\n  min-height: 96px;\n  min-width: 96px;\n  background: #515151;\n  border-radius: 8px;\n}\n\n.batteryLevel {\n  background: green;\n  color: green;\n  min-height: 100px;\n  margin-top: 50px;\n  border: 20px solid red;\n}\n\n.battIcon {\n  font-size: 20px;\n}";
+
+// ../../../../usr/share/astal/gjs/index.ts
+import { default as default3 } from "gi://AstalIO?version=0.1";
+
+// ../../../../usr/share/astal/gjs/file.ts
+import Astal8 from "gi://AstalIO";
+import Gio from "gi://Gio?version=2.0";
+
+// ../../../../usr/share/astal/gjs/gobject.ts
+import GObject4 from "gi://GObject";
+import { default as default2 } from "gi://GLib?version=2.0";
+var meta = Symbol("meta");
+var priv = Symbol("priv");
+var { ParamSpec, ParamFlags } = GObject4;
+
+// widget/battery.tsx
+import Battery from "gi://AstalBattery";
+import PowerProfiles from "gi://AstalPowerProfiles";
+import Hyprland from "gi://AstalHyprland";
+
+// ../../../../usr/share/astal/gjs/gtk3/jsx-runtime.ts
+function jsx2(ctor, props) {
+  return jsx(ctors, ctor, props);
+}
+var ctors = {
+  box: Box,
+  button: Button,
+  centerbox: CenterBox,
+  circularprogress: CircularProgress,
+  drawingarea: DrawingArea,
+  entry: Entry,
+  eventbox: EventBox,
+  // TODO: fixed
+  // TODO: flowbox
+  icon: Icon,
+  label: Label,
+  levelbar: LevelBar,
+  // TODO: listbox
+  menubutton: MenuButton,
+  overlay: Overlay,
+  revealer: Revealer,
+  scrollable: Scrollable,
+  slider: Slider,
+  stack: Stack,
+  switch: Switch,
+  window: Window
+};
+var jsxs = jsx2;
+
+// widget/battery.tsx
+var hyprland = Hyprland.get_default();
+var batt = Battery.get_default();
+var powerProfiles = PowerProfiles.get_default();
+var battWindow = null;
+function BattWindow() {
+  const { TOP, LEFT } = Astal7.WindowAnchor;
+  return /* @__PURE__ */ jsx2(
+    "window",
+    {
+      className: "popupWindow",
+      namespace: "lazerpopup",
+      monitor: hyprland.focusedMonitor.id,
+      anchor: TOP | LEFT,
+      layer: Astal7.Layer.TOP,
+      children: /* @__PURE__ */ jsx2(
+        "box",
+        {
+          className: "popupBattery",
+          vertical: true,
+          children: /* @__PURE__ */ jsxs("box", { spacing: 10, children: [
+            /* @__PURE__ */ jsx2("overlay", { overlay: new widget_exports.Label({
+              halign: Gtk4.Align.CENTER,
+              valign: Gtk4.Align.CENTER,
+              className: "percentage",
+              label: "69%"
+            }), children: /* @__PURE__ */ jsx2(
+              "levelbar",
+              {
+                className: "batteryLevel",
+                minValue: 0,
+                maxValue: 1,
+                inverted: true,
+                widthRequest: 96,
+                vertical: true,
+                value: 0.69
+              }
+            ) }),
+            /* @__PURE__ */ jsxs("box", { vertical: true, spacing: 10, children: [
+              /* @__PURE__ */ jsx2("overlay", { overlay: new widget_exports.Box({
+                halign: Gtk4.Align.CENTER,
+                valign: Gtk4.Align.CENTER,
+                vertical: true,
+                children: [
+                  new widget_exports.Icon({
+                    icon: "/home/protoshark/.face",
+                    css: "font-size: 24px;"
+                  }),
+                  new widget_exports.Label({
+                    className: "title",
+                    label: "title"
+                  }),
+                  new widget_exports.Label({
+                    className: "status",
+                    label: "status"
+                  })
+                ]
+              }), children: /* @__PURE__ */ jsx2("box", { className: "info" }) }),
+              /* @__PURE__ */ jsx2("overlay", { overlay: new widget_exports.Box({
+                halign: Gtk4.Align.CENTER,
+                valign: Gtk4.Align.CENTER,
+                vertical: true,
+                children: [
+                  new widget_exports.Label({
+                    className: "title",
+                    label: "title"
+                  }),
+                  new widget_exports.Label({
+                    className: "status",
+                    label: "status"
+                  })
+                ]
+              }), children: /* @__PURE__ */ jsx2("box", { className: "info" }) })
+            ] })
+          ] })
+        }
+      )
+    }
+  );
+}
+function battery() {
+  return /* @__PURE__ */ jsx2(
+    "button",
+    {
+      className: "battery",
+      halign: Gtk4.Align.START,
+      onClick: () => {
+        if (battWindow === null) {
+          battWindow = BattWindow();
+        } else {
+          battWindow.destroy();
+          battWindow = null;
+        }
+      },
+      children: /* @__PURE__ */ jsxs("box", { children: [
+        /* @__PURE__ */ jsx2(
+          "icon",
+          {
+            className: "battIcon",
+            icon: "battery",
+            pixel_size: 20
+          }
+        ),
+        mergeBindings(
+          [bind(batt, "percentage").as((p) => `${Math.round(p * 100)}%`), bind(batt, "energy_rate").as((w) => `${w}W`)]
+        ).as((p) => `${p[0]} // ${p[1]}`)
+      ] })
+    }
+  );
+}
+
+// widget/workspaces.tsx
+import Hyprland2 from "gi://AstalHyprland";
+var hyprland2 = Hyprland2.get_default();
+function newWorkspace(ws, monitor) {
+  return /* @__PURE__ */ jsx2(
+    "overlay",
+    {
+      halign: Gtk4.Align.START,
+      overlays: [
+        new widget_exports.Button({
+          className: "workspaceButton",
+          visible: true,
+          onClick: () => {
+            hyprland2.dispatch("workspace", ws.toString());
+          }
+        }, new widget_exports.Box({
+          halign: Gtk4.Align.FILL,
+          valign: Gtk4.Align.FILL
+        }, new widget_exports.Box({
+          valign: Gtk4.Align.CENTER,
+          halign: Gtk4.Align.CENTER,
+          className: bind(hyprland2, "workspaces").as((wss) => {
+            let myws = wss.find((w) => w.id === ws);
+            return myws !== void 0 && myws.monitor.id === monitor ? "active" : "inactive";
+          }),
+          css: bind(hyprland2, "focusedWorkspace").as((fws) => {
+            return fws.id === ws ? "border-color: #00ffaa" : "border-color: #ffffff";
+          })
+        })))
+      ],
+      children: /* @__PURE__ */ jsx2("box", { className: "workspaceContainer" })
+    }
+  );
+}
+function workspaces(monitor) {
+  return /* @__PURE__ */ jsx2(
+    "overlay",
+    {
+      overlay: new widget_exports.Box({
+        halign: Gtk4.Align.START,
+        valign: Gtk4.Align.END,
+        className: "workspaceIndicator",
+        css: bind(hyprland2, "focusedWorkspace").as((ws) => {
+          return "margin-left: " + (24 + (ws.id - 1) * 32) + "px;";
+        })
+      }),
+      children: /* @__PURE__ */ jsx2(
+        "box",
+        {
+          className: "workspaces",
+          halign: Gtk4.Align.START,
+          visible: true,
+          setup: (self) => {
+            for (let i = 1; i <= 9; i++) {
+              self.add(newWorkspace(i, monitor.id));
+            }
+          }
+        }
+      )
+    }
+  );
+}
+
+// widget/Bar.tsx
+var time = Variable("").poll(1e3, "date +'%a %b %d // %H:%M'");
+function Bar(monitor) {
+  const { TOP, LEFT, RIGHT } = Astal7.WindowAnchor;
+  return /* @__PURE__ */ jsx2(
+    "window",
+    {
+      className: "bar",
+      namespace: "bar",
+      monitor: monitor.id,
+      exclusivity: Astal7.Exclusivity.IGNORE,
+      anchor: TOP | LEFT | RIGHT,
+      heightRequest: 36,
+      layer: Astal7.Layer.TOP,
+      application: app_default,
+      children: /* @__PURE__ */ jsxs("centerbox", { children: [
+        battery(),
+        workspaces(monitor),
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            className: "default",
+            onClicked: (self) => print(self.get_class_name()),
+            halign: Gtk4.Align.END,
+            children: /* @__PURE__ */ jsx2(
+              "label",
+              {
+                className: "innerButton",
+                label: time()
+              }
+            )
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// app.ts
+import Hyprland3 from "gi://AstalHyprland";
+var hyprland3 = Hyprland3.get_default();
+app_default.start({
+  css: style_default,
+  main() {
+    hyprland3.monitors.map((monitor) => Bar(monitor));
+  }
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../usr/share/astal/gjs/gtk3/index.ts", "../../../../usr/share/astal/gjs/variable.ts", "../../../../usr/share/astal/gjs/binding.ts", "../../../../usr/share/astal/gjs/time.ts", "../../../../usr/share/astal/gjs/process.ts", "../../../../usr/share/astal/gjs/_astal.ts", "../../../../usr/share/astal/gjs/gtk3/astalify.ts", "../../../../usr/share/astal/gjs/gtk3/app.ts", "../../../../usr/share/astal/gjs/overrides.ts", "../../../../usr/share/astal/gjs/_app.ts", "../../../../usr/share/astal/gjs/gtk3/widget.ts", "sass:/home/protoshark/.config/astal/style.scss", "../../../../usr/share/astal/gjs/index.ts", "../../../../usr/share/astal/gjs/file.ts", "../../../../usr/share/astal/gjs/gobject.ts", "widget/battery.tsx", "../../../../usr/share/astal/gjs/gtk3/jsx-runtime.ts", "widget/workspaces.tsx", "widget/Bar.tsx", "app.ts"],
  "sourcesContent": ["import Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport Gdk from \"gi://Gdk?version=3.0\"\nimport astalify, { type ConstructProps, type BindableProps } from \"./astalify.js\"\n\nexport { Astal, Gtk, Gdk }\nexport { default as App } from \"./app.js\"\nexport { astalify, ConstructProps, BindableProps }\nexport * as Widget from \"./widget.js\"\nexport { hook } from \"../_astal\"\n", "import Astal from \"gi://AstalIO\"\nimport Binding, { type Connectable, type Subscribable } from \"./binding.js\"\nimport { interval } from \"./time.js\"\nimport { execAsync, subprocess } from \"./process.js\"\n\nclass VariableWrapper<T> extends Function {\n    private variable!: Astal.VariableBase\n    private errHandler? = console.error\n\n    private _value: T\n    private _poll?: Astal.Time\n    private _watch?: Astal.Process\n\n    private pollInterval = 1000\n    private pollExec?: string[] | string\n    private pollTransform?: (stdout: string, prev: T) => T\n    private pollFn?: (prev: T) => T | Promise<T>\n\n    private watchTransform?: (stdout: string, prev: T) => T\n    private watchExec?: string[] | string\n\n    constructor(init: T) {\n        super()\n        this._value = init\n        this.variable = new Astal.VariableBase()\n        this.variable.connect(\"dropped\", () => {\n            this.stopWatch()\n            this.stopPoll()\n        })\n        this.variable.connect(\"error\", (_, err) => this.errHandler?.(err))\n        return new Proxy(this, {\n            apply: (target, _, args) => target._call(args[0]),\n        })\n    }\n\n    private _call<R = T>(transform?: (value: T) => R): Binding<R> {\n        const b = Binding.bind(this)\n        return transform ? b.as(transform) : b as unknown as Binding<R>\n    }\n\n    toString() {\n        return String(`Variable<${this.get()}>`)\n    }\n\n    get(): T { return this._value }\n    set(value: T) {\n        if (value !== this._value) {\n            this._value = value\n            this.variable.emit(\"changed\")\n        }\n    }\n\n    startPoll() {\n        if (this._poll)\n            return\n\n        if (this.pollFn) {\n            this._poll = interval(this.pollInterval, () => {\n                const v = this.pollFn!(this.get())\n                if (v instanceof Promise) {\n                    v.then(v => this.set(v))\n                        .catch(err => this.variable.emit(\"error\", err))\n                } else {\n                    this.set(v)\n                }\n            })\n        } else if (this.pollExec) {\n            this._poll = interval(this.pollInterval, () => {\n                execAsync(this.pollExec!)\n                    .then(v => this.set(this.pollTransform!(v, this.get())))\n                    .catch(err => this.variable.emit(\"error\", err))\n            })\n        }\n    }\n\n    startWatch() {\n        if (this._watch)\n            return\n\n        this._watch = subprocess({\n            cmd: this.watchExec!,\n            out: out => this.set(this.watchTransform!(out, this.get())),\n            err: err => this.variable.emit(\"error\", err),\n        })\n    }\n\n    stopPoll() {\n        this._poll?.cancel()\n        delete this._poll\n    }\n\n    stopWatch() {\n        this._watch?.kill()\n        delete this._watch\n    }\n\n    isPolling() { return !!this._poll }\n    isWatching() { return !!this._watch }\n\n    drop() {\n        this.variable.emit(\"dropped\")\n    }\n\n    onDropped(callback: () => void) {\n        this.variable.connect(\"dropped\", callback)\n        return this as unknown as Variable<T>\n    }\n\n    onError(callback: (err: string) => void) {\n        delete this.errHandler\n        this.variable.connect(\"error\", (_, err) => callback(err))\n        return this as unknown as Variable<T>\n    }\n\n    subscribe(callback: (value: T) => void) {\n        const id = this.variable.connect(\"changed\", () => {\n            callback(this.get())\n        })\n        return () => this.variable.disconnect(id)\n    }\n\n    poll(\n        interval: number,\n        exec: string | string[],\n        transform?: (stdout: string, prev: T) => T\n    ): Variable<T>\n\n    poll(\n        interval: number,\n        callback: (prev: T) => T | Promise<T>\n    ): Variable<T>\n\n    poll(\n        interval: number,\n        exec: string | string[] | ((prev: T) => T | Promise<T>),\n        transform: (stdout: string, prev: T) => T = out => out as T,\n    ) {\n        this.stopPoll()\n        this.pollInterval = interval\n        this.pollTransform = transform\n        if (typeof exec === \"function\") {\n            this.pollFn = exec\n            delete this.pollExec\n        } else {\n            this.pollExec = exec\n            delete this.pollFn\n        }\n        this.startPoll()\n        return this as unknown as Variable<T>\n    }\n\n    watch(\n        exec: string | string[],\n        transform: (stdout: string, prev: T) => T = out => out as T,\n    ) {\n        this.stopWatch()\n        this.watchExec = exec\n        this.watchTransform = transform\n        this.startWatch()\n        return this as unknown as Variable<T>\n    }\n\n    observe(\n        objs: Array<[obj: Connectable, signal: string]>,\n        callback: (...args: any[]) => T,\n    ): Variable<T>\n\n    observe(\n        obj: Connectable,\n        signal: string,\n        callback: (...args: any[]) => T,\n    ): Variable<T>\n\n    observe(\n        objs: Connectable | Array<[obj: Connectable, signal: string]>,\n        sigOrFn: string | ((obj: Connectable, ...args: any[]) => T),\n        callback?: (obj: Connectable, ...args: any[]) => T,\n    ) {\n        const f = typeof sigOrFn === \"function\" ? sigOrFn : callback ?? (() => this.get())\n        const set = (obj: Connectable, ...args: any[]) => this.set(f(obj, ...args))\n\n        if (Array.isArray(objs)) {\n            for (const obj of objs) {\n                const [o, s] = obj\n                const id = o.connect(s, set)\n                this.onDropped(() => o.disconnect(id))\n            }\n        } else {\n            if (typeof sigOrFn === \"string\") {\n                const id = objs.connect(sigOrFn, set)\n                this.onDropped(() => objs.disconnect(id))\n            }\n        }\n\n        return this as unknown as Variable<T>\n    }\n\n    static derive<\n        const Deps extends Array<Subscribable<any>>,\n        Args extends {\n            [K in keyof Deps]: Deps[K] extends Subscribable<infer T> ? T : never\n        },\n        V = Args,\n    >(deps: Deps, fn: (...args: Args) => V = (...args) => args as unknown as V) {\n        const update = () => fn(...deps.map(d => d.get()) as Args)\n        const derived = new Variable(update())\n        const unsubs = deps.map(dep => dep.subscribe(() => derived.set(update())))\n        derived.onDropped(() => unsubs.map(unsub => unsub()))\n        return derived\n    }\n}\n\nexport interface Variable<T> extends Omit<VariableWrapper<T>, \"bind\"> {\n    <R>(transform: (value: T) => R): Binding<R>\n    (): Binding<T>\n}\n\nexport const Variable = new Proxy(VariableWrapper as any, {\n    apply: (_t, _a, args) => new VariableWrapper(args[0]),\n}) as {\n    derive: typeof VariableWrapper[\"derive\"]\n    <T>(init: T): Variable<T>\n    new<T>(init: T): Variable<T>\n}\n\nexport const { derive } = Variable\nexport default Variable\n", "export const snakeify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replaceAll(\"-\", \"_\")\n    .toLowerCase()\n\nexport const kebabify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replaceAll(\"_\", \"-\")\n    .toLowerCase()\n\nexport interface Subscribable<T = unknown> {\n    subscribe(callback: (value: T) => void): () => void\n    get(): T\n    [key: string]: any\n}\n\nexport interface Connectable {\n    connect(signal: string, callback: (...args: any[]) => unknown): number\n    disconnect(id: number): void\n    [key: string]: any\n}\n\nexport class Binding<Value> {\n    private transformFn = (v: any) => v\n\n    #emitter: Subscribable<Value> | Connectable\n    #prop?: string\n\n    static bind<\n        T extends Connectable,\n        P extends keyof T,\n    >(object: T, property: P): Binding<T[P]>\n\n    static bind<T>(object: Subscribable<T>): Binding<T>\n\n    static bind(emitter: Connectable | Subscribable, prop?: string) {\n        return new Binding(emitter, prop)\n    }\n\n    private constructor(emitter: Connectable | Subscribable<Value>, prop?: string) {\n        this.#emitter = emitter\n        this.#prop = prop && kebabify(prop)\n    }\n\n    toString() {\n        return `Binding<${this.#emitter}${this.#prop ? `, \"${this.#prop}\"` : \"\"}>`\n    }\n\n    as<T>(fn: (v: Value) => T): Binding<T> {\n        const bind = new Binding(this.#emitter, this.#prop)\n        bind.transformFn = (v: Value) => fn(this.transformFn(v))\n        return bind as unknown as Binding<T>\n    }\n\n    get(): Value {\n        if (typeof this.#emitter.get === \"function\")\n            return this.transformFn(this.#emitter.get())\n\n        if (typeof this.#prop === \"string\") {\n            const getter = `get_${snakeify(this.#prop)}`\n            if (typeof this.#emitter[getter] === \"function\")\n                return this.transformFn(this.#emitter[getter]())\n\n            return this.transformFn(this.#emitter[this.#prop])\n        }\n\n        throw Error(\"can not get value of binding\")\n    }\n\n    subscribe(callback: (value: Value) => void): () => void {\n        if (typeof this.#emitter.subscribe === \"function\") {\n            return this.#emitter.subscribe(() => {\n                callback(this.get())\n            })\n        } else if (typeof this.#emitter.connect === \"function\") {\n            const signal = `notify::${this.#prop}`\n            const id = this.#emitter.connect(signal, () => {\n                callback(this.get())\n            })\n            return () => {\n                (this.#emitter.disconnect as Connectable[\"disconnect\"])(id)\n            }\n        }\n        throw Error(`${this.#emitter} is not bindable`)\n    }\n}\n\nexport const { bind } = Binding\nexport default Binding\n", "import Astal from \"gi://AstalIO\"\n\nexport type Time = Astal.Time\nexport const Time = Astal.Time\n\nexport function interval(interval: number, callback?: () => void) {\n    return Astal.Time.interval(interval, () => void callback?.())\n}\n\nexport function timeout(timeout: number, callback?: () => void) {\n    return Astal.Time.timeout(timeout, () => void callback?.())\n}\n\nexport function idle(callback?: () => void) {\n    return Astal.Time.idle(() => void callback?.())\n}\n", "import Astal from \"gi://AstalIO\"\n\ntype Args = {\n    cmd: string | string[]\n    out?: (stdout: string) => void\n    err?: (stderr: string) => void\n}\n\nexport type Process = Astal.Process\nexport const Process = Astal.Process\n\nexport function subprocess(args: Args): Astal.Process\n\nexport function subprocess(\n    cmd: string | string[],\n    onOut?: (stdout: string) => void,\n    onErr?: (stderr: string) => void,\n): Astal.Process\n\nexport function subprocess(\n    argsOrCmd: Args | string | string[],\n    onOut: (stdout: string) => void = print,\n    onErr: (stderr: string) => void = printerr,\n) {\n    const args = Array.isArray(argsOrCmd) || typeof argsOrCmd === \"string\"\n    const { cmd, err, out } = {\n        cmd: args ? argsOrCmd : argsOrCmd.cmd,\n        err: args ? onErr : argsOrCmd.err || onErr,\n        out: args ? onOut : argsOrCmd.out || onOut,\n    }\n\n    const proc = Array.isArray(cmd)\n        ? Astal.Process.subprocessv(cmd)\n        : Astal.Process.subprocess(cmd)\n\n    proc.connect(\"stdout\", (_, stdout: string) => out(stdout))\n    proc.connect(\"stderr\", (_, stderr: string) => err(stderr))\n    return proc\n}\n\n/** @throws {GLib.Error} Throws stderr */\nexport function exec(cmd: string | string[]) {\n    return Array.isArray(cmd)\n        ? Astal.Process.execv(cmd)\n        : Astal.Process.exec(cmd)\n}\n\nexport function execAsync(cmd: string | string[]): Promise<string> {\n    return new Promise((resolve, reject) => {\n        if (Array.isArray(cmd)) {\n            Astal.Process.exec_asyncv(cmd, (_, res) => {\n                try {\n                    resolve(Astal.Process.exec_asyncv_finish(res))\n                } catch (error) {\n                    reject(error)\n                }\n            })\n        } else {\n            Astal.Process.exec_async(cmd, (_, res) => {\n                try {\n                    resolve(Astal.Process.exec_finish(res))\n                } catch (error) {\n                    reject(error)\n                }\n            })\n        }\n    })\n}\n", "import Variable from \"./variable.js\"\nimport { execAsync } from \"./process.js\"\nimport Binding, { Connectable, kebabify, snakeify, Subscribable } from \"./binding.js\"\n\nexport const noImplicitDestroy = Symbol(\"no no implicit destroy\")\nexport const setChildren = Symbol(\"children setter method\")\n\nexport function mergeBindings(array: any[]) {\n    function getValues(...args: any[]) {\n        let i = 0\n        return array.map(value => value instanceof Binding\n            ? args[i++]\n            : value,\n        )\n    }\n\n    const bindings = array.filter(i => i instanceof Binding)\n\n    if (bindings.length === 0)\n        return array\n\n    if (bindings.length === 1)\n        return bindings[0].as(getValues)\n\n    return Variable.derive(bindings, getValues)()\n}\n\nexport function setProp(obj: any, prop: string, value: any) {\n    try {\n        const setter = `set_${snakeify(prop)}`\n        if (typeof obj[setter] === \"function\")\n            return obj[setter](value)\n\n        return (obj[prop] = value)\n    } catch (error) {\n        console.error(`could not set property \"${prop}\" on ${obj}:`, error)\n    }\n}\n\nexport type BindableProps<T> = {\n    [K in keyof T]: Binding<T[K]> | T[K];\n}\n\nexport function hook<Widget extends Connectable>(\n    widget: Widget,\n    object: Connectable | Subscribable,\n    signalOrCallback: string | ((self: Widget, ...args: any[]) => void),\n    callback?: (self: Widget, ...args: any[]) => void,\n) {\n    if (typeof object.connect === \"function\" && callback) {\n        const id = object.connect(signalOrCallback, (_: any, ...args: unknown[]) => {\n            return callback(widget, ...args)\n        })\n        widget.connect(\"destroy\", () => {\n            (object.disconnect as Connectable[\"disconnect\"])(id)\n        })\n    } else if (typeof object.subscribe === \"function\" && typeof signalOrCallback === \"function\") {\n        const unsub = object.subscribe((...args: unknown[]) => {\n            signalOrCallback(widget, ...args)\n        })\n        widget.connect(\"destroy\", unsub)\n    }\n}\n\nexport function construct<Widget extends Connectable & { [setChildren]: (children: any[]) => void }>(widget: Widget, config: any) {\n    // eslint-disable-next-line prefer-const\n    let { setup, child, children = [], ...props } = config\n\n    if (children instanceof Binding) {\n        children = [children]\n    }\n\n    if (child) {\n        children.unshift(child)\n    }\n\n    // remove undefined values\n    for (const [key, value] of Object.entries(props)) {\n        if (value === undefined) {\n            delete props[key]\n        }\n    }\n\n    // collect bindings\n    const bindings: Array<[string, Binding<any>]> = Object\n        .keys(props)\n        .reduce((acc: any, prop) => {\n            if (props[prop] instanceof Binding) {\n                const binding = props[prop]\n                delete props[prop]\n                return [...acc, [prop, binding]]\n            }\n            return acc\n        }, [])\n\n    // collect signal handlers\n    const onHandlers: Array<[string, string | (() => unknown)]> = Object\n        .keys(props)\n        .reduce((acc: any, key) => {\n            if (key.startsWith(\"on\")) {\n                const sig = kebabify(key).split(\"-\").slice(1).join(\"-\")\n                const handler = props[key]\n                delete props[key]\n                return [...acc, [sig, handler]]\n            }\n            return acc\n        }, [])\n\n    // set children\n    const mergedChildren = mergeBindings(children.flat(Infinity))\n    if (mergedChildren instanceof Binding) {\n        widget[setChildren](mergedChildren.get())\n        widget.connect(\"destroy\", mergedChildren.subscribe((v) => {\n            widget[setChildren](v)\n        }))\n    } else {\n        if (mergedChildren.length > 0) {\n            widget[setChildren](mergedChildren)\n        }\n    }\n\n    // setup signal handlers\n    for (const [signal, callback] of onHandlers) {\n        const sig = signal.startsWith(\"notify\")\n            ? signal.replace(\"-\", \"::\")\n            : signal\n\n        if (typeof callback === \"function\") {\n            widget.connect(sig, callback)\n        } else {\n            widget.connect(sig, () => execAsync(callback)\n                .then(print).catch(console.error))\n        }\n    }\n\n    // setup bindings handlers\n    for (const [prop, binding] of bindings) {\n        if (prop === \"child\" || prop === \"children\") {\n            widget.connect(\"destroy\", binding.subscribe((v: any) => {\n                widget[setChildren](v)\n            }))\n        }\n        widget.connect(\"destroy\", binding.subscribe((v: any) => {\n            setProp(widget, prop, v)\n        }))\n        setProp(widget, prop, binding.get())\n    }\n\n    // filter undefined values\n    for (const [key, value] of Object.entries(props)) {\n        if (value === undefined) {\n            delete props[key]\n        }\n    }\n\n    Object.assign(widget, props)\n    setup?.(widget)\n    return widget\n}\n\nfunction isArrowFunction(func: any): func is (args: any) => any {\n    return !Object.hasOwn(func, \"prototype\")\n}\n\nexport function jsx(\n    ctors: Record<string, { new(props: any): any } | ((props: any) => any)>,\n    ctor: string | ((props: any) => any) | { new(props: any): any },\n    { children, ...props }: any,\n) {\n    children ??= []\n\n    if (!Array.isArray(children))\n        children = [children]\n\n    children = children.filter(Boolean)\n\n    if (children.length === 1)\n        props.child = children[0]\n    else if (children.length > 1)\n        props.children = children\n\n    if (typeof ctor === \"string\") {\n        if (isArrowFunction(ctors[ctor]))\n            return ctors[ctor](props)\n\n        return new ctors[ctor](props)\n    }\n\n    if (isArrowFunction(ctor))\n        return ctor(props)\n\n    return new ctor(props)\n}\n", "import { hook, noImplicitDestroy, setChildren, mergeBindings, type BindableProps, construct } from \"../_astal.js\"\nimport Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport Gdk from \"gi://Gdk?version=3.0\"\nimport GObject from \"gi://GObject\"\nimport Gio from \"gi://Gio?version=2.0\"\nimport Binding, { type Connectable, type Subscribable } from \"../binding.js\"\n\nexport { BindableProps, mergeBindings }\n\nexport default function astalify<\n    C extends { new(...args: any[]): Gtk.Widget },\n>(cls: C, clsName = cls.name) {\n    class Widget extends cls {\n        get css(): string { return Astal.widget_get_css(this) }\n        set css(css: string) { Astal.widget_set_css(this, css) }\n        get_css(): string { return this.css }\n        set_css(css: string) { this.css = css }\n\n        get className(): string { return Astal.widget_get_class_names(this).join(\" \") }\n        set className(className: string) { Astal.widget_set_class_names(this, className.split(/\\s+/)) }\n        get_class_name(): string { return this.className }\n        set_class_name(className: string) { this.className = className }\n\n        get cursor(): Cursor { return Astal.widget_get_cursor(this) as Cursor }\n        set cursor(cursor: Cursor) { Astal.widget_set_cursor(this, cursor) }\n        get_cursor(): Cursor { return this.cursor }\n        set_cursor(cursor: Cursor) { this.cursor = cursor }\n\n        get clickThrough(): boolean { return Astal.widget_get_click_through(this) }\n        set clickThrough(clickThrough: boolean) { Astal.widget_set_click_through(this, clickThrough) }\n        get_click_through(): boolean { return this.clickThrough }\n        set_click_through(clickThrough: boolean) { this.clickThrough = clickThrough }\n\n        declare private [noImplicitDestroy]: boolean\n        get noImplicitDestroy(): boolean { return this[noImplicitDestroy] }\n        set noImplicitDestroy(value: boolean) { this[noImplicitDestroy] = value }\n\n        set actionGroup([prefix, group]: ActionGroup) { this.insert_action_group(prefix, group) }\n        set_action_group(actionGroup: ActionGroup) { this.actionGroup = actionGroup }\n\n        protected getChildren(): Array<Gtk.Widget> {\n            if (this instanceof Gtk.Bin) {\n                return this.get_child() ? [this.get_child()!] : []\n            } else if (this instanceof Gtk.Container) {\n                return this.get_children()\n            }\n            return []\n        }\n\n        protected setChildren(children: any[]) {\n            children = children.flat(Infinity).map(ch => ch instanceof Gtk.Widget\n                ? ch\n                : new Gtk.Label({ visible: true, label: String(ch) }))\n\n            if (this instanceof Gtk.Container) {\n                for (const ch of children)\n                    this.add(ch)\n            } else {\n                throw Error(`can not add children to ${this.constructor.name}`)\n            }\n        }\n\n        [setChildren](children: any[]) {\n            // remove\n            if (this instanceof Gtk.Container) {\n                for (const ch of this.getChildren()) {\n                    this.remove(ch)\n                    if (!children.includes(ch) && !this.noImplicitDestroy)\n                        ch?.destroy()\n                }\n            }\n\n            // append\n            this.setChildren(children)\n        }\n\n        toggleClassName(cn: string, cond = true) {\n            Astal.widget_toggle_class_name(this, cn, cond)\n        }\n\n        hook(\n            object: Connectable,\n            signal: string,\n            callback: (self: this, ...args: any[]) => void,\n        ): this\n        hook(\n            object: Subscribable,\n            callback: (self: this, ...args: any[]) => void,\n        ): this\n        hook(\n            object: Connectable | Subscribable,\n            signalOrCallback: string | ((self: this, ...args: any[]) => void),\n            callback?: (self: this, ...args: any[]) => void,\n        ) {\n            hook(this, object, signalOrCallback, callback)\n            return this\n        }\n\n        constructor(...params: any[]) {\n            super()\n            const props = params[0] || {}\n            props.visible ??= true\n            construct(this, props)\n        }\n    }\n\n    GObject.registerClass({\n        GTypeName: `Astal_${clsName}`,\n        Properties: {\n            \"class-name\": GObject.ParamSpec.string(\n                \"class-name\", \"\", \"\", GObject.ParamFlags.READWRITE, \"\",\n            ),\n            \"css\": GObject.ParamSpec.string(\n                \"css\", \"\", \"\", GObject.ParamFlags.READWRITE, \"\",\n            ),\n            \"cursor\": GObject.ParamSpec.string(\n                \"cursor\", \"\", \"\", GObject.ParamFlags.READWRITE, \"default\",\n            ),\n            \"click-through\": GObject.ParamSpec.boolean(\n                \"click-through\", \"\", \"\", GObject.ParamFlags.READWRITE, false,\n            ),\n            \"no-implicit-destroy\": GObject.ParamSpec.boolean(\n                \"no-implicit-destroy\", \"\", \"\", GObject.ParamFlags.READWRITE, false,\n            ),\n        },\n    }, Widget)\n\n    return Widget\n}\n\ntype SigHandler<\n    W extends InstanceType<typeof Gtk.Widget>,\n    Args extends Array<unknown>,\n> = ((self: W, ...args: Args) => unknown) | string | string[]\n\nexport type BindableChild = Gtk.Widget | Binding<Gtk.Widget>\n\nexport type ConstructProps<\n    Self extends InstanceType<typeof Gtk.Widget>,\n    Props extends Gtk.Widget.ConstructorProps,\n    Signals extends Record<`on${string}`, Array<unknown>> = Record<`on${string}`, any[]>,\n> = Partial<{\n    // @ts-expect-error can't assign to unknown, but it works as expected though\n    [S in keyof Signals]: SigHandler<Self, Signals[S]>\n}> & Partial<{\n    [Key in `on${string}`]: SigHandler<Self, any[]>\n}> & BindableProps<Partial<Props & {\n    className?: string\n    css?: string\n    cursor?: string\n    clickThrough?: boolean\n    actionGroup?: ActionGroup\n}>> & Partial<{\n    onDestroy: (self: Self) => unknown\n    onDraw: (self: Self) => unknown\n    onKeyPressEvent: (self: Self, event: Gdk.Event) => unknown\n    onKeyReleaseEvent: (self: Self, event: Gdk.Event) => unknown\n    onButtonPressEvent: (self: Self, event: Gdk.Event) => unknown\n    onButtonReleaseEvent: (self: Self, event: Gdk.Event) => unknown\n    onRealize: (self: Self) => unknown\n    setup: (self: Self) => void\n}>\n\ntype Cursor =\n    | \"default\"\n    | \"help\"\n    | \"pointer\"\n    | \"context-menu\"\n    | \"progress\"\n    | \"wait\"\n    | \"cell\"\n    | \"crosshair\"\n    | \"text\"\n    | \"vertical-text\"\n    | \"alias\"\n    | \"copy\"\n    | \"no-drop\"\n    | \"move\"\n    | \"not-allowed\"\n    | \"grab\"\n    | \"grabbing\"\n    | \"all-scroll\"\n    | \"col-resize\"\n    | \"row-resize\"\n    | \"n-resize\"\n    | \"e-resize\"\n    | \"s-resize\"\n    | \"w-resize\"\n    | \"ne-resize\"\n    | \"nw-resize\"\n    | \"sw-resize\"\n    | \"se-resize\"\n    | \"ew-resize\"\n    | \"ns-resize\"\n    | \"nesw-resize\"\n    | \"nwse-resize\"\n    | \"zoom-in\"\n    | \"zoom-out\"\n\ntype ActionGroup = [prefix: string, actionGroup: Gio.ActionGroup]\n", "import Gtk from \"gi://Gtk?version=3.0\"\nimport Astal from \"gi://Astal?version=3.0\"\nimport { mkApp } from \"../_app\"\n\nGtk.init(null)\n\nexport default mkApp(Astal.Application)\n", "/**\n * Workaround for \"Can't convert non-null pointer to JS value \"\n */\n\nexport { }\n\nconst snakeify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replaceAll(\"-\", \"_\")\n    .toLowerCase()\n\nasync function suppress<T>(mod: Promise<{ default: T }>, patch: (m: T) => void) {\n    return mod.then(m => patch(m.default)).catch(() => void 0)\n}\n\nfunction patch<P extends object>(proto: P, prop: Extract<keyof P, string>) {\n    Object.defineProperty(proto, prop, {\n        get() { return this[`get_${snakeify(prop)}`]() },\n    })\n}\n\nawait suppress(import(\"gi://AstalApps\"), ({ Apps, Application }) => {\n    patch(Apps.prototype, \"list\")\n    patch(Application.prototype, \"keywords\")\n    patch(Application.prototype, \"categories\")\n})\n\nawait suppress(import(\"gi://AstalBattery\"), ({ UPower }) => {\n    patch(UPower.prototype, \"devices\")\n})\n\nawait suppress(import(\"gi://AstalBluetooth\"), ({ Adapter, Bluetooth, Device }) => {\n    patch(Adapter.prototype, \"uuids\")\n    patch(Bluetooth.prototype, \"adapters\")\n    patch(Bluetooth.prototype, \"devices\")\n    patch(Device.prototype, \"uuids\")\n})\n\nawait suppress(import(\"gi://AstalHyprland\"), ({ Hyprland, Monitor, Workspace }) => {\n    patch(Hyprland.prototype, \"monitors\")\n    patch(Hyprland.prototype, \"workspaces\")\n    patch(Hyprland.prototype, \"clients\")\n    patch(Monitor.prototype, \"availableModes\")\n    patch(Monitor.prototype, \"available_modes\")\n    patch(Workspace.prototype, \"clients\")\n})\n\nawait suppress(import(\"gi://AstalMpris\"), ({ Mpris, Player }) => {\n    patch(Mpris.prototype, \"players\")\n    patch(Player.prototype, \"supported_uri_schemes\")\n    patch(Player.prototype, \"supportedUriSchemes\")\n    patch(Player.prototype, \"supported_mime_types\")\n    patch(Player.prototype, \"supportedMimeTypes\")\n    patch(Player.prototype, \"comments\")\n})\n\nawait suppress(import(\"gi://AstalNetwork\"), ({ Wifi }) => {\n    patch(Wifi.prototype, \"access_points\")\n    patch(Wifi.prototype, \"accessPoints\")\n})\n\nawait suppress(import(\"gi://AstalNotifd\"), ({ Notifd, Notification }) => {\n    patch(Notifd.prototype, \"notifications\")\n    patch(Notification.prototype, \"actions\")\n})\n\nawait suppress(import(\"gi://AstalPowerProfiles\"), ({ PowerProfiles }) => {\n    patch(PowerProfiles.prototype, \"actions\")\n})\n\nawait suppress(import(\"gi://AstalWp\"), ({ Wp, Audio, Video }) => {\n    patch(Wp.prototype, \"endpoints\")\n    patch(Wp.prototype, \"devices\")\n    patch(Audio.prototype, \"streams\")\n    patch(Audio.prototype, \"recorders\")\n    patch(Audio.prototype, \"microphones\")\n    patch(Audio.prototype, \"speakers\")\n    patch(Audio.prototype, \"devices\")\n    patch(Video.prototype, \"streams\")\n    patch(Video.prototype, \"recorders\")\n    patch(Video.prototype, \"sinks\")\n    patch(Video.prototype, \"sources\")\n    patch(Video.prototype, \"devices\")\n})\n", "import \"./overrides.js\"\nimport { setConsoleLogDomain } from \"console\"\nimport { exit, programArgs } from \"system\"\nimport IO from \"gi://AstalIO\"\nimport GObject from \"gi://GObject\"\nimport Gio from \"gi://Gio?version=2.0\"\nimport type Astal3 from \"gi://Astal?version=3.0\"\nimport type Astal4 from \"gi://Astal?version=4.0\"\n\ntype Config = Partial<{\n    instanceName: string\n    css: string\n    icons: string\n    gtkTheme: string\n    iconTheme: string\n    cursorTheme: string\n    hold: boolean\n    requestHandler(request: string, res: (response: any) => void): void\n    main(...args: string[]): void\n    client(message: (msg: string) => string, ...args: string[]): void\n}>\n\ninterface Astal3JS extends Astal3.Application {\n    eval(body: string): Promise<any>\n    requestHandler: Config[\"requestHandler\"]\n    apply_css(style: string, reset?: boolean): void\n    quit(code?: number): void\n    start(config?: Config): void\n}\n\ninterface Astal4JS extends Astal4.Application {\n    eval(body: string): Promise<any>\n    requestHandler?: Config[\"requestHandler\"]\n    apply_css(style: string, reset?: boolean): void\n    quit(code?: number): void\n    start(config?: Config): void\n}\n\ntype App3 = typeof Astal3.Application\ntype App4 = typeof Astal4.Application\n\nexport function mkApp<App extends App3>(App: App): Astal3JS\nexport function mkApp<App extends App4>(App: App): Astal4JS\n\nexport function mkApp(App: App3 | App4) {\n    return new (class AstalJS extends App {\n        static { GObject.registerClass({ GTypeName: \"AstalJS\" }, this as any) }\n\n        eval(body: string): Promise<any> {\n            return new Promise((res, rej) => {\n                try {\n                    const fn = Function(`return (async function() {\n                        ${body.includes(\";\") ? body : `return ${body};`}\n                    })`)\n                    fn()().then(res).catch(rej)\n                } catch (error) {\n                    rej(error)\n                }\n            })\n        }\n\n        requestHandler?: Config[\"requestHandler\"]\n\n        vfunc_request(msg: string, conn: Gio.SocketConnection): void {\n            if (typeof this.requestHandler === \"function\") {\n                this.requestHandler(msg, (response) => {\n                    IO.write_sock(conn, String(response), (_, res) =>\n                        IO.write_sock_finish(res),\n                    )\n                })\n            } else {\n                super.vfunc_request(msg, conn)\n            }\n        }\n\n        apply_css(style: string, reset = false) {\n            super.apply_css(style, reset)\n        }\n\n        quit(code?: number): void {\n            super.quit()\n            exit(code ?? 0)\n        }\n\n        start({ requestHandler, css, hold, main, client, icons, ...cfg }: Config = {}) {\n            const app = this as unknown as InstanceType<App3 | App4>\n\n            client ??= () => {\n                print(`Astal instance \"${app.instanceName}\" already running`)\n                exit(1)\n            }\n\n            Object.assign(this, cfg)\n            setConsoleLogDomain(app.instanceName)\n\n            this.requestHandler = requestHandler\n            app.connect(\"activate\", () => {\n                main?.(...programArgs)\n            })\n\n            try {\n                app.acquire_socket()\n            } catch (error) {\n                return client(msg => IO.send_message(app.instanceName, msg)!, ...programArgs)\n            }\n\n            if (css)\n                this.apply_css(css, false)\n\n            if (icons)\n                app.add_icons(icons)\n\n            hold ??= true\n            if (hold)\n                app.hold()\n\n            app.runAsync([])\n        }\n    })\n}\n", "/* eslint-disable max-len */\nimport Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport GObject from \"gi://GObject\"\nimport astalify, { type ConstructProps, type BindableChild } from \"./astalify.js\"\n\nfunction filter(children: any[]) {\n    return children.flat(Infinity).map(ch => ch instanceof Gtk.Widget\n        ? ch\n        : new Gtk.Label({ visible: true, label: String(ch) }))\n}\n\n// Box\nObject.defineProperty(Astal.Box.prototype, \"children\", {\n    get() { return this.get_children() },\n    set(v) { this.set_children(v) },\n})\n\nexport type BoxProps = ConstructProps<Box, Astal.Box.ConstructorProps>\nexport class Box extends astalify(Astal.Box) {\n    static { GObject.registerClass({ GTypeName: \"Box\" }, this) }\n    constructor(props?: BoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void { this.set_children(filter(children)) }\n}\n\n// Button\nexport type ButtonProps = ConstructProps<Button, Astal.Button.ConstructorProps, {\n    onClicked: []\n    onClick: [event: Astal.ClickEvent]\n    onClickRelease: [event: Astal.ClickEvent]\n    onHover: [event: Astal.HoverEvent]\n    onHoverLost: [event: Astal.HoverEvent]\n    onScroll: [event: Astal.ScrollEvent]\n}>\nexport class Button extends astalify(Astal.Button) {\n    static { GObject.registerClass({ GTypeName: \"Button\" }, this) }\n    constructor(props?: ButtonProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// CenterBox\nexport type CenterBoxProps = ConstructProps<CenterBox, Astal.CenterBox.ConstructorProps>\nexport class CenterBox extends astalify(Astal.CenterBox) {\n    static { GObject.registerClass({ GTypeName: \"CenterBox\" }, this) }\n    constructor(props?: CenterBoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void {\n        const ch = filter(children)\n        this.startWidget = ch[0] || new Gtk.Box\n        this.centerWidget = ch[1] || new Gtk.Box\n        this.endWidget = ch[2] || new Gtk.Box\n    }\n}\n\n// CircularProgress\nexport type CircularProgressProps = ConstructProps<CircularProgress, Astal.CircularProgress.ConstructorProps>\nexport class CircularProgress extends astalify(Astal.CircularProgress) {\n    static { GObject.registerClass({ GTypeName: \"CircularProgress\" }, this) }\n    constructor(props?: CircularProgressProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// DrawingArea\nexport type DrawingAreaProps = ConstructProps<DrawingArea, Gtk.DrawingArea.ConstructorProps, {\n    onDraw: [cr: any] // TODO: cairo types\n}>\nexport class DrawingArea extends astalify(Gtk.DrawingArea) {\n    static { GObject.registerClass({ GTypeName: \"DrawingArea\" }, this) }\n    constructor(props?: DrawingAreaProps) { super(props as any) }\n}\n\n// Entry\nexport type EntryProps = ConstructProps<Entry, Gtk.Entry.ConstructorProps, {\n    onChanged: []\n    onActivate: []\n}>\nexport class Entry extends astalify(Gtk.Entry) {\n    static { GObject.registerClass({ GTypeName: \"Entry\" }, this) }\n    constructor(props?: EntryProps) { super(props as any) }\n}\n\n// EventBox\nexport type EventBoxProps = ConstructProps<EventBox, Astal.EventBox.ConstructorProps, {\n    onClick: [event: Astal.ClickEvent]\n    onClickRelease: [event: Astal.ClickEvent]\n    onHover: [event: Astal.HoverEvent]\n    onHoverLost: [event: Astal.HoverEvent]\n    onScroll: [event: Astal.ScrollEvent]\n}>\nexport class EventBox extends astalify(Astal.EventBox) {\n    static { GObject.registerClass({ GTypeName: \"EventBox\" }, this) }\n    constructor(props?: EventBoxProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// // TODO: Fixed\n// // TODO: FlowBox\n//\n// Icon\nexport type IconProps = ConstructProps<Icon, Astal.Icon.ConstructorProps>\nexport class Icon extends astalify(Astal.Icon) {\n    static { GObject.registerClass({ GTypeName: \"Icon\" }, this) }\n    constructor(props?: IconProps) { super(props as any) }\n}\n\n// Label\nexport type LabelProps = ConstructProps<Label, Astal.Label.ConstructorProps>\nexport class Label extends astalify(Astal.Label) {\n    static { GObject.registerClass({ GTypeName: \"Label\" }, this) }\n    constructor(props?: LabelProps) { super(props as any) }\n    protected setChildren(children: any[]): void { this.label = String(children) }\n}\n\n// LevelBar\nexport type LevelBarProps = ConstructProps<LevelBar, Astal.LevelBar.ConstructorProps>\nexport class LevelBar extends astalify(Astal.LevelBar) {\n    static { GObject.registerClass({ GTypeName: \"LevelBar\" }, this) }\n    constructor(props?: LevelBarProps) { super(props as any) }\n}\n\n// TODO: ListBox\n\n// MenuButton\nexport type MenuButtonProps = ConstructProps<MenuButton, Gtk.MenuButton.ConstructorProps>\nexport class MenuButton extends astalify(Gtk.MenuButton) {\n    static { GObject.registerClass({ GTypeName: \"MenuButton\" }, this) }\n    constructor(props?: MenuButtonProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Overlay\nObject.defineProperty(Astal.Overlay.prototype, \"overlays\", {\n    get() { return this.get_overlays() },\n    set(v) { this.set_overlays(v) },\n})\n\nexport type OverlayProps = ConstructProps<Overlay, Astal.Overlay.ConstructorProps>\nexport class Overlay extends astalify(Astal.Overlay) {\n    static { GObject.registerClass({ GTypeName: \"Overlay\" }, this) }\n    constructor(props?: OverlayProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void {\n        const [child, ...overlays] = filter(children)\n        this.set_child(child)\n        this.set_overlays(overlays)\n    }\n}\n\n// Revealer\nexport type RevealerProps = ConstructProps<Revealer, Gtk.Revealer.ConstructorProps>\nexport class Revealer extends astalify(Gtk.Revealer) {\n    static { GObject.registerClass({ GTypeName: \"Revealer\" }, this) }\n    constructor(props?: RevealerProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Scrollable\nexport type ScrollableProps = ConstructProps<Scrollable, Astal.Scrollable.ConstructorProps>\nexport class Scrollable extends astalify(Astal.Scrollable) {\n    static { GObject.registerClass({ GTypeName: \"Scrollable\" }, this) }\n    constructor(props?: ScrollableProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Slider\nexport type SliderProps = ConstructProps<Slider, Astal.Slider.ConstructorProps, {\n    onDragged: []\n}>\nexport class Slider extends astalify(Astal.Slider) {\n    static { GObject.registerClass({ GTypeName: \"Slider\" }, this) }\n    constructor(props?: SliderProps) { super(props as any) }\n}\n\n// Stack\nexport type StackProps = ConstructProps<Stack, Astal.Stack.ConstructorProps>\nexport class Stack extends astalify(Astal.Stack) {\n    static { GObject.registerClass({ GTypeName: \"Stack\" }, this) }\n    constructor(props?: StackProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void { this.set_children(filter(children)) }\n}\n\n// Switch\nexport type SwitchProps = ConstructProps<Switch, Gtk.Switch.ConstructorProps>\nexport class Switch extends astalify(Gtk.Switch) {\n    static { GObject.registerClass({ GTypeName: \"Switch\" }, this) }\n    constructor(props?: SwitchProps) { super(props as any) }\n}\n\n// Window\nexport type WindowProps = ConstructProps<Window, Astal.Window.ConstructorProps>\nexport class Window extends astalify(Astal.Window) {\n    static { GObject.registerClass({ GTypeName: \"Window\" }, this) }\n    constructor(props?: WindowProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n", "window {\n  background: #191919;\n  color: #E0DBF0;\n  font-family: comfortaa;\n  font-weight: bolder;\n}\nwindow > centerbox {\n  background: #191919;\n}\n\nbutton {\n  animation: none;\n  background: transparent;\n  color: #FFFFFF;\n  padding: 0;\n}\nbutton > label {\n  transition: ease-out 0.2s;\n  margin: 4px 8px 4px 8px;\n  padding: 0 8px 0 8px;\n  border-radius: 10px;\n  color: #FFFFFF;\n}\nbutton.selected > label {\n  background: #CD1D48;\n}\nbutton:hover {\n  color: transparent;\n}\nbutton:hover > label {\n  background: #515151;\n}\nbutton:hover.selected > label {\n  background: #FF5580;\n}\n\n.workspaces {\n  padding: 0 20px 0 20px;\n}\n\n.workspaceContainer {\n  min-width: 32px;\n  padding: 0;\n  margin: 0;\n}\n\n.workspaceBg {\n  background: #191919;\n  border: 2px solid #FFFFFF;\n  border-radius: 100%;\n}\n\n.workspaceIndicator {\n  transition: all cubic-bezier(0.34, 1.4, 0.64, 1) 0.4s;\n  background: #FFFFFF;\n  min-width: 24px;\n  min-height: 4px;\n  border-radius: 4px;\n}\n\n.workspaceButton {\n  background: #191919;\n  padding: 0;\n  margin: 0;\n}\n.workspaceButton > box {\n  transition: all ease-out 0.1s;\n  margin: 2px 2px 6px 2px;\n  border-radius: 8px;\n}\n.workspaceButton > box > box {\n  margin-left: 6px;\n  transition: ease-out 0.2s;\n  min-width: 8px;\n  min-height: 8px;\n  border-radius: 100%;\n  border: solid 4px;\n  color: #FFFFFF;\n}\n.workspaceButton > box > box.active {\n  min-width: 0px;\n  min-height: 0px;\n  border-width: 8px;\n}\n.workspaceButton > box > box.focused {\n  min-width: 6px;\n  min-height: 6px;\n}\n.workspaceButton:hover {\n  color: #191919;\n}\n.workspaceButton:hover > box {\n  background: #515151;\n}\n\n.popupWindow {\n  background: transparent;\n}\n.popupWindow > box {\n  background: #191919;\n  border-radius: 8px;\n  box-shadow: 0 0 10px 4px black;\n  padding: 8px;\n  margin: 48px 20px 20px 12px;\n}\n\n.popupBattery {\n  min-height: 200px;\n  min-width: 152px;\n}\n.popupBattery .percentage {\n  color: #FFFFFF;\n  background: #191919;\n  border-radius: 6px;\n  padding: 4px 6px 4px 6px;\n  box-shadow: 0 0 5px -1px black;\n}\n.popupBattery levelbar block {\n  background: #00FFAA;\n  border-radius: 8px;\n}\n.popupBattery levelbar block.empty {\n  background: #515151;\n}\n.popupBattery .info {\n  min-height: 96px;\n  min-width: 96px;\n  background: #515151;\n  border-radius: 8px;\n}\n\n.batteryLevel {\n  background: green;\n  color: green;\n  min-height: 100px;\n  margin-top: 50px;\n  border: 20px solid red;\n}\n\n.battIcon {\n  font-size: 20px;\n}", "import \"./overrides.js\"\nexport { default as AstalIO } from \"gi://AstalIO?version=0.1\"\nexport * from \"./process.js\"\nexport * from \"./time.js\"\nexport * from \"./file.js\"\nexport * from \"./gobject.js\"\nexport { Binding, bind } from \"./binding.js\"\nexport { Variable, derive } from \"./variable.js\"\n", "import Astal from \"gi://AstalIO\"\nimport Gio from \"gi://Gio?version=2.0\"\n\nexport { Gio }\n\nexport function readFile(path: string): string {\n    return Astal.read_file(path) || \"\"\n}\n\nexport function readFileAsync(path: string): Promise<string> {\n    return new Promise((resolve, reject) => {\n        Astal.read_file_async(path, (_, res) => {\n            try {\n                resolve(Astal.read_file_finish(res) || \"\")\n            } catch (error) {\n                reject(error)\n            }\n        })\n    })\n}\n\nexport function writeFile(path: string, content: string): void {\n    Astal.write_file(path, content)\n}\n\nexport function writeFileAsync(path: string, content: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n        Astal.write_file_async(path, content, (_, res) => {\n            try {\n                resolve(Astal.write_file_finish(res))\n            } catch (error) {\n                reject(error)\n            }\n        })\n    })\n}\n\nexport function monitorFile(\n    path: string,\n    callback: (file: string, event: Gio.FileMonitorEvent) => void,\n): Gio.FileMonitor {\n    return Astal.monitor_file(path, (file: string, event: Gio.FileMonitorEvent) => {\n        callback(file, event)\n    })!\n}\n", "import GObject from \"gi://GObject\"\n\nexport { default as GLib } from \"gi://GLib?version=2.0\"\nexport { GObject, GObject as default }\n\nconst meta = Symbol(\"meta\")\nconst priv = Symbol(\"priv\")\n\nconst { ParamSpec, ParamFlags } = GObject\n\nconst kebabify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replaceAll(\"_\", \"-\")\n    .toLowerCase()\n\ntype SignalDeclaration = {\n    flags?: GObject.SignalFlags\n    accumulator?: GObject.AccumulatorType\n    return_type?: GObject.GType\n    param_types?: Array<GObject.GType>\n}\n\ntype PropertyDeclaration =\n    | InstanceType<typeof GObject.ParamSpec>\n    | { $gtype: GObject.GType }\n    | typeof String\n    | typeof Number\n    | typeof Boolean\n    | typeof Object\n\ntype GObjectConstructor = {\n    [meta]?: {\n        Properties?: { [key: string]: GObject.ParamSpec }\n        Signals?: { [key: string]: GObject.SignalDefinition }\n    }\n    new(...args: any[]): any\n}\n\ntype MetaInfo = GObject.MetaInfo<never, Array<{ $gtype: GObject.GType }>, never>\n\nexport function register(options: MetaInfo = {}) {\n    return function (cls: GObjectConstructor) {\n        const t = options.Template\n        if (typeof t === \"string\" && !t.startsWith(\"resource://\") && !t.startsWith(\"file://\")) {\n            // assume xml template\n            options.Template = new TextEncoder().encode(t)\n        }\n\n        GObject.registerClass({\n            Signals: { ...cls[meta]?.Signals },\n            Properties: { ...cls[meta]?.Properties },\n            ...options,\n        }, cls)\n\n        delete cls[meta]\n    }\n}\n\nexport function property(declaration: PropertyDeclaration = Object) {\n    return function (target: any, prop: any, desc?: PropertyDescriptor) {\n        target.constructor[meta] ??= {}\n        target.constructor[meta].Properties ??= {}\n\n        const name = kebabify(prop)\n\n        if (!desc) {\n            Object.defineProperty(target, prop, {\n                get() {\n                    return this[priv]?.[prop] ?? defaultValue(declaration)\n                },\n                set(v: any) {\n                    if (v !== this[prop]) {\n                        this[priv] ??= {}\n                        this[priv][prop] = v\n                        this.notify(name)\n                    }\n                },\n            })\n\n            Object.defineProperty(target, `set_${name.replace(\"-\", \"_\")}`, {\n                value(v: any) {\n                    this[prop] = v\n                },\n            })\n\n            Object.defineProperty(target, `get_${name.replace(\"-\", \"_\")}`, {\n                value() {\n                    return this[prop]\n                },\n            })\n\n            target.constructor[meta].Properties[kebabify(prop)] = pspec(name, ParamFlags.READWRITE, declaration)\n        } else {\n            let flags = 0\n            if (desc.get) flags |= ParamFlags.READABLE\n            if (desc.set) flags |= ParamFlags.WRITABLE\n\n            target.constructor[meta].Properties[kebabify(prop)] = pspec(name, flags, declaration)\n        }\n    }\n}\n\nexport function signal(...params: Array<{ $gtype: GObject.GType } | typeof Object>):\n(target: any, signal: any, desc?: PropertyDescriptor) => void\n\nexport function signal(declaration?: SignalDeclaration):\n(target: any, signal: any, desc?: PropertyDescriptor) => void\n\nexport function signal(\n    declaration?: SignalDeclaration | { $gtype: GObject.GType } | typeof Object,\n    ...params: Array<{ $gtype: GObject.GType } | typeof Object>\n) {\n    return function (target: any, signal: any, desc?: PropertyDescriptor) {\n        target.constructor[meta] ??= {}\n        target.constructor[meta].Signals ??= {}\n\n        const name = kebabify(signal)\n\n        if (declaration || params.length > 0) {\n            // @ts-expect-error TODO: type assert\n            const arr = [declaration, ...params].map(v => v.$gtype)\n            target.constructor[meta].Signals[name] = {\n                param_types: arr,\n            }\n        } else {\n            target.constructor[meta].Signals[name] = declaration || {\n                param_types: [],\n            }\n        }\n\n        if (!desc) {\n            Object.defineProperty(target, signal, {\n                value: function (...args: any[]) {\n                    this.emit(name, ...args)\n                },\n            })\n        } else {\n            const og: ((...args: any[]) => void) = desc.value\n            desc.value = function (...args: any[]) {\n                // @ts-expect-error not typed\n                this.emit(name, ...args)\n            }\n            Object.defineProperty(target, `on_${name.replace(\"-\", \"_\")}`, {\n                value: function (...args: any[]) {\n                    return og(...args)\n                },\n            })\n        }\n    }\n}\n\nfunction pspec(name: string, flags: number, declaration: PropertyDeclaration) {\n    if (declaration instanceof ParamSpec)\n        return declaration\n\n    switch (declaration) {\n        case String:\n            return ParamSpec.string(name, \"\", \"\", flags, \"\")\n        case Number:\n            return ParamSpec.double(name, \"\", \"\", flags, -Number.MAX_VALUE, Number.MAX_VALUE, 0)\n        case Boolean:\n            return ParamSpec.boolean(name, \"\", \"\", flags, false)\n        case Object:\n            return ParamSpec.jsobject(name, \"\", \"\", flags)\n        default:\n            // @ts-expect-error misstyped\n            return ParamSpec.object(name, \"\", \"\", flags, declaration.$gtype)\n    }\n}\n\nfunction defaultValue(declaration: PropertyDeclaration) {\n    if (declaration instanceof ParamSpec)\n        return declaration.get_default_value()\n\n    switch (declaration) {\n        case String:\n            return \"\"\n        case Number:\n            return 0\n        case Boolean:\n            return false\n        case Object:\n        default:\n            return null\n    }\n}\n", "import { bind, Gio } from \"astal\"\nimport Battery from \"gi://AstalBattery\"\nimport PowerProfiles from \"gi://AstalPowerProfiles\"\nimport { mergeBindings } from \"/usr/share/astal/gjs/_astal\"\nimport { Astal, Gdk, Gtk, Widget } from \"astal/gtk3\"\nimport Hyprland from \"gi://AstalHyprland\"\nimport { LevelBar, Window } from \"astal/gtk3/widget\"\n\nconst hyprland = Hyprland.get_default()\nconst batt = Battery.get_default()\nconst powerProfiles = PowerProfiles.get_default()\n\nlet battWindow: Window = null;\n\nfunction BattWindow() {\n\tconst { TOP, LEFT } = Astal.WindowAnchor\n\treturn <window\n\t\tclassName=\"popupWindow\"\n\t\tnamespace=\"lazerpopup\"\n\t\tmonitor={hyprland.focusedMonitor.id}\n\t\tanchor={TOP | LEFT}\n\t\tlayer={Astal.Layer.TOP}>\n\t\t<box\n\t\t\tclassName=\"popupBattery\"\n\t\t\tvertical={true}>\n\t\t\t<box spacing={10}>\n\t\t\t\t<overlay overlay={new Widget.Label({\n\t\t\t\t\thalign: Gtk.Align.CENTER,\n\t\t\t\t\tvalign: Gtk.Align.CENTER,\n\t\t\t\t\tclassName: \"percentage\",\n\t\t\t\t\tlabel: \"69%\",\n\t\t\t\t})}>\n\t\t\t\t\t<levelbar\n\t\t\t\t\t\tclassName=\"batteryLevel\"\n\t\t\t\t\t\tminValue={0}\n\t\t\t\t\t\tmaxValue={1}\n\t\t\t\t\t\tinverted={true}\n\t\t\t\t\t\twidthRequest={96}\n\t\t\t\t\t\tvertical={true}\n\t\t\t\t\t\tvalue={0.69}\n\t\t\t\t\t/>\n\t\t\t\t</overlay>\n\t\t\t\t<box vertical={true} spacing={10}>\n\t\t\t\t\t<overlay overlay={new Widget.Box({\n\t\t\t\t\t\thalign: Gtk.Align.CENTER,\n\t\t\t\t\t\tvalign: Gtk.Align.CENTER,\n\t\t\t\t\t\tvertical: true,\n\t\t\t\t\t\tchildren: [\n\t\t\t\t\t\t\tnew Widget.Icon({\n\t\t\t\t\t\t\t\ticon: \"/home/protoshark/.face\",\n\t\t\t\t\t\t\t\tcss: \"font-size: 24px;\",\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\tnew Widget.Label({\n\t\t\t\t\t\t\t\tclassName: \"title\",\n\t\t\t\t\t\t\t\tlabel: \"title\",\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\tnew Widget.Label({\n\t\t\t\t\t\t\t\tclassName: \"status\",\n\t\t\t\t\t\t\t\tlabel: \"status\",\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t]\n\t\t\t\t\t})}>\n\t\t\t\t\t<box className=\"info\" />\n\t\t\t\t\t</overlay>\n\t\t\t\t\t<overlay overlay={new Widget.Box({\n\t\t\t\t\t\thalign: Gtk.Align.CENTER,\n\t\t\t\t\t\tvalign: Gtk.Align.CENTER,\n\t\t\t\t\t\tvertical: true,\n\t\t\t\t\t\tchildren: [\n\t\t\t\t\t\t\tnew Widget.Label({\n\t\t\t\t\t\t\t\tclassName: \"title\",\n\t\t\t\t\t\t\t\tlabel: \"title\",\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\tnew Widget.Label({\n\t\t\t\t\t\t\t\tclassName: \"status\",\n\t\t\t\t\t\t\t\tlabel: \"status\",\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t]\n\t\t\t\t\t})}>\n\t\t\t\t\t<box className=\"info\" />\n\t\t\t\t\t</overlay>\n\t\t\t\t</box>\n\t\t\t</box>\n\t\t</box>\n\t</window>\n}\n\nexport default function battery() {\n\treturn <button\n\t\tclassName=\"battery\"\n\t\thalign={Gtk.Align.START}\n\t\tonClick={() => {\n\t\t\tif (battWindow === null) {\n\t\t\t\tbattWindow = BattWindow();\n\t\t\t} else {\n\t\t\t\tbattWindow.destroy()\n\t\t\t\tbattWindow = null\n\t\t\t}}}\n\t\t><box>\n\t\t\t<icon\n\t\t\t\tclassName=\"battIcon\"\n\t\t\t\ticon=\"battery\"\n\t\t\t\tpixel_size={20}>\n\t\t\t</icon>\n\t\t\t{mergeBindings(\n\t\t\t\t[bind(batt, \"percentage\").as(p => `${Math.round(p*100)}%`), bind(batt, \"energy_rate\").as(w => `${w}W`)]\n\t\t\t).as((p) => `${p[0]} // ${p[1]}`)}\n\t\t</box>\n\t</button>\n}\n", "import Gtk from \"gi://Gtk?version=3.0\"\nimport { type BindableChild } from \"./astalify.js\"\nimport { mergeBindings, jsx as _jsx } from \"../_astal.js\"\nimport * as Widget from \"./widget.js\"\n\nexport function Fragment({ children = [], child }: {\n    child?: BindableChild\n    children?: Array<BindableChild>\n}) {\n    if (child) children.push(child)\n    return mergeBindings(children)\n}\n\nexport function jsx(\n    ctor: keyof typeof ctors | typeof Gtk.Widget,\n    props: any,\n) {\n    return _jsx(ctors, ctor as any, props)\n}\n\nconst ctors = {\n    box: Widget.Box,\n    button: Widget.Button,\n    centerbox: Widget.CenterBox,\n    circularprogress: Widget.CircularProgress,\n    drawingarea: Widget.DrawingArea,\n    entry: Widget.Entry,\n    eventbox: Widget.EventBox,\n    // TODO: fixed\n    // TODO: flowbox\n    icon: Widget.Icon,\n    label: Widget.Label,\n    levelbar: Widget.LevelBar,\n    // TODO: listbox\n    menubutton: Widget.MenuButton,\n    overlay: Widget.Overlay,\n    revealer: Widget.Revealer,\n    scrollable: Widget.Scrollable,\n    slider: Widget.Slider,\n    stack: Widget.Stack,\n    switch: Widget.Switch,\n    window: Widget.Window,\n}\n\ndeclare global {\n    // eslint-disable-next-line @typescript-eslint/no-namespace\n    namespace JSX {\n        type Element = Gtk.Widget\n        type ElementClass = Gtk.Widget\n        interface IntrinsicElements {\n            box: Widget.BoxProps\n            button: Widget.ButtonProps\n            centerbox: Widget.CenterBoxProps\n            circularprogress: Widget.CircularProgressProps\n            drawingarea: Widget.DrawingAreaProps\n            entry: Widget.EntryProps\n            eventbox: Widget.EventBoxProps\n            // TODO: fixed\n            // TODO: flowbox\n            icon: Widget.IconProps\n            label: Widget.LabelProps\n            levelbar: Widget.LevelBarProps\n            // TODO: listbox\n            menubutton: Widget.MenuButtonProps\n            overlay: Widget.OverlayProps\n            revealer: Widget.RevealerProps\n            scrollable: Widget.ScrollableProps\n            slider: Widget.SliderProps\n            stack: Widget.StackProps\n            switch: Widget.SwitchProps\n            window: Widget.WindowProps\n        }\n    }\n}\n\nexport const jsxs = jsx\n", "import { bind } from \"astal\"\nimport { Gdk, Gtk, Widget } from \"astal/gtk3\"\nimport Hyprland from \"gi://AstalHyprland\"\n\nconst hyprland = Hyprland.get_default()\n\nfunction newWorkspace(ws: number, monitor: number) {\n\treturn <overlay\n\t\thalign={Gtk.Align.START}\n\t\toverlays={[\n\t\t\tnew Widget.Button({\n\t\t\t\tclassName: \"workspaceButton\",\n\t\t\t\tvisible: true,\n\t\t\t\tonClick: () => {\n\t\t\t\t\thyprland.dispatch(\"workspace\", ws.toString())\n\t\t\t\t}\n\t\t\t}, new Widget.Box({\n\t\t\t\thalign: Gtk.Align.FILL,\n\t\t\t\tvalign: Gtk.Align.FILL,\n\t\t\t}, new Widget.Box({\n\t\t\t\tvalign: Gtk.Align.CENTER,\n\t\t\t\thalign: Gtk.Align.CENTER,\n\t\t\t\tclassName: bind(hyprland, \"workspaces\").as(wss => {\n\t\t\t\t\t\tlet myws = wss.find(w => w.id === ws)\n\t\t\t\t\t\treturn (myws !== undefined && myws.monitor.id === monitor)\n\t\t\t\t\t\t\t? \"active\" : \"inactive\"\n\t\t\t\t}),\n\t\t\t\tcss: bind(hyprland, \"focusedWorkspace\").as(fws => {\n\t\t\t\t\treturn (fws.id === ws)\n\t\t\t\t\t\t? \"border-color: #00ffaa\"\n\t\t\t\t\t\t: \"border-color: #ffffff\"\n\t\t\t\t})\n\t\t\t}))),\n\t\t]}>\n\t\t<box className=\"workspaceContainer\" />\n\t</overlay>\n}\n\nexport default function workspaces(monitor: Hyprland.Monitor) {\n\treturn <overlay\n\t\toverlay={new Widget.Box({\n\t\t\thalign: Gtk.Align.START,\n\t\t\tvalign: Gtk.Align.END,\n\t\t\tclassName: \"workspaceIndicator\",\n\t\t\tcss: bind(hyprland, \"focusedWorkspace\").as(ws => {\n\t\t\t\treturn \"margin-left: \" + (24+(ws.id-1)*32) + \"px;\"\n\t\t\t})\n\t\t})}>\n\t\t<box\n\t\t\tclassName=\"workspaces\"\n\t\t\thalign={Gtk.Align.START}\n\t\t\tvisible={true}\n\t\t\tsetup={(self) => {\n\t\t\t\tfor (let i = 1; i <= 9; i++) {\n\t\t\t\t\tself.add(newWorkspace(i, monitor.id))\n\t\t\t\t}\n\t\t\t}}/>\n\t</overlay>\n}\n", "import { App, Astal, Gtk, Gdk, Widget } from \"astal/gtk3\"\nimport { Variable } from \"astal\"\nimport Hyprland from \"gi://AstalHyprland\"\nimport battery from \"./battery\"\nimport workspaces from \"./workspaces\"\n\nconst time = Variable(\"\").poll(1000, \"date +'%a %b %d // %H:%M'\")\n\nexport default function Bar(monitor: Hyprland.Monitor) {\n    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor\n\n    return <window\n        className=\"bar\"\n\t\tnamespace=\"bar\"\n\t\tmonitor={monitor.id}\n        exclusivity={Astal.Exclusivity.IGNORE}\n        anchor={TOP | LEFT | RIGHT}\n\t\theightRequest={36}\n\t\tlayer={Astal.Layer.TOP}\n        application={App}>\n        <centerbox>\n\t\t\t{battery()}\n\t\t\t{workspaces(monitor)}\n            <button\n\t\t\t\tclassName=\"default\"\n                onClicked={(self) => print(self.get_class_name())}\n                halign={Gtk.Align.END}\n            >\n                <label\n\t\t\t\t\tclassName=\"innerButton\"\n\t\t\t\t\tlabel={time()}\n\t\t\t\t/>\n            </button>\n        </centerbox>\n    </window>\n}\n", "import { App } from \"astal/gtk3\"\nimport style from \"./style.scss\"\nimport Bar from \"./widget/Bar\"\nimport Hyprland from \"gi://AstalHyprland\"\n\nconst hyprland = Hyprland.get_default()\n\nApp.start({\n    css: style,\n    main() {\n\t\thyprland.monitors.map((monitor) => Bar(monitor))\n    },\n})\n"],
  "mappings": "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",
  "names": ["Astal", "Gtk", "Astal", "bind", "interval", "Astal", "Astal", "Astal", "v", "interval", "ctors", "Astal", "Widget", "Astal", "Gtk", "Astal", "snakeify", "patch", "Hyprland", "PowerProfiles", "GObject", "Gtk", "Astal", "Astal", "Gtk", "GObject", "Gtk", "Astal", "GObject", "default", "Astal", "GObject", "default", "GObject", "jsx", "Astal", "jsx", "Gtk", "Hyprland", "hyprland", "Hyprland", "jsx", "Gtk", "Astal", "jsx", "Gtk", "Hyprland", "hyprland"]
}

diff --git a/app.ts b/app.ts
new file mode 100644
index 0000000..1f413e3
--- /dev/null
+++ b/app.ts
@@ -0,0 +1,14 @@
+import { App } from "astal/gtk3"
+import style from "./style.scss"
+import Bar from "./widget/Bar"
+import Hyprland from "gi://AstalHyprland"
+
+const hyprland = Hyprland.get_default()
+
+App.start({
+    css: style,
+	icons: "/home/protoshark/.config/astal/assets/",
+    main() {
+		hyprland.monitors.map((monitor) => Bar(monitor))
+    },
+})
diff --git a/assets/balanced-symbolic.svg b/assets/balanced-symbolic.svg
new file mode 100644
index 0000000..8f10a4f
--- /dev/null
+++ b/assets/balanced-symbolic.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.4192 9.00047C20.2792 8.99047 20.0992 8.98047 19.8992 8.98047C19.5092 8.98047 19.1992 9.29047 19.1992 9.68047V14.3305C19.1992 14.7205 19.5092 15.0305 19.8992 15.0305C20.0992 15.0305 20.2692 15.0205 20.4392 15.0105C21.9992 14.8305 21.9992 13.7305 21.9992 12.9305V11.0705C21.9992 10.2705 21.9992 9.17047 20.4192 9.00047Z" fill="#292D32"/>
+<path d="M12.93 4.78906H7.35C3.25 4.78906 2 6.03906 2 10.1391V13.8591C2 17.9591 3.25 19.2091 7.35 19.2091H12.93C17.03 19.2091 18.28 17.9591 18.28 13.8591V10.1391C18.28 6.03906 17.03 4.78906 12.93 4.78906ZM7.1 14.1791C7.02 14.5191 6.71 14.7491 6.37 14.7491C6.31 14.7491 6.25 14.7391 6.19 14.7291C5.79 14.6291 5.54 14.2191 5.64 13.8191C5.94 12.6291 5.94 11.3691 5.64 10.1791C5.54 9.77906 5.78 9.36906 6.19 9.26906C6.6 9.16906 7 9.41906 7.1 9.81906C7.46 11.2491 7.46 12.7491 7.1 14.1791ZM10.6 14.1791C10.52 14.5191 10.21 14.7491 9.87 14.7491C9.81 14.7491 9.75 14.7391 9.69 14.7291C9.29 14.6291 9.04 14.2191 9.14 13.8191C9.44 12.6291 9.44 11.3691 9.14 10.1791C9.04 9.77906 9.28 9.36906 9.69 9.26906C10.09 9.16906 10.5 9.40906 10.6 9.81906C10.96 11.2491 10.96 12.7491 10.6 14.1791Z" fill="#292D32"/>
+</svg>
\ No newline at end of file
diff --git a/assets/battery-charging-symbolic.svg b/assets/battery-charging-symbolic.svg
new file mode 100644
index 0000000..7ac1e0e
--- /dev/null
+++ b/assets/battery-charging-symbolic.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.4192 9.00047C20.2792 8.99047 20.0992 8.98047 19.8992 8.98047C19.5092 8.98047 19.1992 9.29047 19.1992 9.68047V14.3305C19.1992 14.7205 19.5092 15.0305 19.8992 15.0305C20.0992 15.0305 20.2692 15.0205 20.4392 15.0105C21.9992 14.8305 21.9992 13.7305 21.9992 12.9305V11.0705C21.9992 10.2705 21.9992 9.17047 20.4192 9.00047Z" fill="#292D32"/>
+<path d="M12.93 4.78906H7.35C3.25 4.78906 2 6.03906 2 10.1391V13.8591C2 17.9591 3.25 19.2091 7.35 19.2091H12.93C17.03 19.2091 18.28 17.9591 18.28 13.8591V10.1391C18.28 6.03906 17.03 4.78906 12.93 4.78906ZM12.53 13.6791C12.51 13.7191 12.48 13.7591 12.45 13.7891L10.58 15.9791C10.43 16.1491 10.22 16.2391 10.01 16.2391C9.84 16.2391 9.66 16.1791 9.52 16.0591C9.21 15.7891 9.17 15.3191 9.44 14.9991L11.24 12.8891C11.25 12.8591 11.24 12.8291 11.22 12.7991C11.2 12.7591 11.16 12.7391 11.11 12.7391H9.12C8.53 12.7391 8.01 12.4391 7.71 11.9291C7.42 11.4191 7.42 10.8191 7.71 10.3091L9.42 8.04906C9.67 7.71906 10.14 7.64906 10.47 7.89906C10.8 8.14906 10.87 8.61906 10.62 8.94906L8.97 11.1391C9 11.0991 9 11.1391 9.02 11.1891C9.04 11.2291 9.08 11.2491 9.13 11.2491H11.14C11.73 11.2491 12.25 11.5491 12.55 12.0591C12.82 12.5691 12.82 13.1691 12.53 13.6791Z" fill="#292D32"/>
+</svg>
\ No newline at end of file
diff --git a/assets/brightness-symbolic.svg b/assets/brightness-symbolic.svg
new file mode 100644
index 0000000..5dfd3d2
--- /dev/null
+++ b/assets/brightness-symbolic.svg
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" width="800px" height="800px" viewBox="0 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg">
+<title>brightness</title>
+<path d="M0 16q0 0.832 0.576 1.44t1.44 0.576h1.984q0.832 0 1.408-0.576t0.608-1.44-0.608-1.408-1.408-0.576h-1.984q-0.832 0-1.44 0.576t-0.576 1.408zM4.096 25.888q0 0.832 0.608 1.44t1.408 0.576 1.408-0.576l1.408-1.408q0.608-0.608 0.608-1.408t-0.608-1.408-1.408-0.608-1.408 0.608l-1.408 1.408q-0.608 0.576-0.608 1.376zM4.096 6.112q0 0.832 0.608 1.408l1.408 1.408q0.576 0.576 1.408 0.576t1.408-0.576 0.608-1.408-0.608-1.408l-1.408-1.408q-0.576-0.608-1.408-0.608t-1.408 0.608-0.608 1.408zM8 16q0 3.328 2.336 5.664t5.664 2.336 5.664-2.336 2.336-5.664-2.336-5.632-5.664-2.368-5.664 2.368-2.336 5.632zM12 16q0-1.632 1.184-2.816t2.816-1.184 2.816 1.184 1.184 2.816-1.184 2.848-2.816 1.152-2.816-1.152-1.184-2.848zM14.016 28v2.016q0 0.832 0.576 1.408t1.408 0.576 1.408-0.576 0.608-1.408v-2.016q0-0.832-0.608-1.408t-1.408-0.576-1.408 0.576-0.576 1.408zM14.016 4q0 0.832 0.576 1.44t1.408 0.576 1.408-0.576 0.608-1.44v-1.984q0-0.832-0.608-1.408t-1.408-0.608-1.408 0.608-0.576 1.408v1.984zM22.496 24.512q0 0.8 0.576 1.408l1.408 1.408q0.576 0.576 1.408 0.576t1.44-0.576 0.576-1.44-0.576-1.376l-1.408-1.408q-0.608-0.608-1.44-0.608t-1.408 0.608-0.576 1.408zM22.496 7.52q0 0.832 0.576 1.408t1.408 0.576 1.44-0.576l1.408-1.408q0.576-0.576 0.576-1.408t-0.576-1.408-1.44-0.608-1.408 0.608l-1.408 1.408q-0.576 0.576-0.576 1.408zM26.016 16q0 0.832 0.576 1.44t1.408 0.576h2.016q0.8 0 1.408-0.576t0.576-1.44-0.576-1.408-1.408-0.576h-2.016q-0.832 0-1.408 0.576t-0.576 1.408z"></path>
+</svg>
\ No newline at end of file
diff --git a/assets/lazer-bluetooth-symbolic.svg b/assets/lazer-bluetooth-symbolic.svg
new file mode 100644
index 0000000..bcfe23e
--- /dev/null
+++ b/assets/lazer-bluetooth-symbolic.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M11.9098 2.77366L13.7426 4.0752C14.2829 4.45881 14.7548 4.79385 15.0843 5.10897C15.435 5.44445 15.7501 5.87349 15.7501 6.45834C15.7501 7.04319 15.435 7.47224 15.0843 7.80771C14.7548 8.12283 14.2829 8.45787 13.7426 8.84148L9.29541 11.9996L13.7426 15.1577C14.2829 15.5413 14.7548 15.8764 15.0843 16.1915C15.435 16.527 15.7501 16.956 15.7501 17.5409C15.7501 18.1257 15.435 18.5548 15.0843 18.8902C14.7548 19.2054 14.2829 19.5404 13.7426 19.924L11.9099 21.2255C11.1804 21.7436 10.5645 22.181 10.0536 22.4416C9.53336 22.707 8.89829 22.9067 8.26311 22.5817C7.62612 22.2558 7.41919 21.6227 7.33374 21.0458C7.24998 20.4803 7.25002 19.7272 7.25006 18.8365L7.25006 13.4401L3.43016 16.114C3.09082 16.3516 2.62318 16.269 2.38564 15.9297C2.1481 15.5904 2.23063 15.1227 2.56997 14.8852L6.69222 11.9996L2.56997 9.11402C2.23063 8.87649 2.1481 8.40884 2.38564 8.0695C2.62318 7.73017 3.09082 7.64764 3.43016 7.88517L7.25006 10.5591V5.22417C7.25006 5.20359 7.25006 5.18309 7.25006 5.16266C7.25002 4.27198 7.24998 3.51888 7.33374 2.9534C7.41919 2.3765 7.62612 1.74342 8.26311 1.41752C8.89829 1.09254 9.53336 1.29223 10.0536 1.55758C10.5644 1.81817 11.1804 2.25559 11.9098 2.77366ZM8.75006 13.4521V18.775C8.75006 19.7439 8.75207 20.3839 8.81755 20.826C8.84924 21.04 8.88915 21.1526 8.9187 21.2087C8.93168 21.2334 8.94094 21.2429 8.94094 21.2429C8.94094 21.2429 8.9414 21.2438 8.94632 21.2463C8.95081 21.2486 8.95303 21.2489 8.95303 21.2489C8.95504 21.2492 8.96803 21.251 8.99661 21.2471C9.06133 21.2381 9.17796 21.2044 9.372 21.1054C9.77271 20.901 10.2984 20.5301 11.0911 19.9672L12.8291 18.733C13.4278 18.3078 13.8072 18.036 14.0475 17.8062C14.1612 17.6975 14.212 17.6269 14.2343 17.5863C14.2503 17.5573 14.2501 17.5474 14.2501 17.5418V17.5399C14.2501 17.5343 14.2503 17.5244 14.2343 17.4955C14.212 17.4548 14.1612 17.3842 14.0475 17.2755C13.8072 17.0457 13.4278 16.7739 12.8291 16.3487L8.75006 13.4521ZM8.75006 10.5471V5.22417C8.75006 4.2553 8.75207 3.61528 8.81755 3.17318C8.84924 2.95922 8.88915 2.84656 8.9187 2.79047C8.93168 2.76583 8.94094 2.75632 8.94094 2.75632C8.94094 2.75632 8.9414 2.75541 8.94632 2.75289C8.95081 2.75059 8.95303 2.7503 8.95303 2.7503C8.95503 2.74999 8.96803 2.74818 8.99661 2.75212C9.06133 2.76105 9.17796 2.79481 9.372 2.89379C9.77271 3.09819 10.2984 3.46908 11.0911 4.03202L12.8291 5.2662C13.4278 5.69138 13.8072 5.96315 14.0475 6.19298C14.1612 6.30172 14.212 6.37233 14.2343 6.41294C14.2503 6.44191 14.2501 6.45181 14.2501 6.45735V6.45933C14.2501 6.46487 14.2503 6.47477 14.2343 6.50374C14.212 6.54435 14.1612 6.61496 14.0475 6.7237C13.8072 6.95353 13.4278 7.2253 12.8291 7.65048L8.75006 10.5471ZM18.4828 4.45649C18.7828 4.17083 19.2575 4.18241 19.5432 4.48236L19.0249 4.97592C19.5432 4.48237 19.5432 4.48236 19.5432 4.48236L19.5444 4.48369L19.5459 4.48523L19.5493 4.48889L19.5583 4.49863C19.5653 4.50618 19.5741 4.51589 19.5845 4.52775C19.6055 4.55148 19.6333 4.58388 19.667 4.62512C19.7343 4.7076 19.8251 4.82547 19.9311 4.98014C20.1433 5.28958 20.4166 5.74597 20.6867 6.3603C21.2279 7.59152 21.7501 9.44417 21.7501 11.9996C21.7501 14.555 21.2279 16.4077 20.6867 17.6389C20.4166 18.2532 20.1433 18.7096 19.9311 19.0191C19.8251 19.1737 19.7343 19.2916 19.667 19.3741C19.6333 19.4153 19.6055 19.4477 19.5845 19.4714C19.5741 19.4833 19.5653 19.493 19.5583 19.5006L19.5493 19.5103L19.5459 19.514L19.5444 19.5155C19.5444 19.5155 19.5432 19.5168 19.0249 19.0233L19.5432 19.5168C19.2575 19.8168 18.7828 19.8284 18.4828 19.5427C18.1841 19.2582 18.1714 18.7863 18.4534 18.4861L18.4557 18.4837L18.455 18.4845L18.4534 18.4861L18.4605 18.4782C18.4688 18.4688 18.484 18.4513 18.505 18.4255C18.5471 18.374 18.6126 18.2895 18.694 18.1708C18.8568 17.9333 19.0835 17.5585 19.3135 17.0353C19.7723 15.9915 20.2501 14.3442 20.2501 11.9996C20.2501 9.65503 19.7723 8.00768 19.3135 6.9639C19.0835 6.44072 18.8568 6.06587 18.694 5.82843C18.6126 5.70966 18.5471 5.62519 18.505 5.57369C18.484 5.54793 18.4688 5.53043 18.4605 5.52101L18.4537 5.51338L18.455 5.51474L18.4559 5.5157M18.4828 4.45649C18.1841 4.74097 18.1717 5.21324 18.4537 5.51338ZM16.6508 7.33591C17.0173 7.14299 17.4708 7.28374 17.6638 7.65029L17.0001 7.9996C17.6638 7.65029 17.6638 7.65029 17.6638 7.65029L17.6646 7.65182L17.6657 7.65406L17.6691 7.66062L17.6801 7.68197C17.6891 7.69981 17.7016 7.7248 17.7171 7.75652C17.748 7.81995 17.7909 7.91046 17.8417 8.02468C17.9431 8.2528 18.0768 8.5774 18.2104 8.97132C18.4752 9.75259 18.7501 10.8384 18.7501 11.9996C18.7501 13.1608 18.4752 14.2466 18.2104 15.0279C18.0768 15.4218 17.9431 15.7464 17.8417 15.9745C17.7909 16.0887 17.748 16.1792 17.7171 16.2427C17.7016 16.2744 17.6891 16.2994 17.6801 16.3172L17.6691 16.3386L17.6657 16.3451L17.6646 16.3474L17.6639 16.3486C17.6639 16.3486 17.6638 16.3489 17.0001 15.9996L17.6639 16.3486C17.471 16.7151 17.0173 16.8562 16.6508 16.6633C16.2845 16.4705 16.1437 16.0176 16.3359 15.6513M16.3364 15.6503L16.3425 15.6383C16.3481 15.6272 16.3571 15.6094 16.369 15.585C16.3927 15.5364 16.428 15.462 16.471 15.3653C16.5571 15.1715 16.6733 14.8899 16.7898 14.5463C17.0249 13.8526 17.2501 12.9384 17.2501 11.9996C17.2501 11.0608 17.0249 10.1466 16.7898 9.45288C16.6733 9.1093 16.5571 8.82765 16.471 8.63389C16.428 8.53718 16.3927 8.46284 16.369 8.41416C16.3571 8.38983 16.3481 8.37195 16.3425 8.36093L16.3367 8.3496L16.3362 8.34863C16.1435 7.98214 16.2843 7.52878 16.6508 7.33591" fill="#1C274C"/>
+</svg>
\ No newline at end of file
diff --git a/assets/lazer-next-symbolic.svg b/assets/lazer-next-symbolic.svg
new file mode 100644
index 0000000..7c214b7
--- /dev/null
+++ b/assets/lazer-next-symbolic.svg
@@ -0,0 +1,7 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" stroke="#ffffff" stroke-width="1.512" style="--darkreader-inline-stroke: var(--darkreader-text-ffffff, #e8e6e3);" data-darkreader-inline-stroke="">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M6.27769 1.7555C5.1348 1.01747 3.83955 1.13428 2.86078 1.80371C1.89423 2.46477 1.25 3.64507 1.25 5.03297V18.9672C1.25 20.3551 1.89423 21.5354 2.86078 22.1965C3.83956 22.8659 5.1348 22.9827 6.2777 22.2447L17.0667 15.2775C18.217 14.5347 18.75 13.2342 18.75 12.0001C18.75 10.7659 18.217 9.46544 17.0667 8.72261L6.27769 1.7555ZM2.75 5.03297C2.75 4.11167 3.17287 3.40753 3.70757 3.04182C4.23005 2.68448 4.87022 2.63219 5.46397 3.0156L16.253 9.98271C16.8895 10.3938 17.25 11.1637 17.25 12.0001C17.25 12.8364 16.8895 13.6064 16.253 14.0174L5.46397 20.9846C4.87023 21.368 4.23005 21.3157 3.70758 20.9583C3.17287 20.5926 2.75 19.8885 2.75 18.9672L2.75 5.03297Z" fill="#1C274C" style="--darkreader-inline-fill: var(--darkreader-background-1c274c, #161f3d);" data-darkreader-inline-fill=""/> <path d="M22.75 5.00008C22.75 4.58586 22.4142 4.25008 22 4.25008C21.5858 4.25008 21.25 4.58586 21.25 5.00008V19.0001C21.25 19.4143 21.5858 19.7501 22 19.7501C22.4142 19.7501 22.75 19.4143 22.75 19.0001V5.00008Z" fill="#1C274C" style="--darkreader-inline-fill: var(--darkreader-background-1c274c, #161f3d);" data-darkreader-inline-fill=""/> </g>
+
</svg>
\ No newline at end of file
diff --git a/assets/lazer-pause-symbolic.svg b/assets/lazer-pause-symbolic.svg
new file mode 100644
index 0000000..244845d
--- /dev/null
+++ b/assets/lazer-pause-symbolic.svg
@@ -0,0 +1,7 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" stroke="#ffffff" stroke-width="1.512" style="--darkreader-inline-stroke: var(--darkreader-text-ffffff, #e8e6e3);" data-darkreader-inline-stroke="">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M5.948 1.25H6.052C6.95048 1.24997 7.6997 1.24995 8.29448 1.32991C8.92228 1.41432 9.48908 1.59999 9.94455 2.05546C10.4 2.51093 10.5857 3.07773 10.6701 3.70552C10.7501 4.30031 10.75 5.04953 10.75 5.94801V18.052C10.75 18.9505 10.7501 19.6997 10.6701 20.2945C10.5857 20.9223 10.4 21.4891 9.94455 21.9445C9.48908 22.4 8.92228 22.5857 8.29448 22.6701C7.6997 22.7501 6.95048 22.75 6.052 22.75H5.94801C5.04953 22.75 4.30031 22.7501 3.70552 22.6701C3.07773 22.5857 2.51093 22.4 2.05546 21.9445C1.59999 21.4891 1.41432 20.9223 1.32991 20.2945C1.24995 19.6997 1.24997 18.9505 1.25 18.052V5.948C1.24997 5.04952 1.24995 4.3003 1.32991 3.70552C1.41432 3.07773 1.59999 2.51093 2.05546 2.05546C2.51093 1.59999 3.07773 1.41432 3.70552 1.32991C4.3003 1.24995 5.04952 1.24997 5.948 1.25ZM3.90539 2.81654C3.44393 2.87858 3.24644 2.9858 3.11612 3.11612C2.9858 3.24644 2.87858 3.44393 2.81654 3.90539C2.7516 4.38843 2.75 5.03599 2.75 6V18C2.75 18.964 2.7516 19.6116 2.81654 20.0946C2.87858 20.5561 2.9858 20.7536 3.11612 20.8839C3.24644 21.0142 3.44393 21.1214 3.90539 21.1835C4.38843 21.2484 5.03599 21.25 6 21.25C6.96401 21.25 7.61157 21.2484 8.09461 21.1835C8.55607 21.1214 8.75357 21.0142 8.88389 20.8839C9.0142 20.7536 9.12143 20.5561 9.18347 20.0946C9.24841 19.6116 9.25 18.964 9.25 18V6C9.25 5.03599 9.24841 4.38843 9.18347 3.90539C9.12143 3.44393 9.0142 3.24644 8.88389 3.11612C8.75357 2.9858 8.55607 2.87858 8.09461 2.81654C7.61157 2.7516 6.96401 2.75 6 2.75C5.03599 2.75 4.38843 2.7516 3.90539 2.81654ZM17.948 1.25H18.052C18.9505 1.24997 19.6997 1.24995 20.2945 1.32991C20.9223 1.41432 21.4891 1.59999 21.9445 2.05546C22.4 2.51093 22.5857 3.07773 22.6701 3.70552C22.7501 4.30031 22.75 5.04953 22.75 5.94801V18.052C22.75 18.9505 22.7501 19.6997 22.6701 20.2945C22.5857 20.9223 22.4 21.4891 21.9445 21.9445C21.4891 22.4 20.9223 22.5857 20.2945 22.6701C19.6997 22.7501 18.9505 22.75 18.052 22.75H17.948C17.0495 22.75 16.3003 22.7501 15.7055 22.6701C15.0777 22.5857 14.5109 22.4 14.0555 21.9445C13.6 21.4891 13.4143 20.9223 13.3299 20.2945C13.2499 19.6997 13.25 18.9505 13.25 18.052V5.94801C13.25 5.04953 13.2499 4.30031 13.3299 3.70552C13.4143 3.07773 13.6 2.51093 14.0555 2.05546C14.5109 1.59999 15.0777 1.41432 15.7055 1.32991C16.3003 1.24995 17.0495 1.24997 17.948 1.25ZM15.9054 2.81654C15.4439 2.87858 15.2464 2.9858 15.1161 3.11612C14.9858 3.24644 14.8786 3.44393 14.8165 3.90539C14.7516 4.38843 14.75 5.03599 14.75 6V18C14.75 18.964 14.7516 19.6116 14.8165 20.0946C14.8786 20.5561 14.9858 20.7536 15.1161 20.8839C15.2464 21.0142 15.4439 21.1214 15.9054 21.1835C16.3884 21.2484 17.036 21.25 18 21.25C18.964 21.25 19.6116 21.2484 20.0946 21.1835C20.5561 21.1214 20.7536 21.0142 20.8839 20.8839C21.0142 20.7536 21.1214 20.5561 21.1835 20.0946C21.2484 19.6116 21.25 18.964 21.25 18V6C21.25 5.03599 21.2484 4.38843 21.1835 3.90539C21.1214 3.44393 21.0142 3.24644 20.8839 3.11612C20.7536 2.9858 20.5561 2.87858 20.0946 2.81654C19.6116 2.7516 18.964 2.75 18 2.75C17.036 2.75 16.3884 2.7516 15.9054 2.81654Z" fill="#1C274C" style="--darkreader-inline-fill: var(--darkreader-background-1c274c, #161f3d);" data-darkreader-inline-fill=""/> </g>
+
</svg>
\ No newline at end of file
diff --git a/assets/lazer-play-symbolic.svg b/assets/lazer-play-symbolic.svg
new file mode 100644
index 0000000..87ea81e
--- /dev/null
+++ b/assets/lazer-play-symbolic.svg
@@ -0,0 +1,7 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" stroke="#ffffff" stroke-width="1.512" style="--darkreader-inline-stroke: var(--darkreader-text-ffffff, #e8e6e3);" data-darkreader-inline-stroke="">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M7.23832 3.04445C5.65196 2.1818 3.75 3.31957 3.75 5.03299L3.75 18.9672C3.75 20.6806 5.65196 21.8184 7.23832 20.9557L20.0503 13.9886C21.6499 13.1188 21.6499 10.8814 20.0503 10.0116L7.23832 3.04445ZM2.25 5.03299C2.25 2.12798 5.41674 0.346438 7.95491 1.72669L20.7669 8.6938C23.411 10.1317 23.411 13.8685 20.7669 15.3064L7.95491 22.2735C5.41674 23.6537 2.25 21.8722 2.25 18.9672L2.25 5.03299Z" fill="#1C274C" style="--darkreader-inline-fill: var(--darkreader-background-1c274c, #161f3d);" data-darkreader-inline-fill=""/> </g>
+
</svg>
\ No newline at end of file
diff --git a/assets/lazer-previous-symbolic.svg b/assets/lazer-previous-symbolic.svg
new file mode 100644
index 0000000..688869a
--- /dev/null
+++ b/assets/lazer-previous-symbolic.svg
@@ -0,0 +1,7 @@
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" stroke="#ffffff" stroke-width="1.512" style="--darkreader-inline-stroke: var(--darkreader-text-ffffff, #e8e6e3);" data-darkreader-inline-stroke="">
+
<g id="SVGRepo_bgCarrier" stroke-width="0"/>
+
<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
+
<g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M21.1392 1.80371C22.1058 2.46477 22.75 3.64507 22.75 5.03297V18.9672C22.75 20.3551 22.1058 21.5354 21.1392 22.1965C20.1604 22.8659 18.8652 22.9827 17.7223 22.2447L6.93329 15.2775C5.78297 14.5347 5.25 13.2342 5.25 12.0001C5.25 10.7659 5.78297 9.46544 6.93329 8.72261L17.7223 1.7555C18.8652 1.01747 20.1604 1.13428 21.1392 1.80371ZM20.2924 3.04182C19.7699 2.68448 19.1298 2.63219 18.536 3.0156L7.74702 9.98271C7.11047 10.3938 6.75 11.1637 6.75 12.0001C6.75 12.8364 7.11047 13.6064 7.74701 14.0174L18.536 20.9846C19.1298 21.368 19.7699 21.3157 20.2924 20.9583C20.8271 20.5926 21.25 19.8885 21.25 18.9672V5.03297C21.25 4.11167 20.8271 3.40753 20.2924 3.04182ZM2 4.25008C2.41421 4.25008 2.75 4.58586 2.75 5.00008V19.0001C2.75 19.4143 2.41421 19.7501 2 19.7501C1.58579 19.7501 1.25 19.4143 1.25 19.0001V5.00008C1.25 4.58586 1.58579 4.25008 2 4.25008Z" fill="#1C274C" style="--darkreader-inline-fill: var(--darkreader-background-1c274c, #161f3d);" data-darkreader-inline-fill=""/> </g>
+
</svg>
\ No newline at end of file
diff --git a/assets/myvolume-symbolic.svg b/assets/myvolume-symbolic.svg
new file mode 100644
index 0000000..85d305e
--- /dev/null
+++ b/assets/myvolume-symbolic.svg
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M2 13C2 15.2091 3.79086 17 6 17H6.19669C6.69707 17 7.17928 17.1876 7.54814 17.5257L10.4773 20.2107C11.0311 20.7184 11.755 21 12.5063 21C13.7594 21 14.9494 20.2016 15.2601 18.8803C15.5904 17.476 16 15.1081 16 12C16 8.89192 15.5904 6.52403 15.2601 5.11974C14.9494 3.79838 13.7594 3 12.5063 3C11.755 3 11.0311 3.28161 10.4773 3.78926L7.54813 6.47431C7.17928 6.81243 6.69707 7 6.19669 7H6C3.79086 7 2 8.79086 2 11V13ZM6 15C4.89543 15 4 14.1046 4 13V11C4 9.89543 4.89543 9 6 9H6.19669C7.19745 9 8.16186 8.62486 8.89958 7.94862L11.8287 5.26357C12.0137 5.09404 12.2554 5 12.5063 5C12.9376 5 13.2384 5.25937 13.3132 5.57761C13.6134 6.85393 14 9.06723 14 12C14 14.9328 13.6134 17.1461 13.3132 18.4224C13.2384 18.7406 12.9376 19 12.5063 19C12.2554 19 12.0137 18.906 11.8287 18.7364L8.89958 16.0514C8.16186 15.3751 7.19745 15 6.19669 15H6Z" fill="#0F1729"/>
+<path d="M20.5723 6.09607C21.0716 5.85987 21.6677 6.0731 21.9039 6.57232C22.6447 8.13791 22.9979 10.0843 23 11.9889C23.0021 13.8934 22.6531 15.8479 21.9036 17.4285C21.6669 17.9275 21.0706 18.1402 20.5715 17.9036C20.0725 17.6669 19.8598 17.0706 20.0964 16.5715C20.6881 15.3238 21.0018 13.679 21 11.991C20.9981 10.303 20.6808 8.66357 20.0961 7.42768C19.8599 6.92845 20.0731 6.33227 20.5723 6.09607Z" fill="#0F1729"/>
+<path d="M17.5528 15.8944C17.0588 15.6474 16.8586 15.0468 17.1056 14.5528C17.9648 12.8343 17.9648 11.1657 17.1056 9.44721C16.8586 8.95324 17.0588 8.35256 17.5528 8.10557C18.0468 7.85858 18.6474 8.05881 18.8944 8.55279C20.0352 10.8343 20.0352 13.1657 18.8944 15.4472C18.6474 15.9412 18.0468 16.1414 17.5528 15.8944Z" fill="#0F1729"/>
+</svg>
\ No newline at end of file
diff --git a/assets/nobluetooth-symbolic.svg b/assets/nobluetooth-symbolic.svg
new file mode 100644
index 0000000..8c866e4
--- /dev/null
+++ b/assets/nobluetooth-symbolic.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.9098 2.77366L16.7426 4.0752C17.2829 4.45881 17.7548 4.79385 18.0843 5.10897C18.435 5.44445 18.7501 5.87349 18.7501 6.45834C18.7501 7.04319 18.435 7.47224 18.0843 7.80771C17.7548 8.12283 17.2829 8.45787 16.7426 8.84148L12.2954 11.9996L16.7426 15.1577C17.2829 15.5413 17.7548 15.8764 18.0843 16.1915C18.435 16.527 18.7501 16.956 18.7501 17.5409C18.7501 18.1257 18.435 18.5548 18.0843 18.8902C17.7548 19.2054 17.2829 19.5404 16.7426 19.924L14.9099 21.2255C14.1804 21.7436 13.5645 22.181 13.0536 22.4416C12.5334 22.707 11.8983 22.9067 11.2631 22.5817C10.6261 22.2558 10.4192 21.6227 10.3337 21.0458C10.25 20.4803 10.25 19.7272 10.2501 18.8365L10.2501 13.4401L6.43016 16.114C6.09082 16.3516 5.62318 16.269 5.38564 15.9297C5.1481 15.5904 5.23063 15.1227 5.56997 14.8852L9.69222 11.9996L5.56997 9.11402C5.23063 8.87649 5.1481 8.40884 5.38564 8.0695C5.62318 7.73017 6.09082 7.64764 6.43016 7.88517L10.2501 10.5591V5.22417C10.2501 5.20359 10.2501 5.18309 10.2501 5.16266C10.25 4.27198 10.25 3.51888 10.3337 2.9534C10.4192 2.3765 10.6261 1.74342 11.2631 1.41752C11.8983 1.09254 12.5334 1.29223 13.0536 1.55758C13.5644 1.81817 14.1804 2.25559 14.9098 2.77366ZM11.7501 13.4521V18.775C11.7501 19.7439 11.7521 20.3839 11.8176 20.826C11.8492 21.04 11.8892 21.1526 11.9187 21.2087C11.9317 21.2334 11.94 21.2419 11.9409 21.2429C11.9411 21.2431 11.9414 21.2438 11.9463 21.2463C11.9508 21.2486 11.9521 21.2488 11.953 21.2489C11.955 21.2492 11.968 21.251 11.9966 21.2471C12.0613 21.2381 12.178 21.2044 12.372 21.1054C12.7727 20.901 13.2984 20.5301 14.0911 19.9672L15.8291 18.733C16.4278 18.3078 16.8072 18.036 17.0475 17.8062C17.1612 17.6975 17.212 17.6269 17.2343 17.5863C17.2503 17.5573 17.2501 17.5474 17.2501 17.5418C17.2501 17.5415 17.2501 17.5422 17.2501 17.5418C17.2501 17.5415 17.2501 17.5402 17.2501 17.5399C17.2501 17.5343 17.2503 17.5244 17.2343 17.4955C17.212 17.4548 17.1612 17.3842 17.0475 17.2755C16.8072 17.0457 16.4278 16.7739 15.8291 16.3487L11.7501 13.4521ZM11.7501 10.5471V5.22417C11.7501 4.2553 11.7521 3.61528 11.8176 3.17318C11.8492 2.95922 11.8892 2.84656 11.9187 2.79047C11.9317 2.76583 11.94 2.75725 11.9409 2.75632C11.9411 2.75611 11.9414 2.75541 11.9463 2.75289C11.9508 2.75059 11.9521 2.75042 11.953 2.7503C11.9529 2.75031 11.9531 2.75028 11.953 2.7503C11.955 2.74999 11.968 2.74818 11.9966 2.75212C12.0613 2.76105 12.178 2.79481 12.372 2.89379C12.7727 3.09819 13.2984 3.46908 14.0911 4.03202L15.8291 5.2662C16.4278 5.69138 16.8072 5.96315 17.0475 6.19298C17.1612 6.30172 17.212 6.37233 17.2343 6.41294C17.2503 6.44191 17.2501 6.45181 17.2501 6.45735C17.2501 6.45704 17.2501 6.4577 17.2501 6.45735C17.2501 6.45767 17.2501 6.45898 17.2501 6.45933C17.2501 6.46487 17.2503 6.47477 17.2343 6.50374C17.212 6.54435 17.1612 6.61496 17.0475 6.7237C16.8072 6.95353 16.4278 7.2253 15.8291 7.65048L11.7501 10.5471Z" fill="#1C274C"/>
+</svg>
\ No newline at end of file
diff --git a/assets/noplayer-symbolic b/assets/noplayer-symbolic
new file mode 100644
index 0000000..50bfb6b
--- /dev/null
+++ b/assets/noplayer-symbolic
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12,7.33a1,1,0,0,0,1-1V5.78l6-1.5V7.22L14.7,8.3a1,1,0,0,0,.24,2l.24,0L20.24,9l.07,0,.19-.09.15-.1a.93.93,0,0,0,.13-.15.78.78,0,0,0,.1-.15.55.55,0,0,0,.06-.18.65.65,0,0,0,0-.19A.24.24,0,0,0,21,8V3a1,1,0,0,0-1.24-1l-8,2A1,1,0,0,0,11,5V6.33A1,1,0,0,0,12,7.33Zm9.71,13-9-9h0l-9-9A1,1,0,0,0,2.29,3.71L11,12.41v2.94A3.45,3.45,0,0,0,9.5,15,3.5,3.5,0,1,0,13,18.5V14.41l7.29,7.3a1,1,0,0,0,1.42,0A1,1,0,0,0,21.71,20.29ZM9.5,20A1.5,1.5,0,1,1,11,18.5,1.5,1.5,0,0,1,9.5,20Z"/></svg>
\ No newline at end of file
diff --git a/assets/noplayer-symbolic.svg b/assets/noplayer-symbolic.svg
new file mode 100644
index 0000000..50bfb6b
--- /dev/null
+++ b/assets/noplayer-symbolic.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12,7.33a1,1,0,0,0,1-1V5.78l6-1.5V7.22L14.7,8.3a1,1,0,0,0,.24,2l.24,0L20.24,9l.07,0,.19-.09.15-.1a.93.93,0,0,0,.13-.15.78.78,0,0,0,.1-.15.55.55,0,0,0,.06-.18.65.65,0,0,0,0-.19A.24.24,0,0,0,21,8V3a1,1,0,0,0-1.24-1l-8,2A1,1,0,0,0,11,5V6.33A1,1,0,0,0,12,7.33Zm9.71,13-9-9h0l-9-9A1,1,0,0,0,2.29,3.71L11,12.41v2.94A3.45,3.45,0,0,0,9.5,15,3.5,3.5,0,1,0,13,18.5V14.41l7.29,7.3a1,1,0,0,0,1.42,0A1,1,0,0,0,21.71,20.29ZM9.5,20A1.5,1.5,0,1,1,11,18.5,1.5,1.5,0,0,1,9.5,20Z"/></svg>
\ No newline at end of file
diff --git a/assets/performance-symbolic.svg b/assets/performance-symbolic.svg
new file mode 100644
index 0000000..1c8131d
--- /dev/null
+++ b/assets/performance-symbolic.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.4192 9.00047C20.2792 8.99047 20.0992 8.98047 19.8992 8.98047C19.5092 8.98047 19.1992 9.29047 19.1992 9.68047V14.3305C19.1992 14.7205 19.5092 15.0305 19.8992 15.0305C20.0992 15.0305 20.2692 15.0205 20.4392 15.0105C21.9992 14.8305 21.9992 13.7305 21.9992 12.9305V11.0705C21.9992 10.2705 21.9992 9.17047 20.4192 9.00047Z" fill="#292D32"/>
+<path d="M12.93 4.78906H7.35C3.25 4.78906 2 6.03906 2 10.1391V13.8591C2 17.9591 3.25 19.2091 7.35 19.2091H12.93C17.03 19.2091 18.28 17.9591 18.28 13.8591V10.1391C18.28 6.03906 17.03 4.78906 12.93 4.78906ZM7.1 14.1791C7.02 14.5191 6.71 14.7491 6.37 14.7491C6.31 14.7491 6.25 14.7391 6.19 14.7291C5.79 14.6291 5.54 14.2191 5.64 13.8191C5.94 12.6291 5.94 11.3691 5.64 10.1791C5.54 9.77906 5.78 9.36906 6.19 9.26906C6.6 9.16906 7 9.41906 7.1 9.81906C7.46 11.2491 7.46 12.7491 7.1 14.1791ZM10.6 14.1791C10.52 14.5191 10.21 14.7491 9.87 14.7491C9.81 14.7491 9.75 14.7391 9.69 14.7291C9.29 14.6291 9.04 14.2191 9.14 13.8191C9.44 12.6291 9.44 11.3691 9.14 10.1791C9.04 9.77906 9.28 9.36906 9.69 9.26906C10.09 9.16906 10.5 9.40906 10.6 9.81906C10.96 11.2491 10.96 12.7491 10.6 14.1791ZM14.1 14.1791C14.02 14.5191 13.71 14.7491 13.37 14.7491C13.31 14.7491 13.25 14.7391 13.19 14.7291C12.79 14.6291 12.54 14.2191 12.64 13.8191C12.94 12.6291 12.94 11.3691 12.64 10.1791C12.54 9.77906 12.78 9.36906 13.19 9.26906C13.59 9.16906 14 9.40906 14.1 9.81906C14.46 11.2491 14.46 12.7491 14.1 14.1791Z" fill="#292D32"/>
+</svg>
\ No newline at end of file
diff --git a/assets/player-symbolic.svg b/assets/player-symbolic.svg
new file mode 100644
index 0000000..f5ea5e4
--- /dev/null
+++ b/assets/player-symbolic.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M21.65,2.24a1,1,0,0,0-.8-.23l-13,2A1,1,0,0,0,7,5V15.35A3.45,3.45,0,0,0,5.5,15,3.5,3.5,0,1,0,9,18.5V10.86L20,9.17v4.18A3.45,3.45,0,0,0,18.5,13,3.5,3.5,0,1,0,22,16.5V3A1,1,0,0,0,21.65,2.24ZM5.5,20A1.5,1.5,0,1,1,7,18.5,1.5,1.5,0,0,1,5.5,20Zm13-2A1.5,1.5,0,1,1,20,16.5,1.5,1.5,0,0,1,18.5,18ZM20,7.14,9,8.83v-3L20,4.17Z"/></svg>
\ No newline at end of file
diff --git a/assets/power-saver-symbolic.svg b/assets/power-saver-symbolic.svg
new file mode 100644
index 0000000..c981de7
--- /dev/null
+++ b/assets/power-saver-symbolic.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.4192 9.00047C20.2792 8.99047 20.0992 8.98047 19.8992 8.98047C19.5092 8.98047 19.1992 9.29047 19.1992 9.68047V14.3305C19.1992 14.7205 19.5092 15.0305 19.8992 15.0305C20.0992 15.0305 20.2692 15.0205 20.4392 15.0105C21.9992 14.8305 21.9992 13.7305 21.9992 12.9305V11.0705C21.9992 10.2705 21.9992 9.17047 20.4192 9.00047Z" fill="#292D32"/>
+<path d="M12.93 4.78906H7.35C3.25 4.78906 2 6.03906 2 10.1391V13.8591C2 17.9591 3.25 19.2091 7.35 19.2091H12.93C17.03 19.2091 18.28 17.9591 18.28 13.8591V10.1391C18.28 6.03906 17.03 4.78906 12.93 4.78906ZM7.1 14.1791C7.02 14.5191 6.71 14.7491 6.37 14.7491C6.31 14.7491 6.25 14.7391 6.19 14.7291C5.79 14.6291 5.54 14.2191 5.64 13.8191C5.94 12.6291 5.94 11.3691 5.64 10.1791C5.54 9.77906 5.78 9.36906 6.19 9.26906C6.59 9.16906 7 9.41906 7.1 9.81906C7.46 11.2491 7.46 12.7491 7.1 14.1791Z" fill="#292D32"/>
+</svg>
\ No newline at end of file
diff --git a/colors.scss b/colors.scss
new file mode 100644
index 0000000..59df57d
--- /dev/null
+++ b/colors.scss
@@ -0,0 +1,12 @@
+$background-1:    #191919;
+$background-2:    #515151;
+$background-3:    #24222A;
+$background-4:    #302E38;
+$highlight-1:     #CD1D48;
+$highlight-1s:    #FF5580;
+$highlight-2:     #00FFAA;
+$highlight-3:     #8C66FF;
+$highlight-3s:    #A87AFF;
+$text-1:          #FFFFFF;
+$text-2:          #E0DBF0;
+
diff --git a/env.d.ts b/env.d.ts
new file mode 100644
index 0000000..467c0a4
--- /dev/null
+++ b/env.d.ts
@@ -0,0 +1,21 @@
+declare const SRC: string
+
+declare module "inline:*" {
+    const content: string
+    export default content
+}
+
+declare module "*.scss" {
+    const content: string
+    export default content
+}
+
+declare module "*.blp" {
+    const content: string
+    export default content
+}
+
+declare module "*.css" {
+    const content: string
+    export default content
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..44226f2
--- /dev/null
+++ b/package.json
@@ -0,0 +1,6 @@
+{
+    "name": "astal-shell",
+    "dependencies": {
+        "astal": "/usr/share/astal/gjs"
+    }
+}
diff --git a/style.scss b/style.scss
new file mode 100644
index 0000000..505e162
--- /dev/null
+++ b/style.scss
@@ -0,0 +1,292 @@
+@import "colors";
+
+window {
+  background: $background-1;
+  color: $text-2;
+  font-family: comfortaa; 
+  font-weight: bolder;
+  font-size: 14px;
+
+  > centerbox {
+    background: $background-1;
+  }
+}
+
+button {
+  animation: none;
+  background: transparent;
+  color: $text-1;
+  padding: 0;
+
+  > box, > overlay > box {
+    transition: ease-out 0.2s;
+    border-radius: 12px;
+    padding: 0 6px 0 6px;
+    margin: 2px 6px 4px 6px;
+    color: $text-1;
+  }
+
+  &.selected {
+    > box {
+      background: $highlight-1;
+      box-shadow: 0 0 4px 0 $highlight-1;
+    }
+  }
+
+  &:hover {
+    color: transparent;
+    > box, > overlay > box {
+      background: $background-2;
+    }
+    &.selected {
+      > box, > overlay > box {
+        background: $highlight-1s;
+      }
+    }
+  }
+}
+
+.workspaces {
+  padding: 0 20px 0 20px;
+}
+
+.workspaceContainer {
+  min-width: 32px;
+  padding: 0;
+  margin: 0;
+}
+
+.workspaceButton > box {
+  padding: 0;
+  margin: 0;
+}
+
+.workspaceBg {
+  background: $background-1;
+  border: 2px solid $text-1;
+  border-radius: 100%;
+}
+
+.workspaceIndicator {
+  transition: all cubic-bezier(0.34, 1.4, 0.64, 1) 0.4s;
+  background: $text-1;
+  min-width: 24px;
+  min-height: 4px;
+  border-radius: 4px;
+}
+
+.workspaceButton {
+  background: $background-1;
+  padding: 0;
+  margin: 0;
+  > box {
+    transition: all ease-out 0.1s;
+    margin: 2px 2px 6px 2px;
+    border-radius: 8px;
+  }
+  > box > box {
+    margin-left: 6px;
+    transition: ease-out 0.2s;
+    min-width: 8px;
+    min-height: 8px;
+    border-radius: 100%;
+    border: solid 4px;
+    color: $text-1;
+    &.active {
+      min-width: 0px;
+      min-height: 0px;
+      border-width: 8px;
+    }
+    &.focused {
+      min-width: 6px;
+      min-height: 6px;
+    }
+  }
+  &:hover {
+    color: $background-1;
+    > box {
+      background: $background-2;
+    }
+  }
+}
+
+.popupWindow {
+  background: transparent;
+  > box {
+    background: $background-3;
+    border-radius: 10px;
+    box-shadow: 0 0 10px 4px black;
+    padding: 10px;
+    margin: 48px 40px 40px 12px;
+  }
+}
+
+
+.popupBattery {
+  .percentage {
+    color: $text-1;
+    background: $background-1;
+    border-radius: 6px;
+    padding: 4px 6px 4px 6px;
+    box-shadow: 0 0 5px -1px $background-1;
+  }
+  levelbar block:not(.empty) {
+    background: $highlight-2;
+    border-radius: 8px;
+    box-shadow: 0 0 4px 0px $background-1;
+  }
+  levelbar block.empty {
+    border-radius: 8px;
+    background: $background-4;
+  }
+  .info {
+    min-height: 96px;
+    min-width: 96px;
+    background: $background-4;
+    border-radius: 8px;
+  }
+}
+.bigText {
+  font-size: 16px;
+}
+.smallText {
+  font-size: 12px;
+}
+
+.toggleButton {
+  &:hover .toggleIndicator {
+    box-shadow: 0 0 6px 0px $highlight-3;
+  }
+  > overlay {
+    margin: 0;
+    padding: 6px 0px 6px 0px;
+    > label {
+      color: $text-1;
+      font-size: 16px;
+      margin: 2px;
+    }
+    > .active {
+      margin: 4px 12px 4px 0;
+      min-width: 32px;
+      background: $highlight-3;
+    }
+  }
+}
+
+.scroller {
+  levelbar block {
+    margin: 0 2px 0 4px;
+    border-radius: 4px;
+    &:not(.empty) {
+      background: $text-2;
+    }
+    .empty {
+      background: $background-3;
+    }
+  }
+  & .active {
+    > box {
+      margin: 4px 12px 4px 0;
+      min-width: 32px;
+      background: $highlight-1;
+    }
+  }
+}
+
+.volSlider {
+  scale {
+    min-width: 250px;
+    &:hover slider {
+      box-shadow: 0 0 6px 0px $highlight-3;
+    }
+  }
+  scale slider {
+    transition: all cubic-bezier(0.34, 1.6, 0.64, 1) 0.25s, box-shadow ease-out 0.3s;
+    min-height: 6px;
+    min-width: 24px;
+    border: none;
+    box-shadow: none;
+    color: $highlight-3;
+    background: $highlight-3;
+    margin: -6px;
+    box-shadow: 0 0 4px 0 $background-3;
+    &:active {
+      min-width: 40px;
+    }
+  }
+  scale trough {
+    min-height: 6px;
+    background-color: $background-1;
+    border-radius: 8px;
+  }
+  scale highlight {
+    border-radius: 8px;
+    background: $highlight-3;
+    color: $highlight-3;
+  }
+}
+
+@keyframes upIn {
+  from {margin-top: -50px; opacity: 0;}
+  to {opacity: 100;}
+}
+
+.clientLabel {
+  animation: upIn cubic-bezier(0.22, 1, 0.36, 1) 0.5s;
+  transition: all cubic-bezier(0.22, 1, 0.36, 1) 0.2s;
+  margin-left: 6px;
+  background: transparent;
+}
+
+.coverArt {
+  margin: 0;
+  padding: 0;
+  min-width: 24px;
+  min-height: 24px;
+  border-radius: 8px;
+}
+
+.bigCoverArt{
+  transition: all ease-in-out 1s;
+  min-width: 300px;
+  min-height: 150px;
+  background-size: cover;
+  background-position: center;
+  background-color: #ccc;
+  background-blend-mode: multiply;
+  border-radius: 8px;
+}
+
+.playerLabel {
+  .playerTitle {
+    font-size: 20px;
+  }
+  .playerArtist {
+    font-size: 14px;
+  }
+}
+
+.playerButton {
+  padding: 0;
+  margin: 0;
+  > button > box {
+    min-height: 36px;
+  }
+}
+
+.bigCoverShadow {
+  min-width: 50px;
+  min-height: 0;
+  background: rgba(0, 0, 0, 0.67);
+  box-shadow: 0 0 48px 48px #000000;
+}
+
+.toggleIndicator {
+  transition: all cubic-bezier(0.34, 1.6, 0.64, 1) 0.25s;
+  min-height: 6px;
+  min-width: 24px;
+  padding: 0;
+  margin: 4px 16px 4px 0;
+  border: 2px solid $highlight-3;
+  border-radius: 8px;
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..9471e35
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json.schemastore.org/tsconfig",
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "strict": true,
+        "target": "ES2022",
+        "module": "ES2022",
+        "moduleResolution": "Bundler",
+        // "checkJs": true,
+        // "allowJs": true,
+        "jsx": "react-jsx",
+        "jsxImportSource": "astal/gtk3",
+    }
+}
diff --git a/widget/Bar.tsx b/widget/Bar.tsx
new file mode 100644
index 0000000..1695a98
--- /dev/null
+++ b/widget/Bar.tsx
@@ -0,0 +1,46 @@
+import { App, Astal, Gtk, Gdk, Widget } from "astal/gtk3"
+import { Variable } from "astal"
+import Hyprland from "gi://AstalHyprland"
+import battery from "./battery"
+import workspaces from "./workspaces"
+import volume from "./volume"
+import brightness from "./brightness"
+import client from "./client"
+import player from "./player"
+import bluetooth from "./bluetooth"
+
+const time = Variable("").poll(1000, "date +'%a %b %d · %H:%M'")
+
+export default function Bar(monitor: Hyprland.Monitor) {
+    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor
+
+    return <window
+        className="bar"
+		namespace="bar"
+		monitor={monitor.id}
+        exclusivity={Astal.Exclusivity.IGNORE}
+        anchor={TOP | LEFT | RIGHT}
+		heightRequest={36}
+		layer={Astal.Layer.TOP}
+        application={App}>
+        <centerbox>
+			<box>
+				{battery()}
+				{volume()}
+				{brightness()}
+				{bluetooth()}
+			</box>
+			{workspaces(monitor)}
+			<box halign={Gtk.Align.END}>
+				{player()}
+				{client()}
+				<button><box>
+					<label
+						className="innerButton"
+						label={time()}
+					/>
+				</box></button>
+			</box>
+        </centerbox>
+    </window>
+}
diff --git a/widget/battery.tsx b/widget/battery.tsx
new file mode 100644
index 0000000..efab899
--- /dev/null
+++ b/widget/battery.tsx
@@ -0,0 +1,154 @@
+import Battery from "gi://AstalBattery"
+import PowerProfiles from "gi://AstalPowerProfiles"
+import Hyprland from "gi://AstalHyprland"
+import { popup } from "./popup"
+import { Astal, Gtk, Widget } from "astal/gtk3"
+import { mergeBindings } from "/usr/share/astal/gjs/_astal"
+import { bind } from "astal"
+
+const hyprland = Hyprland.get_default()
+const batt = Battery.get_default()
+const powerProfiles = PowerProfiles.get_default()
+
+const percentage = bind(batt, "percentage").as((p) => `${Math.round(p*100)}%`)
+const charging = bind(batt, "charging")
+const toFull = bind(batt, "timeToFull").as((t) => t.toString())
+const toEmpty = bind(batt, "timeToEmpty").as((t) => t.toString())
+
+function profileButton(label: string, profile: string) {
+	return <button className="toggleButton" onClicked={(self) => {
+		powerProfiles.activeProfile = profile
+	}}>
+		<overlay overlay={new Widget.Box({
+				halign: Gtk.Align.END,
+				valign: Gtk.Align.CENTER,
+				className: bind(powerProfiles, "activeProfile").as((p) => 
+					(p === profile)
+						? "toggleIndicator active"
+						: "toggleIndicator inactive"
+				)
+			})}>
+			<label halign={Gtk.Align.START}>{label}</label>
+		</overlay>
+	</button>
+}
+
+function BattWindow() {
+	const { TOP, LEFT } = Astal.WindowAnchor
+	return <window
+		className="popupWindow"
+		namespace="lazerpopup"
+		monitor={hyprland.focusedMonitor.id}
+		anchor={TOP | LEFT}
+		layer={Astal.Layer.TOP}>
+		<box
+			className="popupBattery"
+			vertical={true}
+			spacing={8}>
+			<box spacing={10}>
+				<overlay overlay={new Widget.Label({
+					halign: Gtk.Align.CENTER,
+					valign: Gtk.Align.CENTER,
+					className: "percentage",
+					label: bind(batt, "energy").as(e => `${e}Wh`),
+				})}>
+					<levelbar
+						className="batteryLevel"
+						minValue={0}
+						maxValue={1}
+						inverted={true}
+						widthRequest={96}
+						vertical={true}
+						value={bind(batt, "percentage").as(c => c)}
+					/>
+				</overlay>
+				<box vertical={true} spacing={10}>
+					<overlay overlay={new Widget.Box({
+						halign: Gtk.Align.CENTER,
+						valign: Gtk.Align.CENTER,
+						vertical: true,
+						children: [
+							new Widget.Label({
+								className: "bigText",
+								label: bind(batt, "energyRate").as((w) => `${w}W`),
+							}),
+							new Widget.Label({
+								className: "smallText",
+								label: bind(batt, "charging").as(
+									(c) => c ? "Charging" : "Discharging"
+								),
+							}),
+						]
+					})}>
+						<box className="info" />
+					</overlay>
+					<overlay overlay={new Widget.Box({
+						halign: Gtk.Align.CENTER,
+						valign: Gtk.Align.CENTER,
+						vertical: true,
+						children: [
+							new Widget.Label({
+								className: "status",
+								label: mergeBindings([charging, toFull, toEmpty]).as(
+									(b) => {
+										let s = (b[0] ? b[1] : b[2])
+										return `${Math.floor(s/3600)}H ${Math.floor((s%3600)/60)}M`
+									}
+								),
+							}),
+							new Widget.Label({
+								className: "title",
+								label: charging.as(c => c ? "To full" : "To empty"),
+							}),
+						]
+					})}>
+						<box className="info" />
+					</overlay>
+				</box>
+			</box>
+			<box
+				vertical={true}>
+				{profileButton("Power Saver", "power-saver")}
+				{profileButton("Balanced", "balanced")}
+				{profileButton("Performance", "performance")}
+			</box>
+		</box>
+	</window>
+}
+
+export default function battery() {
+	return <button
+		className="battery"
+		halign={Gtk.Align.START}
+		onClicked={(self) => {
+			if (popup.state !== "battery") {
+				if (popup.window !== null) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.window = BattWindow();
+				popup.state = "battery"
+				self.toggleClassName("selected", true)
+				self.hook(popup.window, "destroy", () => {
+					self.toggleClassName("selected", false)
+				})
+			} else {
+				popup.window.destroy()
+				popup.window = null
+				popup.state = ""
+			}}}
+		><box>
+			<icon
+				valign={Gtk.Align.CENTER}
+				css="font-size: 24px; margin-right: 2px;"
+				icon={mergeBindings([charging, bind(powerProfiles, "activeProfile")]).as(
+					b => {
+						if (b[0]) return "battery-charging-symbolic"
+						return `${b[1]}-symbolic`
+					}
+				)}>
+			</icon>
+			<label css="margin-top: 2px;">{percentage}</label>
+		</box>
+	</button>
+}
diff --git a/widget/bluetooth.tsx b/widget/bluetooth.tsx
new file mode 100644
index 0000000..43a2365
--- /dev/null
+++ b/widget/bluetooth.tsx
@@ -0,0 +1,67 @@
+import { bind } from "astal"
+import Bluetooth from "gi://AstalBluetooth"
+import { popup } from "./popup"
+import { Astal, Gtk, Widget } from "astal/gtk3"
+
+const { TOP, LEFT } = Astal.WindowAnchor
+
+const bluetooth = Bluetooth.get_default()
+
+function bluetoothItem(device: Bluetooth.Device) {
+	return <button className="toggleButton">
+		<overlay overlay={new Widget.Box({
+			className: "toggleIndicator",
+			halign: Gtk.Align.END,
+			valign: Gtk.Align.CENTER,
+		})}>
+			<box>
+				<icon icon={device.icon} css="font-size: 32px;" />
+				<label>{device.alias ?? device.name}</label>
+			</box>
+		</overlay>
+	</button>
+}
+
+function bluetoothWindow() {
+	return <window
+		anchor={ TOP | LEFT }
+		marginLeft={170}
+		namespace="lazerpopup"
+		className="popupWindow">
+		<box vertical={true}>
+			{bluetooth.devices.map(dev => bluetoothItem(dev))}
+		</box>
+	</window>
+}
+
+export default function bluetoothWidget() {
+	return <button
+		onClicked={(self) => {
+			if (popup.state !== "bluetooth") {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.window = bluetoothWindow();
+				popup.state = "bluetooth"
+				self.toggleClassName("selected", true)
+				self.hook(popup.window, "destroy", () => {
+					self.toggleClassName("selected", false)
+				})
+			} else {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.state = ""
+			}
+		}}
+	><box>
+		<icon
+			icon={bind(bluetooth, "isConnected").as(c =>
+				c ? "lazer-bluetooth-symbolic" : "nobluetooth-symbolic"
+			)}
+			css="font-size: 24px;"
+		/>
+	</box></button>
+} 
diff --git a/widget/brightness.tsx b/widget/brightness.tsx
new file mode 100644
index 0000000..a185d5c
--- /dev/null
+++ b/widget/brightness.tsx
@@ -0,0 +1,125 @@
+import { bind, exec, execAsync, monitorFile, readFile, writeFile } from "astal"
+import { Astal, Gtk, Gdk, Widget } from "astal/gtk3";
+import { Box } from "astal/gtk3/widget";
+import { popup } from "./popup"
+const { TOP, LEFT } = Astal.WindowAnchor
+
+const backlight = "/sys/class/backlight/intel_backlight/brightness"
+
+function brightnessSlider(display) {
+	let slider: Widget.Slider = <box vertical={true} className="volSlider">
+		<box>
+			<icon 
+				icon="display"
+				css="font-size: 32px; margin-right: 6px;"
+			/>
+			<label>{display}</label>
+		</box>
+		<slider
+			halign={Gtk.Align.START}
+			valign={Gtk.Align.CENTER}
+			min={0}
+			max={19393}
+			value={Number(readFile(backlight))}
+			onDragged={(self) => {
+				exec(`brightnessctl s ${self.value}`)
+			}}
+			setup={(self) => {
+				/*
+				monitorFile(backlight, (file, event) => {
+					self.value = Number(readFile(file))
+				})
+				*/
+			}}
+		/>
+	</box>
+	return slider
+}
+
+function sunset() {
+	try {
+		exec("pgrep -x hyprsunset")
+		return true
+	}
+	catch (e) {
+		return false
+	}
+}
+
+function BrightWindow() {
+	let toggleIndicator: Box = <box 
+		halign={Gtk.Align.END}
+		valign={Gtk.Align.CENTER}
+		className={(sunset()) ? "toggleIndicator active" : "toggleIndicator inactive"}
+	/>  
+	return <window
+		className="popupWindow"
+		anchor={TOP | LEFT}
+		namespace="lazerpopup">
+		<box
+			vertical={true}
+			css="margin-left: 130px;">
+			{brightnessSlider("DP-1")}
+			<button 
+				className="toggleButton"
+				onClicked={(self) => {
+					toggleIndicator.toggleClassName("active", !sunset())
+					execAsync("/home/protoshark/.config/scripts/sunset-toggle.sh")
+						.then((out) => (console.log(out)))
+						.catch((out) => (console.log(out)))
+				}}	
+			><overlay overlay={toggleIndicator}>
+					<label halign={Gtk.Align.START}>Night Light</label>
+			</overlay></button>
+		</box>
+	</window>
+}
+
+export default function brightness() {
+	let brightnessBar = <levelbar
+		valign={Gtk.Align.CENTER}
+		vertical={true}
+		inverted={true}
+		minValue={0}
+		maxValue={19393}
+		heightRequest={24}
+		value={Number(readFile("/sys/class/backlight/intel_backlight/brightness"))}
+	/>
+	{monitorFile("/sys/class/backlight/intel_backlight/brightness", (file, event) => {
+		brightnessBar.value = readFile(file)
+	})}
+	return <button
+		className="scroller"
+		onScroll={(self, diff) => {
+			brightnessBar.value -= diff.delta_y*50
+			exec(`brightnessctl s ${brightnessBar.value}`)
+		}}
+		onClicked={(self) => {
+			if (popup.state !== "brightness") {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.window = BrightWindow();
+				popup.state = "brightness"
+				self.toggleClassName("selected", true)
+				self.hook(popup.window, "destroy", () => {
+					self.toggleClassName("selected", false)
+				})
+			} else {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.state = ""
+			}
+		}}>
+		<box>
+			<icon
+				icon="brightness-symbolic"
+				css="font-size: 22px; color: white;"
+			/>
+			{brightnessBar}
+		</box>
+	</button>
+}
diff --git a/widget/client.tsx b/widget/client.tsx
new file mode 100644
index 0000000..2d22123
--- /dev/null
+++ b/widget/client.tsx
@@ -0,0 +1,54 @@
+import { bind } from "astal"
+import Hyprland from "gi://AstalHyprland"
+import Apps from "gi://AstalApps"
+import { Gtk, Widget } from "astal/gtk3"
+import { Overlay } from "astal/gtk3/widget"
+const hyprland = Hyprland.get_default()
+const apps = new Apps.Apps()
+
+function NewClient(client: Hyprland.Client) {
+	apps.entryMultiplier = 10
+	let hyprClass = (client) ? apps.exact_query(client.class)[0] : null
+	let b = <box halign={Gtk.Align.END} className="clientLabel" visible={true}>
+		<icon 
+			icon={(client) ? hyprClass?.iconName : "archlinux"}
+			css="font-size: 24px; margin-right: 4px;"
+		/>
+		<label css="font-family: comfortaa; font-size: 14px;">{
+			(client) ? hyprClass?.name : "Hummingbird"
+		}</label>
+	</box>
+	return b
+}
+
+export default function client() {
+	let clientContainer = <box />
+	let clientOverlay: Overlay
+	clientOverlay = <overlay
+		overlays={[new Widget.Box(), NewClient(hyprland.focusedClient)]}
+		css={bind(hyprland, "focusedClient").as(c => {
+			let newClient = NewClient(c)
+			clientContainer.css = `min-width: ${newClient.get_preferred_width()[0]}px;`
+			if (clientOverlay) {
+				let os = clientOverlay.overlays
+				if (os[os.length-1].children[1].label === newClient.children[1].label) {
+					return ""
+				}
+				clientOverlay.add_overlay(newClient)
+				if (os.length > 2) {
+					os[os.length-1].css = "margin-top: 50px; opacity: 0;"
+				}
+				setTimeout(() => {
+					if (os.length > 2)
+						clientOverlay.remove(os[os.length-1])
+				}, 500)
+			}
+			return ""
+		})}
+		passThrough={true}>
+			{clientContainer}
+		</overlay>
+	return <button>
+		{clientOverlay}
+	</button>
+}
diff --git a/widget/player.tsx b/widget/player.tsx
new file mode 100644
index 0000000..353b776
--- /dev/null
+++ b/widget/player.tsx
@@ -0,0 +1,178 @@
+import { bind } from "astal"
+import { Astal, Gtk, Widget } from "astal/gtk3"
+import { Box, Button, Overlay } from "astal/gtk3/widget"
+import { popup } from "./popup"
+import Mpris from "gi://AstalMpris"
+
+const mpris = Mpris.get_default()
+const { TOP, RIGHT } = Astal.WindowAnchor
+
+let playerWindow
+
+function NewCover(coverPath: string) {
+	let b = <box
+		className="coverArt" 
+		halign={Gtk.Align.CENTER}
+		valign={Gtk.Align.CENTER}
+		css={`
+			background-image: url("${coverPath}");
+			background-size: contain;
+			background-color: transparent;
+		`}
+	>
+	</box>
+	return b
+}
+
+function cover(player: Mpris.Player) {
+	let coverContainer = <box />
+	let coverOverlay: Overlay
+	coverOverlay = <overlay
+		passThrough={true}
+		overlay={NewCover(player.coverArt)}
+		css={bind(player, "coverArt").as(coverPath => {
+			let newCover = NewCover(coverPath)
+			coverContainer.widthRequest = newCover.get_preferred_width()[0]
+			if (coverOverlay) {
+				coverOverlay.overlay = NewCover(player.coverArt)
+			}
+			return ""
+		})}
+	>
+		<box widthRequest={24} heightRequest={24}/>
+	</overlay>
+	return coverOverlay
+}
+
+function wrap(str: string) {
+	if (str.length > 40) {
+		str = str.substring(0, 40)
+	}
+	if (str.length > 20) {
+		return str.substring(0, 20) + "\n" + str.substring(20)
+	}
+	return str
+}
+
+function playerBox(player: Mpris.Player) {
+	return <box
+		vertical={true}
+		spacing={4}
+		>
+		<box
+			className="playerButton"
+			halign={Gtk.Align.CENTER}>
+			<button onClicked={() => {player.previous()}}>
+				<box>
+				<icon icon="lazer-previous-symbolic" css="font-size: 24px" />
+				</box>
+			</button>
+			<button onClicked={() => {player.play_pause()}}>
+				<box>
+				<icon icon={bind(player, "playbackStatus").as(p => 
+					(p === Mpris.PlaybackStatus.PLAYING) 
+						? "lazer-pause-symbolic" 
+						: "lazer-play-symbolic"
+				)} css="font-size: 24px;" />
+			</box>
+			</button>
+			<button onClicked={() => {player.next()}}>
+				<box>
+				<icon icon="lazer-next-symbolic" css="font-size: 24px;" />
+				</box>
+			</button>
+		</box>
+		<overlay overlay={
+			new Widget.Box({
+				vertical: true,
+				halign: Gtk.Align.CENTER,
+				valign: Gtk.Align.CENTER,
+				className: "playerLabel",
+				children: [
+					new Widget.Label({
+						className: "playerTitle",
+						justify: Gtk.Justification.CENTER,
+						label: bind(player, "title").as(str => wrap(str))
+					}),
+					new Widget.Label({
+						className: "playerArtist",
+						justify: Gtk.Justification.CENTER,
+						label: bind(player, "artist").as(str => wrap(str))
+					})
+				]
+			})
+		}>
+			<overlay overlay={
+				new Widget.Box({
+					halign: Gtk.Align.CENTER,
+					valign: Gtk.Align.CENTER,
+					className: "bigCoverShadow",
+				})
+			}>
+				<box 
+					className="bigCoverArt"
+					css={bind(player, "coverArt").as(c => {
+						return `background-image: url("${c}");`
+					})}>
+				</box>
+			</overlay>
+		</overlay>
+	</box>
+}
+
+function PlayerWindow() {
+	return <window
+		className="popupWindow"
+		anchor = {TOP | RIGHT}
+		namespace="lazerpopup"
+		marginRight={160}>
+		<box 
+			vertical={true}
+			spacing={12}
+			css="margin-left: 40px; margin-right: 40px; padding-top: 4px"
+		>
+			{mpris.players.map(p => playerBox(p))}
+		</box>
+	</window>
+}
+
+export default function player() {
+	let fillerBox = <box/>
+	let playerContainer = <label widthRequest={24} />
+	let playerButton: Button
+	playerButton = <button
+		visible={bind(mpris, "players").as(players => (players.length > 0))}
+		css="padding: 0 8px;"
+		onClicked={(self) => {
+			if (popup.state !== "player") {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.window = PlayerWindow();
+				popup.state = "player"
+				self.toggleClassName("selected", true)
+				self.hook(popup.window, "destroy", () => {
+					self.toggleClassName("selected", false)
+				})
+			} else {
+				if (popup.window) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.state = ""
+			}
+		}}
+	>
+		<box spacing={6}>
+			<icon icon="player-symbolic"
+		  	css="font-size: 24px;"/>
+			<overlay passThrough={true} overlay={bind(mpris, "players").as((ps) => {
+				return (ps.length > 0) ? cover(ps[0]) : fillerBox
+			})}>
+				{playerContainer}
+			</overlay>
+		</box>
+	</button>
+	return playerButton
+}
diff --git a/widget/popup.tsx b/widget/popup.tsx
new file mode 100644
index 0000000..595a058
--- /dev/null
+++ b/widget/popup.tsx
@@ -0,0 +1,8 @@
+import { Widget } from "astal/gtk3";
+
+let popup = {
+	window: null,
+	state: "",
+}
+
+export { popup }
diff --git a/widget/volume.tsx b/widget/volume.tsx
new file mode 100644
index 0000000..008c95d
--- /dev/null
+++ b/widget/volume.tsx
@@ -0,0 +1,99 @@
+import Wp from "gi://AstalWp"
+import Hyprland from "gi://AstalHyprland";
+import { bind } from "astal"
+import { Astal, Gtk, Gdk } from "astal/gtk3";
+import { popup } from "./popup"
+const { TOP, LEFT } = Astal.WindowAnchor
+
+const audio = Wp.get_default()?.audio;
+const hyprland = Hyprland.get_default()
+
+function speakerIcon(icon: string): string {
+	switch (icon) {
+		case "audio-headset-bluetooth":
+			return "audio-headset"
+		case "audio-card-analog-pci":
+			return "audio-speakers"
+		default:
+			return "speakers"
+	}
+}
+
+function speakerVolume(speaker: Wp.Endpoint) {
+	return <box vertical={true} className="volSlider">
+		<box>
+			<icon 
+				icon={speakerIcon(speaker.icon)}
+				css="font-size: 32px;"
+			/>
+			<label>{speaker.description}</label>
+		</box>
+		<slider
+			halign={Gtk.Align.START}
+			valign={Gtk.Align.CENTER}
+			min={0}
+			max={1}
+			value={bind(speaker, "volume").as((s) => {
+				return s
+			})}
+			onDragged={(self) => {
+				speaker.volume = self.value
+			}}
+		/>
+	</box>
+}
+
+function VolWindow() {
+	return <window
+		className="popupWindow"
+		anchor={TOP | LEFT}
+		namespace="lazerpopup">
+		<box
+			vertical={true}
+			css="margin-left: 70px;">
+			{bind(audio, "speakers").as(speakers => speakers.map(s => speakerVolume(s)))}
+		</box>
+	</window>
+}
+
+export default function volume() {
+	return <button
+		className="scroller"
+		onScroll={(self, diff) => {
+			audio.defaultSpeaker.volume -= diff.delta_y/20
+		}}
+		onClicked={(self) => {
+			if (popup.state !== "volume") {
+				if (popup.window !== null) {
+					popup.window.destroy()
+					popup.window = null
+				}
+				popup.window = VolWindow();
+				popup.state = "volume"
+				self.toggleClassName("selected", true)
+				self.hook(popup.window, "destroy", () => {
+					self.toggleClassName("selected", false)
+				})
+			} else {
+				popup.window.destroy()
+				popup.window = null
+				popup.state = ""
+			}}}
+		>
+		<box>
+			<icon
+				icon="myvolume-symbolic"
+				css="font-size: 24px; color: white;"
+			/>
+			<levelbar
+				valign={Gtk.Align.CENTER}
+				vertical={true}
+				inverted={true}
+				minValue={0}
+				maxValue={1}
+				heightRequest={24}
+				value={bind(audio.defaultSpeaker, "volume").as((v) => v)}
+			/>
+		</box>
+	</button>
+}
diff --git a/widget/workspaces.tsx b/widget/workspaces.tsx
new file mode 100644
index 0000000..b977535
--- /dev/null
+++ b/widget/workspaces.tsx
@@ -0,0 +1,59 @@
+import { bind } from "astal"
+import { Gdk, Gtk, Widget } from "astal/gtk3"
+import Hyprland from "gi://AstalHyprland"
+
+const hyprland = Hyprland.get_default()
+
+function newWorkspace(ws: number, monitor: number) {
+	return <overlay
+		halign={Gtk.Align.START}
+		overlays={[
+			new Widget.Button({
+				className: "workspaceButton",
+				visible: true,
+				onClick: () => {
+					hyprland.dispatch("workspace", ws.toString())
+				}
+			}, new Widget.Box({
+				halign: Gtk.Align.FILL,
+				valign: Gtk.Align.FILL,
+			}, new Widget.Box({
+				valign: Gtk.Align.CENTER,
+				halign: Gtk.Align.CENTER,
+				className: bind(hyprland, "workspaces").as(wss => {
+						let myws = wss.find(w => w.id === ws)
+						return (myws !== undefined && myws.monitor.id === monitor)
+							? "active" : "inactive"
+				}),
+				css: bind(hyprland, "focusedWorkspace").as(fws => {
+					return (fws.id === ws)
+						? "border-color: #00ffaa"
+						: "border-color: #ffffff"
+				})
+			}))),
+		]}>
+		<box className="workspaceContainer" />
+	</overlay>
+}
+
+export default function workspaces(monitor: Hyprland.Monitor) {
+	return <overlay
+		overlay={new Widget.Box({
+			halign: Gtk.Align.START,
+			valign: Gtk.Align.END,
+			className: "workspaceIndicator",
+			css: bind(hyprland, "focusedWorkspace").as(ws => {
+				return "margin-left: " + (24+(ws.id-1)*32) + "px;"
+			})
+		})}>
+		<box
+			className="workspaces"
+			halign={Gtk.Align.START}
+			visible={true}
+			setup={(self) => {
+				for (let i = 1; i <= 9; i++) {
+					self.add(newWorkspace(i, monitor.id))
+				}
+			}}/>
+	</overlay>
+}