vite-plugin-vue-devtools 0.0.1-alpha.0 → 0.0.1-alpha.1

package/dist/client/assets/assets-d5f2037f.js

@@ -0,0 +1,1403 @@
+import { _ as __unplugin_components_0 } from './VPanelGrids-0fa9ab66.js';
+import { _ as __unplugin_components_7 } from './VCard-71dc6c0a.js';
+import { _ as _sfc_main$a } from './VIcon.vue_vue_type_script_setup_true_lang-527d8187.js';
+import { d as defineComponent, o as openBlock, a as createBlock, w as withCtx, b as createVNode, an as mergeProps, ao as resolveDynamicComponent, P as ref, ap as useElementSize, aq as onClickOutside, c as createElementBlock, e as createBaseVNode, v as renderSlot, u as unref, m as createCommentVNode, ar as Transition, Q as computed, t as toDisplayString, n as normalizeClass, as as useStyleTag, N as normalizeStyle, at as computedAsync, au as useTimeAgo, F as Fragment, E as createTextVNode, _ as _sfc_main$b, av as onKeyDown, z as isRef, r as renderList } from './index-bed0f7d1.js';
+import { r as rpc } from './rpc-9c16d07a.js';
+import { _ as _sfc_main$c, a as __unplugin_components_3 } from './VTextInput.vue_vue_type_script_setup_true_lang-3269f8e0.js';
+import { F as Fuse } from './fuse.esm-c317b696.js';
+import './VIconTitle.vue_vue_type_script_setup_true_lang-e9a02b1e.js';
+
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "VIconButton",
+  props: {
+    to: null,
+    icon: null
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      const _component_VIcon = _sfc_main$a;
+      return openBlock(), createBlock(resolveDynamicComponent(__props.to ? "a" : "button"), mergeProps({ href: __props.to }, _ctx.$attrs, { class: "n-transition n-icon-button" }), {
+        default: withCtx(() => [
+          createVNode(_component_VIcon, {
+            icon: props.icon
+          }, null, 8, ["icon"])
+        ]),
+        _: 1
+      }, 16, ["href"]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$7 = {
+  relative: "",
+  "h-full": "",
+  "w-full": "",
+  "of-auto": ""
+};
+const __default__ = {
+  inheritAttrs: false
+};
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "DrawerRight",
+  props: {
+    modelValue: { type: Boolean },
+    navbar: null,
+    autoClose: { type: Boolean }
+  },
+  emits: ["close"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const el = ref();
+    const { height: top } = useElementSize(() => props.navbar, void 0, { box: "border-box" });
+    onClickOutside(el, () => {
+      if (props.modelValue && props.autoClose)
+        emit("close");
+    }, {
+      ignore: ["a", "button", "summary"]
+    });
+    return (_ctx, _cache) => {
+      const _component_VIconButton = _sfc_main$9;
+      return openBlock(), createBlock(Transition, {
+        "enter-active-class": "duration-200 ease-in",
+        "enter-from-class": "transform translate-x-1/1",
+        "enter-to-class": "opacity-100",
+        "leave-active-class": "duration-200 ease-out",
+        "leave-from-class": "opacity-100",
+        "leave-to-class": "transform translate-x-1/1"
+      }, {
+        default: withCtx(() => [
+          __props.modelValue ? (openBlock(), createElementBlock("div", mergeProps({
+            key: 0,
+            ref_key: "el",
+            ref: el,
+            border: "l base",
+            flex: "~ col gap-1",
+            absolute: "",
+            "bottom-0": "",
+            "right-0": "",
+            "z-10": "",
+            "z-20": "",
+            "of-auto": "",
+            "text-sm": "",
+            "glass-effect": "",
+            style: { top: `${unref(top)}px` }
+          }, _ctx.$attrs), [
+            createVNode(_component_VIconButton, {
+              absolute: "",
+              "right-2": "",
+              "top-2": "",
+              "z-20": "",
+              "text-xl": "",
+              icon: "carbon-close",
+              onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("close"))
+            }),
+            createBaseVNode("div", _hoisted_1$7, [
+              renderSlot(_ctx.$slots, "default")
+            ])
+          ], 16)) : createCommentVNode("", true)
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$6 = ["title"];
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "FilepathItem",
+  props: {
+    filepath: null,
+    lineBreak: { type: Boolean },
+    subpath: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const parsed = computed(
+      () => ({ path: props.filepath })
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        "font-mono": "",
+        "hover:underline": "",
+        class: normalizeClass(__props.lineBreak ? "" : "ws-nowrap of-hidden truncate"),
+        title: __props.filepath
+      }, toDisplayString(unref(parsed).path), 11, _hoisted_1$6);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const defaults = {
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false
+};
+function objectHash(object, options = {}) {
+  options = { ...defaults, ...options };
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+function createHasher(options) {
+  const buff = [];
+  let context = [];
+  const write = (str) => {
+    buff.push(str);
+  };
+  return {
+    toString() {
+      return buff.join("");
+    },
+    getContext() {
+      return context;
+    },
+    dispatch(value) {
+      if (options.replacer) {
+        value = options.replacer(value);
+      }
+      const type = value === null ? "null" : typeof value;
+      return this["_" + type](value);
+    },
+    _object(object) {
+      if (object && typeof object.toJSON === "function") {
+        return this._object(object.toJSON());
+      }
+      const pattern = /\[object (.*)]/i;
+      const objString = Object.prototype.toString.call(object);
+      const _objType = pattern.exec(objString);
+      const objType = _objType ? _objType[1].toLowerCase() : "unknown:[" + objString.toLowerCase() + "]";
+      let objectNumber = null;
+      if ((objectNumber = context.indexOf(object)) >= 0) {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      } else {
+        context.push(object);
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        write("buffer:");
+        return write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this["_" + objType]) {
+          this["_" + objType](object);
+        } else if (!options.ignoreUnknown) {
+          this._unkown(object, objType);
+        }
+      } else {
+        let keys = Object.keys(object);
+        if (options.unorderedObjects) {
+          keys = keys.sort();
+        }
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          keys.splice(0, 0, "prototype", "__proto__", "letructor");
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter(function(key) {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + keys.length + ":");
+        for (const key of keys) {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        }
+      }
+    },
+    _array(arr, unordered) {
+      unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = [];
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        contextAdditions.push(hasher.getContext());
+        return hasher.toString();
+      });
+      context = [...context, ...contextAdditions];
+      entries.sort();
+      return this._array(entries, false);
+    },
+    _date(date) {
+      return write("date:" + date.toJSON());
+    },
+    _symbol(sym) {
+      return write("symbol:" + sym.toString());
+    },
+    _unkown(value, type) {
+      write(type);
+      if (!value) {
+        return;
+      }
+      write(":");
+      if (value && typeof value.entries === "function") {
+        return this._array(
+          Array.from(value.entries()),
+          true
+          /* ordered */
+        );
+      }
+    },
+    _error(err) {
+      return write("error:" + err.toString());
+    },
+    _boolean(bool) {
+      return write("bool:" + bool.toString());
+    },
+    _string(string) {
+      write("string:" + string.length + ":");
+      write(string.toString());
+    },
+    _function(fn) {
+      write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+      if (options.respectFunctionNames !== false) {
+        this.dispatch("function-name:" + String(fn.name));
+      }
+      if (options.respectFunctionProperties) {
+        this._object(fn);
+      }
+    },
+    _number(number) {
+      return write("number:" + number.toString());
+    },
+    _xml(xml) {
+      return write("xml:" + xml.toString());
+    },
+    _null() {
+      return write("Null");
+    },
+    _undefined() {
+      return write("Undefined");
+    },
+    _regexp(regex) {
+      return write("regex:" + regex.toString());
+    },
+    _uint8array(arr) {
+      write("uint8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint8clampedarray(arr) {
+      write("uint8clampedarray:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int8array(arr) {
+      write("int8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint16array(arr) {
+      write("uint16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int16array(arr) {
+      write("int16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint32array(arr) {
+      write("uint32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int32array(arr) {
+      write("int32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float32array(arr) {
+      write("float32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float64array(arr) {
+      write("float64array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _arraybuffer(arr) {
+      write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    },
+    _url(url) {
+      return write("url:" + url.toString());
+    },
+    _map(map) {
+      write("map:");
+      const arr = [...map];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _set(set) {
+      write("set:");
+      const arr = [...set];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _file(file) {
+      write("file:");
+      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+    },
+    _blob() {
+      if (options.ignoreUnknown) {
+        return write("[blob]");
+      }
+      throw new Error(
+        'Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n'
+      );
+    },
+    _domwindow() {
+      return write("domwindow");
+    },
+    _bigint(number) {
+      return write("bigint:" + number.toString());
+    },
+    /* Node.js standard native objects */
+    _process() {
+      return write("process");
+    },
+    _timer() {
+      return write("timer");
+    },
+    _pipe() {
+      return write("pipe");
+    },
+    _tcp() {
+      return write("tcp");
+    },
+    _udp() {
+      return write("udp");
+    },
+    _tty() {
+      return write("tty");
+    },
+    _statwatcher() {
+      return write("statwatcher");
+    },
+    _securecontext() {
+      return write("securecontext");
+    },
+    _connection() {
+      return write("connection");
+    },
+    _zlib() {
+      return write("zlib");
+    },
+    _context() {
+      return write("context");
+    },
+    _nodescript() {
+      return write("nodescript");
+    },
+    _httpparser() {
+      return write("httpparser");
+    },
+    _dataview() {
+      return write("dataview");
+    },
+    _signal() {
+      return write("signal");
+    },
+    _fsevent() {
+      return write("fsevent");
+    },
+    _tlswrap() {
+      return write("tlswrap");
+    }
+  };
+}
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  const exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code]\s+}$/i;
+  return exp.exec(Function.prototype.toString.call(f)) != null;
+}
+
+class WordArray {
+  constructor(words, sigBytes) {
+    words = this.words = words || [];
+    this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 4;
+  }
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let j = 0; j < wordArray.sigBytes; j += 4) {
+        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  clone() {
+    return new WordArray([...this.words]);
+  }
+}
+const Hex = {
+  stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));
+    }
+    return hexChars.join("");
+  }
+};
+const Base64 = {
+  stringify(wordArray) {
+    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
+        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    return base64Chars.join("");
+  }
+};
+const Latin1 = {
+  parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+};
+const Utf8 = {
+  parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+};
+class BufferedBlockAlgorithm {
+  constructor() {
+    this._minBufferSize = 0;
+    this.blockSize = 512 / 32;
+    this.reset();
+  }
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _doProcessBlock(_dataWords, _offset) {
+  }
+  _process(doFlush) {
+    let processedWords;
+    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+}
+class Hasher extends BufferedBlockAlgorithm {
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+  }
+}
+
+const H = [
+  1779033703,
+  -1150833019,
+  1013904242,
+  -1521486534,
+  1359893119,
+  -1694144372,
+  528734635,
+  1541459225
+];
+const K = [
+  1116352408,
+  1899447441,
+  -1245643825,
+  -373957723,
+  961987163,
+  1508970993,
+  -1841331548,
+  -1424204075,
+  -670586216,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  -2132889090,
+  -1680079193,
+  -1046744716,
+  -459576895,
+  -272742522,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  -1740746414,
+  -1473132947,
+  -1341970488,
+  -1084653625,
+  -958395405,
+  -710438585,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  -2117940946,
+  -1838011259,
+  -1564481375,
+  -1474664885,
+  -1035236496,
+  -949202525,
+  -778901479,
+  -694614492,
+  -200395387,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  -2067236844,
+  -1933114872,
+  -1866530822,
+  -1538233109,
+  -1090935817,
+  -965641998
+];
+const W = [];
+class SHA256 extends Hasher {
+  constructor() {
+    super();
+    this.reset();
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray([...H]);
+  }
+  _doProcessBlock(M, offset) {
+    const H2 = this._hash.words;
+    let a = H2[0];
+    let b = H2[1];
+    let c = H2[2];
+    let d = H2[3];
+    let e = H2[4];
+    let f = H2[5];
+    let g = H2[6];
+    let h = H2[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = M[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    H2[0] = H2[0] + a | 0;
+    H2[1] = H2[1] + b | 0;
+    H2[2] = H2[2] + c | 0;
+    H2[3] = H2[3] + d | 0;
+    H2[4] = H2[4] + e | 0;
+    H2[5] = H2[5] + f | 0;
+    H2[6] = H2[6] + g | 0;
+    H2[7] = H2[7] + h | 0;
+  }
+  finalize(messageUpdate) {
+    super.finalize(messageUpdate);
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(
+      nBitsTotal / 4294967296
+    );
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+}
+function sha256base64(message) {
+  return new SHA256().finalize(message).toString(Base64);
+}
+
+function hash(object, options = {}) {
+  const hashed = typeof object === "string" ? object : objectHash(object, options);
+  return sha256base64(hashed).slice(0, 10);
+}
+
+/* Injected with object hook! */
+
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "AssetFontPreview",
+  props: {
+    asset: null
+  },
+  setup(__props) {
+    const props = __props;
+    const id = computed(() => `devtools-assets-${hash(props.asset)}`);
+    useStyleTag(computed(() => `
+  @font-face {
+    font-family: '${id.value}';
+    src: url('${props.asset.publicPath}');
+  }
+`));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        "of-hidden": "",
+        style: normalizeStyle({ fontFamily: `'${unref(id)}'` })
+      }, " Aa Bb Cc Dd Ee Ff Gg Hh Ii Jj Kk Ll Mm Nn Oo Pp Qq Rr Ss Tt Uu Vv Ww Xx Yy Zz ", 4);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$5 = {
+  flex: "",
+  "items-center": "",
+  "justify-center": "",
+  "of-hidden": "",
+  "bg-active": "",
+  "object-cover": "",
+  p1: ""
+};
+const _hoisted_2$4 = ["src"];
+const _hoisted_3$2 = {
+  key: 2,
+  "i-carbon-document": "",
+  "text-3xl": "",
+  op20: ""
+};
+const _hoisted_4$2 = {
+  key: 3,
+  "w-full": "",
+  "self-start": "",
+  p4: ""
+};
+const _hoisted_5$2 = ["textContent"];
+const _hoisted_6$2 = {
+  key: 4,
+  "i-carbon-help": "",
+  "text-3xl": "",
+  op20: ""
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "AssetPreview",
+  props: {
+    asset: null,
+    textContent: null
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      const _component_AssetFontPreview = _sfc_main$6;
+      return openBlock(), createElementBlock("div", _hoisted_1$5, [
+        __props.asset.type === "image" ? (openBlock(), createElementBlock("img", {
+          key: 0,
+          src: __props.asset.publicPath
+        }, null, 8, _hoisted_2$4)) : __props.asset.type === "font" ? (openBlock(), createBlock(_component_AssetFontPreview, {
+          key: __props.asset.publicPath,
+          asset: __props.asset,
+          "self-stretch": "",
+          p2: "",
+          "text-2xl": ""
+        }, null, 8, ["asset"])) : __props.asset.type === "text" && !__props.textContent ? (openBlock(), createElementBlock("div", _hoisted_3$2)) : __props.asset.type === "text" && __props.textContent ? (openBlock(), createElementBlock("div", _hoisted_4$2, [
+          createBaseVNode("pre", {
+            "max-h-10rem": "",
+            "of-hidden": "",
+            "font-mono": "",
+            "text-xs": "",
+            textContent: toDisplayString(__props.textContent)
+          }, null, 8, _hoisted_5$2)
+        ])) : (openBlock(), createElementBlock("div", _hoisted_6$2))
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$4 = {
+  flex: "~ col gap-4",
+  "min-h-full": "",
+  "w-full": "",
+  "of-hidden": "",
+  p4: ""
+};
+const _hoisted_2$3 = /* @__PURE__ */ createBaseVNode("div", {
+  flex: "~ gap2",
+  "mb--2": "",
+  "items-center": "",
+  op50: ""
+}, [
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" }),
+  /* @__PURE__ */ createBaseVNode("div", { "flex-none": "" }, " Preview "),
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" })
+], -1);
+const _hoisted_3$1 = {
+  flex: "~",
+  "items-center": "",
+  "justify-center": ""
+};
+const _hoisted_4$1 = /* @__PURE__ */ createBaseVNode("div", {
+  flex: "~ gap2",
+  "mb--2": "",
+  "items-center": "",
+  op50: ""
+}, [
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" }),
+  /* @__PURE__ */ createBaseVNode("div", { "flex-none": "" }, " Details "),
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" })
+], -1);
+const _hoisted_5$1 = {
+  "max-w-full": "",
+  "w-full": "",
+  "table-fixed": ""
+};
+const _hoisted_6$1 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Filepath ", -1);
+const _hoisted_7$1 = {
+  flex: "~ gap-1",
+  "w-full": "",
+  "items-center": ""
+};
+const _hoisted_8$1 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Public Path ", -1);
+const _hoisted_9 = {
+  flex: "~ gap-1",
+  "w-full": "",
+  "items-center": "",
+  "of-hidden": ""
+};
+const _hoisted_10 = {
+  "flex-auto": "",
+  "of-hidden": "",
+  truncate: "",
+  "ws-pre": "",
+  "font-mono": ""
+};
+const _hoisted_11 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Type ", -1);
+const _hoisted_12 = { capitalize: "" };
+const _hoisted_13 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Image Size ", -1);
+const _hoisted_14 = { key: 0 };
+const _hoisted_15 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Aspect Ratio ", -1);
+const _hoisted_16 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " File size ", -1);
+const _hoisted_17 = /* @__PURE__ */ createBaseVNode("td", {
+  "w-30": "",
+  "ws-nowrap": "",
+  pr5: "",
+  "text-right": "",
+  op50: ""
+}, " Last modified ", -1);
+const _hoisted_18 = { op70: "" };
+const _hoisted_19 = /* @__PURE__ */ createBaseVNode("div", {
+  flex: "~ gap2",
+  "mb--2": "",
+  "items-center": "",
+  op50: ""
+}, [
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" }),
+  /* @__PURE__ */ createBaseVNode("div", { "flex-none": "" }, " Actions "),
+  /* @__PURE__ */ createBaseVNode("div", { "x-divider": "" })
+], -1);
+const _hoisted_20 = { flex: "~ gap2 wrap" };
+const _hoisted_21 = /* @__PURE__ */ createBaseVNode("div", { "flex-auto": "" }, null, -1);
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "AssetDetails",
+  props: {
+    asset: null
+  },
+  setup(__props) {
+    const props = __props;
+    const origin = window.parent.location.origin;
+    const imageMeta = computedAsync(() => {
+      if (props.asset.type !== "image")
+        return void 0;
+      return rpc.getImageMeta(props.asset.filePath);
+    });
+    const textContent = computedAsync(() => {
+      if (props.asset.type !== "text")
+        return void 0;
+      return rpc.getTextAssetContent(props.asset.filePath);
+    });
+    const timeago = useTimeAgo(() => props.asset.mtime);
+    const fileSize = computed(() => {
+      const size = props.asset.size;
+      if (size < 1024)
+        return `${size} B`;
+      if (size < 1024 * 1024)
+        return `${(size / 1024).toFixed(2)} KB`;
+      return `${(size / 1024 / 1024).toFixed(2)} MB`;
+    });
+    const aspectRatio = computed(() => {
+      if (!imageMeta.value?.width || !imageMeta.value?.height)
+        return "";
+      const gcd = (a, b) => {
+        if (!b)
+          return a;
+        return gcd(b, a % b);
+      };
+      const ratio = gcd(imageMeta.value.width, imageMeta.value.height);
+      if (ratio > 3)
+        return `${imageMeta.value.width / ratio}:${imageMeta.value.height / ratio}`;
+      return "";
+    });
+    const supportsPreview = computed(() => {
+      return [
+        "image",
+        "text",
+        "video",
+        "font"
+      ].includes(props.asset.type);
+    });
+    return (_ctx, _cache) => {
+      const _component_AssetPreview = _sfc_main$5;
+      const _component_FilepathItem = _sfc_main$7;
+      const _component_VIconButton = _sfc_main$9;
+      const _component_VButton = _sfc_main$b;
+      return openBlock(), createElementBlock("div", _hoisted_1$4, [
+        unref(supportsPreview) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          _hoisted_2$3,
+          createBaseVNode("div", _hoisted_3$1, [
+            createVNode(_component_AssetPreview, {
+              "max-h-80": "",
+              "min-h-20": "",
+              "min-w-20": "",
+              "w-auto": "",
+              rounded: "",
+              border: "~ base",
+              asset: __props.asset,
+              "text-content": unref(textContent)
+            }, null, 8, ["asset", "text-content"])
+          ])
+        ], 64)) : createCommentVNode("", true),
+        _hoisted_4$1,
+        createBaseVNode("table", _hoisted_5$1, [
+          createBaseVNode("tbody", null, [
+            createBaseVNode("tr", null, [
+              _hoisted_6$1,
+              createBaseVNode("td", null, [
+                createBaseVNode("div", _hoisted_7$1, [
+                  createVNode(_component_FilepathItem, {
+                    filepath: __props.asset.filePath,
+                    "text-left": ""
+                  }, null, 8, ["filepath"])
+                ])
+              ])
+            ]),
+            createBaseVNode("tr", null, [
+              _hoisted_8$1,
+              createBaseVNode("td", null, [
+                createBaseVNode("div", _hoisted_9, [
+                  createBaseVNode("div", _hoisted_10, toDisplayString(__props.asset.publicPath), 1),
+                  createVNode(_component_VIconButton, {
+                    "flex-none": "",
+                    to: `${unref(origin)}${__props.asset.publicPath}`,
+                    icon: "carbon-launch",
+                    target: "_blank",
+                    title: "Open in browser"
+                  }, null, 8, ["to"])
+                ])
+              ])
+            ]),
+            createBaseVNode("tr", null, [
+              _hoisted_11,
+              createBaseVNode("td", _hoisted_12, toDisplayString(__props.asset.type), 1)
+            ]),
+            unref(imageMeta)?.width ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+              createBaseVNode("tr", null, [
+                _hoisted_13,
+                createBaseVNode("td", null, toDisplayString(unref(imageMeta).width) + " x " + toDisplayString(unref(imageMeta).height), 1)
+              ]),
+              unref(aspectRatio) ? (openBlock(), createElementBlock("tr", _hoisted_14, [
+                _hoisted_15,
+                createBaseVNode("td", null, toDisplayString(unref(aspectRatio)), 1)
+              ])) : createCommentVNode("", true)
+            ], 64)) : createCommentVNode("", true),
+            createBaseVNode("tr", null, [
+              _hoisted_16,
+              createBaseVNode("td", null, toDisplayString(unref(fileSize)), 1)
+            ]),
+            createBaseVNode("tr", null, [
+              _hoisted_17,
+              createBaseVNode("td", null, [
+                createTextVNode(toDisplayString(new Date(__props.asset.mtime).toLocaleString()) + " ", 1),
+                createBaseVNode("span", _hoisted_18, "(" + toDisplayString(unref(timeago)) + ")", 1)
+              ])
+            ])
+          ])
+        ]),
+        _hoisted_19,
+        createBaseVNode("div", _hoisted_20, [
+          createVNode(_component_VButton, {
+            to: `${unref(origin)}${__props.asset.publicPath}`,
+            download: "",
+            target: "_blank",
+            icon: "carbon-download"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(" Download ")
+            ]),
+            _: 1
+          }, 8, ["to"])
+        ]),
+        _hoisted_21
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$3 = {
+  flex: "~ gap-1",
+  "w-full": "",
+  "items-center": "",
+  hover: "bg-active",
+  rounded: "",
+  px4: "",
+  py2: ""
+};
+const _hoisted_2$2 = {
+  "of-hidden": "",
+  truncate: "",
+  "ws-nowrap": "",
+  "text-center": ""
+};
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "AssetListItem",
+  props: {
+    asset: null
+  },
+  setup(__props) {
+    const props = __props;
+    const icon = computed(() => {
+      if (props.asset.type === "image")
+        return "i-carbon-image";
+      if (props.asset.type === "video")
+        return "i-carbon-video";
+      if (props.asset.type === "audio")
+        return "i-carbon-volume-up";
+      if (props.asset.type === "font")
+        return "i-carbon-text-small-caps";
+      if (props.asset.type === "text")
+        return "i-carbon-document";
+      if (props.asset.type === "json")
+        return "i-carbon-json";
+      return "i-carbon-document-blank";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", _hoisted_1$3, [
+        createBaseVNode("div", {
+          class: normalizeClass(unref(icon))
+        }, null, 2),
+        createBaseVNode("div", _hoisted_2$2, toDisplayString(__props.asset.path), 1)
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$2 = {
+  flex: "~ col gap-1",
+  hover: "bg-active",
+  "items-center": "",
+  "of-hidden": "",
+  rounded: "",
+  p2: ""
+};
+const _hoisted_2$1 = {
+  "w-full": "",
+  "of-hidden": "",
+  truncate: "",
+  "ws-nowrap": "",
+  "text-center": "",
+  "text-xs": ""
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "AssetGridItem",
+  props: {
+    asset: null,
+    folder: null
+  },
+  setup(__props) {
+    const props = __props;
+    const path = computed(() => {
+      if (props.folder && props.asset.path.startsWith(props.folder))
+        return props.asset.path.slice(props.folder.length);
+      return props.asset.path;
+    });
+    return (_ctx, _cache) => {
+      const _component_AssetPreview = _sfc_main$5;
+      return openBlock(), createElementBlock("button", _hoisted_1$2, [
+        createVNode(_component_AssetPreview, {
+          "h-30": "",
+          "w-30": "",
+          rounded: "",
+          border: "~ base",
+          asset: __props.asset
+        }, null, 8, ["asset"]),
+        createBaseVNode("div", _hoisted_2$1, toDisplayString(unref(path)), 1)
+      ]);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1$1 = { flex: "~ gap4" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "Navbar",
+  props: {
+    search: {
+      type: String,
+      default: void 0
+    },
+    noPadding: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:search"],
+  setup(__props, { emit }) {
+    function update(event) {
+      emit("update:search", event.target.value);
+    }
+    return (_ctx, _cache) => {
+      const _component_VTextInput = _sfc_main$c;
+      return openBlock(), createElementBlock("div", {
+        flex: "~ col gap2",
+        border: "b base",
+        "flex-1": "",
+        "navbar-glass": "",
+        class: normalizeClass([{ p4: !__props.noPadding }])
+      }, [
+        createBaseVNode("div", _hoisted_1$1, [
+          renderSlot(_ctx.$slots, "search", {}, () => [
+            createVNode(_component_VTextInput, {
+              placeholder: "Search...",
+              icon: "carbon-search",
+              n: "primary",
+              "flex-auto": "",
+              class: normalizeClass({ "px-5 py-2": !__props.noPadding }),
+              value: __props.search,
+              onInput: update
+            }, null, 8, ["class", "value"])
+          ]),
+          renderSlot(_ctx.$slots, "actions")
+        ]),
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+const _hoisted_1 = {
+  key: 0,
+  "h-full": "",
+  "of-auto": "",
+  "n-panel-grids": ""
+};
+const _hoisted_2 = {
+  "flex-none": "",
+  flex: "~ gap4"
+};
+const _hoisted_3 = { op50: "" };
+const _hoisted_4 = { key: 0 };
+const _hoisted_5 = {
+  "mt--4": "",
+  px2: "",
+  grid: "~ cols-minmax-8rem"
+};
+const _hoisted_6 = {
+  key: 1,
+  p2: "",
+  grid: "~ cols-minmax-8rem"
+};
+const _hoisted_7 = { key: 1 };
+const _hoisted_8 = /* @__PURE__ */ createBaseVNode("h1", {
+  "text-sm": "",
+  italic: "",
+  op50: ""
+}, " No Assets ", -1);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "assets",
+  setup(__props) {
+    const assets = ref([]);
+    async function getAssets() {
+      assets.value = await rpc.staticAssets();
+    }
+    getAssets();
+    const search = ref("");
+    const fuse = computed(() => new Fuse(assets.value || [], {
+      keys: [
+        "path"
+      ]
+    }));
+    const filtered = computed(() => {
+      const result = search.value ? fuse.value.search(search.value).map((i) => i.item) : assets.value || [];
+      return result;
+    });
+    const byFolders = computed(() => {
+      const result = {};
+      for (const asset of filtered.value) {
+        const folder = `${asset.path.split("/").slice(0, -1).join("/")}/`;
+        if (!result[folder])
+          result[folder] = [];
+        result[folder].push(asset);
+      }
+      return Object.entries(result).sort(([a], [b]) => a.localeCompare(b));
+    });
+    const selected = ref();
+    const view = ref("grid");
+    function toggleView() {
+      view.value = view.value === "list" ? "grid" : "list";
+    }
+    onKeyDown("Escape", () => {
+      selected.value = void 0;
+    });
+    const navbar = ref();
+    return (_ctx, _cache) => {
+      const _component_VIcon = _sfc_main$a;
+      const _component_Navbar = _sfc_main$1;
+      const _component_AssetGridItem = _sfc_main$2;
+      const _component_VSectionBlock = __unplugin_components_3;
+      const _component_AssetListItem = _sfc_main$3;
+      const _component_AssetDetails = _sfc_main$4;
+      const _component_DrawerRight = _sfc_main$8;
+      const _component_VCard = __unplugin_components_7;
+      const _component_VPanelGrids = __unplugin_components_0;
+      return unref(assets)?.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_component_Navbar, {
+          ref_key: "navbar",
+          ref: navbar,
+          search: unref(search),
+          "onUpdate:search": _cache[0] || (_cache[0] = ($event) => isRef(search) ? search.value = $event : null),
+          pb2: ""
+        }, {
+          actions: withCtx(() => [
+            createBaseVNode("div", _hoisted_2, [
+              createBaseVNode("button", {
+                title: "Toggle view",
+                onClick: toggleView
+              }, [
+                unref(view) === "grid" ? (openBlock(), createBlock(_component_VIcon, {
+                  key: 0,
+                  icon: "i-carbon-list"
+                })) : (openBlock(), createBlock(_component_VIcon, {
+                  key: 1,
+                  icon: "i-carbon-grid"
+                }))
+              ])
+            ])
+          ]),
+          default: withCtx(() => [
+            createBaseVNode("div", _hoisted_3, [
+              unref(search) ? (openBlock(), createElementBlock("span", _hoisted_4, toDisplayString(unref(filtered).length) + " matched · ", 1)) : createCommentVNode("", true),
+              createBaseVNode("span", null, toDisplayString(unref(assets)?.length) + " assets in total", 1)
+            ])
+          ]),
+          _: 1
+        }, 8, ["search"]),
+        unref(view) === "grid" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          unref(byFolders).length > 1 ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(byFolders), ([folder, items]) => {
+            return openBlock(), createBlock(_component_VSectionBlock, {
+              key: folder,
+              text: folder,
+              description: `${items.length} items`,
+              open: items.length <= 20,
+              padding: false
+            }, {
+              default: withCtx(() => [
+                createBaseVNode("div", _hoisted_5, [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(items, (a) => {
+                    return openBlock(), createBlock(_component_AssetGridItem, {
+                      key: a.path,
+                      asset: a,
+                      folder,
+                      onClick: ($event) => selected.value = a
+                    }, null, 8, ["asset", "folder", "onClick"]);
+                  }), 128))
+                ])
+              ]),
+              _: 2
+            }, 1032, ["text", "description", "open"]);
+          }), 128)) : (openBlock(), createElementBlock("div", _hoisted_6, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filtered), (a) => {
+              return openBlock(), createBlock(_component_AssetGridItem, {
+                key: a.path,
+                asset: a,
+                onClick: ($event) => selected.value = a
+              }, null, 8, ["asset", "onClick"]);
+            }), 128))
+          ]))
+        ], 64)) : (openBlock(), createElementBlock("div", _hoisted_7, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filtered), (a) => {
+            return openBlock(), createBlock(_component_AssetListItem, {
+              key: a.path,
+              asset: a,
+              onClick: ($event) => selected.value = a
+            }, null, 8, ["asset", "onClick"]);
+          }), 128))
+        ])),
+        createVNode(_component_DrawerRight, {
+          "model-value": !!unref(selected),
+          "auto-close": "",
+          "w-120": "",
+          navbar: unref(navbar),
+          onClose: _cache[1] || (_cache[1] = ($event) => selected.value = void 0)
+        }, {
+          default: withCtx(() => [
+            unref(selected) ? (openBlock(), createBlock(_component_AssetDetails, {
+              key: 0,
+              asset: unref(selected)
+            }, null, 8, ["asset"])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["model-value", "navbar"])
+      ])) : (openBlock(), createBlock(_component_VPanelGrids, {
+        key: 1,
+        px5: ""
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_VCard, {
+            flex: "~ col gap2",
+            "min-w-30": "",
+            "items-center": "",
+            p3: ""
+          }, {
+            default: withCtx(() => [
+              _hoisted_8
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }));
+    };
+  }
+});
+
+/* Injected with object hook! */
+
+/* Injected with object hook! */
+
+export { _sfc_main as default };