// ==UserScript==
// @name         Emby Launchpad - Emby 媒体库助手
// @namespace    http://tampermonkey.net/
// @version      1.6.0
// @author       leo
// @description  在豆瓣(Douban)、GYG、DMHY 等网站上自动检测 Emby 服务端库内是否存在当前影视。提供 Nullbr 快捷资源检索，支持搜索115网盘和磁链内容; 提供 TMDB/IMDb 评分, gyg.si/bt4gprx.com 资源搜索链接。支持 Web Components 现代化 UI。
// @license      MIT
// @match        https://movie.douban.com/*
// @match        https://m.douban.com/*
// @match        https://www.gyg.si/*
// @match        https://dmhy.org/*
// @connect      api.themoviedb.org
// @connect      www.gyg.si
// @connect      www.imdb.com
// @connect      www.rottentomatoes.com
// @connect      api.bgm.tv
// @connect      api.nullbr.eu.org
// @grant        GM.addStyle
// @grant        GM.xmlHttpRequest
// @grant        GM_addStyle
// @grant        GM_deleteValue
// @grant        GM_getResourceText
// @grant        GM_getValue
// @grant        GM_listValues
// @grant        GM_registerMenuCommand
// @grant        GM_setClipboard
// @grant        GM_setValue
// @grant        GM_xmlhttpRequest
// @downloadURL https://update.greasyfork.icu/scripts/565501/Emby%20Launchpad%20-%20Emby%20%E5%AA%92%E4%BD%93%E5%BA%93%E5%8A%A9%E6%89%8B.user.js
// @updateURL https://update.greasyfork.icu/scripts/565501/Emby%20Launchpad%20-%20Emby%20%E5%AA%92%E4%BD%93%E5%BA%93%E5%8A%A9%E6%89%8B.meta.js
// ==/UserScript==

(function () {
  'use strict';

  /**
  * @vue/shared v3.5.28
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
function makeMap(str) {
    const map = Object.create(null);
    for (const key of str.split(",")) map[key] = 1;
    return (val) => val in map;
  }
  const EMPTY_OBJ = {};
  const EMPTY_ARR = [];
  const NOOP = () => {
  };
  const NO = () => false;
  const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 &&
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
  const isModelListener = (key) => key.startsWith("onUpdate:");
  const extend = Object.assign;
  const remove = (arr, el) => {
    const i = arr.indexOf(el);
    if (i > -1) {
      arr.splice(i, 1);
    }
  };
  const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
  const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
  const isArray = Array.isArray;
  const isMap = (val) => toTypeString(val) === "[object Map]";
  const isSet = (val) => toTypeString(val) === "[object Set]";
  const isDate = (val) => toTypeString(val) === "[object Date]";
  const isFunction = (val) => typeof val === "function";
  const isString = (val) => typeof val === "string";
  const isSymbol = (val) => typeof val === "symbol";
  const isObject = (val) => val !== null && typeof val === "object";
  const isPromise = (val) => {
    return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
  };
  const objectToString = Object.prototype.toString;
  const toTypeString = (value) => objectToString.call(value);
  const toRawType = (value) => {
    return toTypeString(value).slice(8, -1);
  };
  const isPlainObject = (val) => toTypeString(val) === "[object Object]";
  const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
  const isReservedProp = makeMap(
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
  );
  const cacheStringFunction = (fn) => {
    const cache2 = Object.create(null);
    return ((str) => {
      const hit = cache2[str];
      return hit || (cache2[str] = fn(str));
    });
  };
  const camelizeRE = /-\w/g;
  const camelize = cacheStringFunction(
    (str) => {
      return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
    }
  );
  const hyphenateRE = /\B([A-Z])/g;
  const hyphenate = cacheStringFunction(
    (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
  );
  const capitalize = cacheStringFunction((str) => {
    return str.charAt(0).toUpperCase() + str.slice(1);
  });
  const toHandlerKey = cacheStringFunction(
    (str) => {
      const s = str ? `on${capitalize(str)}` : ``;
      return s;
    }
  );
  const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
  const invokeArrayFns = (fns, ...arg) => {
    for (let i = 0; i < fns.length; i++) {
      fns[i](...arg);
    }
  };
  const def = (obj, key, value, writable = false) => {
    Object.defineProperty(obj, key, {
      configurable: true,
      enumerable: false,
      writable,
      value
    });
  };
  const looseToNumber = (val) => {
    const n = parseFloat(val);
    return isNaN(n) ? val : n;
  };
  const toNumber = (val) => {
    const n = isString(val) ? Number(val) : NaN;
    return isNaN(n) ? val : n;
  };
  let _globalThis;
  const getGlobalThis = () => {
    return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
  };
  function normalizeStyle(value) {
    if (isArray(value)) {
      const res = {};
      for (let i = 0; i < value.length; i++) {
        const item = value[i];
        const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
        if (normalized) {
          for (const key in normalized) {
            res[key] = normalized[key];
          }
        }
      }
      return res;
    } else if (isString(value) || isObject(value)) {
      return value;
    }
  }
  const listDelimiterRE = /;(?![^(]*\))/g;
  const propertyDelimiterRE = /:([^]+)/;
  const styleCommentRE = /\/\*[^]*?\*\//g;
  function parseStringStyle(cssText) {
    const ret = {};
    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
      if (item) {
        const tmp = item.split(propertyDelimiterRE);
        tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
      }
    });
    return ret;
  }
  function normalizeClass(value) {
    let res = "";
    if (isString(value)) {
      res = value;
    } else if (isArray(value)) {
      for (let i = 0; i < value.length; i++) {
        const normalized = normalizeClass(value[i]);
        if (normalized) {
          res += normalized + " ";
        }
      }
    } else if (isObject(value)) {
      for (const name in value) {
        if (value[name]) {
          res += name + " ";
        }
      }
    }
    return res.trim();
  }
  const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
  const isSpecialBooleanAttr = makeMap(specialBooleanAttrs);
  function includeBooleanAttr(value) {
    return !!value || value === "";
  }
  function looseCompareArrays(a, b) {
    if (a.length !== b.length) return false;
    let equal = true;
    for (let i = 0; equal && i < a.length; i++) {
      equal = looseEqual(a[i], b[i]);
    }
    return equal;
  }
  function looseEqual(a, b) {
    if (a === b) return true;
    let aValidType = isDate(a);
    let bValidType = isDate(b);
    if (aValidType || bValidType) {
      return aValidType && bValidType ? a.getTime() === b.getTime() : false;
    }
    aValidType = isSymbol(a);
    bValidType = isSymbol(b);
    if (aValidType || bValidType) {
      return a === b;
    }
    aValidType = isArray(a);
    bValidType = isArray(b);
    if (aValidType || bValidType) {
      return aValidType && bValidType ? looseCompareArrays(a, b) : false;
    }
    aValidType = isObject(a);
    bValidType = isObject(b);
    if (aValidType || bValidType) {
      if (!aValidType || !bValidType) {
        return false;
      }
      const aKeysCount = Object.keys(a).length;
      const bKeysCount = Object.keys(b).length;
      if (aKeysCount !== bKeysCount) {
        return false;
      }
      for (const key in a) {
        const aHasKey = a.hasOwnProperty(key);
        const bHasKey = b.hasOwnProperty(key);
        if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
          return false;
        }
      }
    }
    return String(a) === String(b);
  }
  function looseIndexOf(arr, val) {
    return arr.findIndex((item) => looseEqual(item, val));
  }
  const isRef$1 = (val) => {
    return !!(val && val["__v_isRef"] === true);
  };
  const toDisplayString = (val) => {
    return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
  };
  const replacer = (_key, val) => {
    if (isRef$1(val)) {
      return replacer(_key, val.value);
    } else if (isMap(val)) {
      return {
        [`Map(${val.size})`]: [...val.entries()].reduce(
          (entries, [key, val2], i) => {
            entries[stringifySymbol(key, i) + " =>"] = val2;
            return entries;
          },
          {}
        )
      };
    } else if (isSet(val)) {
      return {
        [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
      };
    } else if (isSymbol(val)) {
      return stringifySymbol(val);
    } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
      return String(val);
    }
    return val;
  };
  const stringifySymbol = (v, i = "") => {
    var _a;
    return (

isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
    );
  };
  function normalizeCssVarValue(value) {
    if (value == null) {
      return "initial";
    }
    if (typeof value === "string") {
      return value === "" ? " " : value;
    }
    return String(value);
  }
  /**
  * @vue/reactivity v3.5.28
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
  let activeEffectScope;
  class EffectScope {
constructor(detached = false) {
      this.detached = detached;
      this._active = true;
      this._on = 0;
      this.effects = [];
      this.cleanups = [];
      this._isPaused = false;
      this.__v_skip = true;
      this.parent = activeEffectScope;
      if (!detached && activeEffectScope) {
        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
          this
        ) - 1;
      }
    }
    get active() {
      return this._active;
    }
    pause() {
      if (this._active) {
        this._isPaused = true;
        let i, l;
        if (this.scopes) {
          for (i = 0, l = this.scopes.length; i < l; i++) {
            this.scopes[i].pause();
          }
        }
        for (i = 0, l = this.effects.length; i < l; i++) {
          this.effects[i].pause();
        }
      }
    }
resume() {
      if (this._active) {
        if (this._isPaused) {
          this._isPaused = false;
          let i, l;
          if (this.scopes) {
            for (i = 0, l = this.scopes.length; i < l; i++) {
              this.scopes[i].resume();
            }
          }
          for (i = 0, l = this.effects.length; i < l; i++) {
            this.effects[i].resume();
          }
        }
      }
    }
    run(fn) {
      if (this._active) {
        const currentEffectScope = activeEffectScope;
        try {
          activeEffectScope = this;
          return fn();
        } finally {
          activeEffectScope = currentEffectScope;
        }
      }
    }
on() {
      if (++this._on === 1) {
        this.prevScope = activeEffectScope;
        activeEffectScope = this;
      }
    }
off() {
      if (this._on > 0 && --this._on === 0) {
        activeEffectScope = this.prevScope;
        this.prevScope = void 0;
      }
    }
    stop(fromParent) {
      if (this._active) {
        this._active = false;
        let i, l;
        for (i = 0, l = this.effects.length; i < l; i++) {
          this.effects[i].stop();
        }
        this.effects.length = 0;
        for (i = 0, l = this.cleanups.length; i < l; i++) {
          this.cleanups[i]();
        }
        this.cleanups.length = 0;
        if (this.scopes) {
          for (i = 0, l = this.scopes.length; i < l; i++) {
            this.scopes[i].stop(true);
          }
          this.scopes.length = 0;
        }
        if (!this.detached && this.parent && !fromParent) {
          const last = this.parent.scopes.pop();
          if (last && last !== this) {
            this.parent.scopes[this.index] = last;
            last.index = this.index;
          }
        }
        this.parent = void 0;
      }
    }
  }
  function getCurrentScope() {
    return activeEffectScope;
  }
  let activeSub;
  const pausedQueueEffects = new WeakSet();
  class ReactiveEffect {
    constructor(fn) {
      this.fn = fn;
      this.deps = void 0;
      this.depsTail = void 0;
      this.flags = 1 | 4;
      this.next = void 0;
      this.cleanup = void 0;
      this.scheduler = void 0;
      if (activeEffectScope && activeEffectScope.active) {
        activeEffectScope.effects.push(this);
      }
    }
    pause() {
      this.flags |= 64;
    }
    resume() {
      if (this.flags & 64) {
        this.flags &= -65;
        if (pausedQueueEffects.has(this)) {
          pausedQueueEffects.delete(this);
          this.trigger();
        }
      }
    }
notify() {
      if (this.flags & 2 && !(this.flags & 32)) {
        return;
      }
      if (!(this.flags & 8)) {
        batch(this);
      }
    }
    run() {
      if (!(this.flags & 1)) {
        return this.fn();
      }
      this.flags |= 2;
      cleanupEffect(this);
      prepareDeps(this);
      const prevEffect = activeSub;
      const prevShouldTrack = shouldTrack;
      activeSub = this;
      shouldTrack = true;
      try {
        return this.fn();
      } finally {
        cleanupDeps(this);
        activeSub = prevEffect;
        shouldTrack = prevShouldTrack;
        this.flags &= -3;
      }
    }
    stop() {
      if (this.flags & 1) {
        for (let link = this.deps; link; link = link.nextDep) {
          removeSub(link);
        }
        this.deps = this.depsTail = void 0;
        cleanupEffect(this);
        this.onStop && this.onStop();
        this.flags &= -2;
      }
    }
    trigger() {
      if (this.flags & 64) {
        pausedQueueEffects.add(this);
      } else if (this.scheduler) {
        this.scheduler();
      } else {
        this.runIfDirty();
      }
    }
runIfDirty() {
      if (isDirty(this)) {
        this.run();
      }
    }
    get dirty() {
      return isDirty(this);
    }
  }
  let batchDepth = 0;
  let batchedSub;
  let batchedComputed;
  function batch(sub, isComputed = false) {
    sub.flags |= 8;
    if (isComputed) {
      sub.next = batchedComputed;
      batchedComputed = sub;
      return;
    }
    sub.next = batchedSub;
    batchedSub = sub;
  }
  function startBatch() {
    batchDepth++;
  }
  function endBatch() {
    if (--batchDepth > 0) {
      return;
    }
    if (batchedComputed) {
      let e = batchedComputed;
      batchedComputed = void 0;
      while (e) {
        const next = e.next;
        e.next = void 0;
        e.flags &= -9;
        e = next;
      }
    }
    let error;
    while (batchedSub) {
      let e = batchedSub;
      batchedSub = void 0;
      while (e) {
        const next = e.next;
        e.next = void 0;
        e.flags &= -9;
        if (e.flags & 1) {
          try {
            ;
            e.trigger();
          } catch (err) {
            if (!error) error = err;
          }
        }
        e = next;
      }
    }
    if (error) throw error;
  }
  function prepareDeps(sub) {
    for (let link = sub.deps; link; link = link.nextDep) {
      link.version = -1;
      link.prevActiveLink = link.dep.activeLink;
      link.dep.activeLink = link;
    }
  }
  function cleanupDeps(sub) {
    let head;
    let tail = sub.depsTail;
    let link = tail;
    while (link) {
      const prev = link.prevDep;
      if (link.version === -1) {
        if (link === tail) tail = prev;
        removeSub(link);
        removeDep(link);
      } else {
        head = link;
      }
      link.dep.activeLink = link.prevActiveLink;
      link.prevActiveLink = void 0;
      link = prev;
    }
    sub.deps = head;
    sub.depsTail = tail;
  }
  function isDirty(sub) {
    for (let link = sub.deps; link; link = link.nextDep) {
      if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
        return true;
      }
    }
    if (sub._dirty) {
      return true;
    }
    return false;
  }
  function refreshComputed(computed2) {
    if (computed2.flags & 4 && !(computed2.flags & 16)) {
      return;
    }
    computed2.flags &= -17;
    if (computed2.globalVersion === globalVersion) {
      return;
    }
    computed2.globalVersion = globalVersion;
    if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
      return;
    }
    computed2.flags |= 2;
    const dep = computed2.dep;
    const prevSub = activeSub;
    const prevShouldTrack = shouldTrack;
    activeSub = computed2;
    shouldTrack = true;
    try {
      prepareDeps(computed2);
      const value = computed2.fn(computed2._value);
      if (dep.version === 0 || hasChanged(value, computed2._value)) {
        computed2.flags |= 128;
        computed2._value = value;
        dep.version++;
      }
    } catch (err) {
      dep.version++;
      throw err;
    } finally {
      activeSub = prevSub;
      shouldTrack = prevShouldTrack;
      cleanupDeps(computed2);
      computed2.flags &= -3;
    }
  }
  function removeSub(link, soft = false) {
    const { dep, prevSub, nextSub } = link;
    if (prevSub) {
      prevSub.nextSub = nextSub;
      link.prevSub = void 0;
    }
    if (nextSub) {
      nextSub.prevSub = prevSub;
      link.nextSub = void 0;
    }
    if (dep.subs === link) {
      dep.subs = prevSub;
      if (!prevSub && dep.computed) {
        dep.computed.flags &= -5;
        for (let l = dep.computed.deps; l; l = l.nextDep) {
          removeSub(l, true);
        }
      }
    }
    if (!soft && !--dep.sc && dep.map) {
      dep.map.delete(dep.key);
    }
  }
  function removeDep(link) {
    const { prevDep, nextDep } = link;
    if (prevDep) {
      prevDep.nextDep = nextDep;
      link.prevDep = void 0;
    }
    if (nextDep) {
      nextDep.prevDep = prevDep;
      link.nextDep = void 0;
    }
  }
  let shouldTrack = true;
  const trackStack = [];
  function pauseTracking() {
    trackStack.push(shouldTrack);
    shouldTrack = false;
  }
  function resetTracking() {
    const last = trackStack.pop();
    shouldTrack = last === void 0 ? true : last;
  }
  function cleanupEffect(e) {
    const { cleanup } = e;
    e.cleanup = void 0;
    if (cleanup) {
      const prevSub = activeSub;
      activeSub = void 0;
      try {
        cleanup();
      } finally {
        activeSub = prevSub;
      }
    }
  }
  let globalVersion = 0;
  class Link {
    constructor(sub, dep) {
      this.sub = sub;
      this.dep = dep;
      this.version = dep.version;
      this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
    }
  }
  class Dep {
constructor(computed2) {
      this.computed = computed2;
      this.version = 0;
      this.activeLink = void 0;
      this.subs = void 0;
      this.map = void 0;
      this.key = void 0;
      this.sc = 0;
      this.__v_skip = true;
    }
    track(debugInfo) {
      if (!activeSub || !shouldTrack || activeSub === this.computed) {
        return;
      }
      let link = this.activeLink;
      if (link === void 0 || link.sub !== activeSub) {
        link = this.activeLink = new Link(activeSub, this);
        if (!activeSub.deps) {
          activeSub.deps = activeSub.depsTail = link;
        } else {
          link.prevDep = activeSub.depsTail;
          activeSub.depsTail.nextDep = link;
          activeSub.depsTail = link;
        }
        addSub(link);
      } else if (link.version === -1) {
        link.version = this.version;
        if (link.nextDep) {
          const next = link.nextDep;
          next.prevDep = link.prevDep;
          if (link.prevDep) {
            link.prevDep.nextDep = next;
          }
          link.prevDep = activeSub.depsTail;
          link.nextDep = void 0;
          activeSub.depsTail.nextDep = link;
          activeSub.depsTail = link;
          if (activeSub.deps === link) {
            activeSub.deps = next;
          }
        }
      }
      return link;
    }
    trigger(debugInfo) {
      this.version++;
      globalVersion++;
      this.notify(debugInfo);
    }
    notify(debugInfo) {
      startBatch();
      try {
        if (false) ;
        for (let link = this.subs; link; link = link.prevSub) {
          if (link.sub.notify()) {
            ;
            link.sub.dep.notify();
          }
        }
      } finally {
        endBatch();
      }
    }
  }
  function addSub(link) {
    link.dep.sc++;
    if (link.sub.flags & 4) {
      const computed2 = link.dep.computed;
      if (computed2 && !link.dep.subs) {
        computed2.flags |= 4 | 16;
        for (let l = computed2.deps; l; l = l.nextDep) {
          addSub(l);
        }
      }
      const currentTail = link.dep.subs;
      if (currentTail !== link) {
        link.prevSub = currentTail;
        if (currentTail) currentTail.nextSub = link;
      }
      link.dep.subs = link;
    }
  }
  const targetMap = new WeakMap();
  const ITERATE_KEY = Symbol(
    ""
  );
  const MAP_KEY_ITERATE_KEY = Symbol(
    ""
  );
  const ARRAY_ITERATE_KEY = Symbol(
    ""
  );
  function track(target, type, key) {
    if (shouldTrack && activeSub) {
      let depsMap = targetMap.get(target);
      if (!depsMap) {
        targetMap.set(target, depsMap = new Map());
      }
      let dep = depsMap.get(key);
      if (!dep) {
        depsMap.set(key, dep = new Dep());
        dep.map = depsMap;
        dep.key = key;
      }
      {
        dep.track();
      }
    }
  }
  function trigger(target, type, key, newValue, oldValue, oldTarget) {
    const depsMap = targetMap.get(target);
    if (!depsMap) {
      globalVersion++;
      return;
    }
    const run = (dep) => {
      if (dep) {
        {
          dep.trigger();
        }
      }
    };
    startBatch();
    if (type === "clear") {
      depsMap.forEach(run);
    } else {
      const targetIsArray = isArray(target);
      const isArrayIndex = targetIsArray && isIntegerKey(key);
      if (targetIsArray && key === "length") {
        const newLength = Number(newValue);
        depsMap.forEach((dep, key2) => {
          if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
            run(dep);
          }
        });
      } else {
        if (key !== void 0 || depsMap.has(void 0)) {
          run(depsMap.get(key));
        }
        if (isArrayIndex) {
          run(depsMap.get(ARRAY_ITERATE_KEY));
        }
        switch (type) {
          case "add":
            if (!targetIsArray) {
              run(depsMap.get(ITERATE_KEY));
              if (isMap(target)) {
                run(depsMap.get(MAP_KEY_ITERATE_KEY));
              }
            } else if (isArrayIndex) {
              run(depsMap.get("length"));
            }
            break;
          case "delete":
            if (!targetIsArray) {
              run(depsMap.get(ITERATE_KEY));
              if (isMap(target)) {
                run(depsMap.get(MAP_KEY_ITERATE_KEY));
              }
            }
            break;
          case "set":
            if (isMap(target)) {
              run(depsMap.get(ITERATE_KEY));
            }
            break;
        }
      }
    }
    endBatch();
  }
  function reactiveReadArray(array) {
    const raw = toRaw(array);
    if (raw === array) return raw;
    track(raw, "iterate", ARRAY_ITERATE_KEY);
    return isShallow(array) ? raw : raw.map(toReactive);
  }
  function shallowReadArray(arr) {
    track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
    return arr;
  }
  function toWrapped(target, item) {
    if ( isReadonly(target)) {
      return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
    }
    return toReactive(item);
  }
  const arrayInstrumentations = {
    __proto__: null,
    [Symbol.iterator]() {
      return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
    },
    concat(...args) {
      return reactiveReadArray(this).concat(
        ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
      );
    },
    entries() {
      return iterator(this, "entries", (value) => {
        value[1] = toWrapped(this, value[1]);
        return value;
      });
    },
    every(fn, thisArg) {
      return apply(this, "every", fn, thisArg, void 0, arguments);
    },
    filter(fn, thisArg) {
      return apply(
        this,
        "filter",
        fn,
        thisArg,
        (v) => v.map((item) => toWrapped(this, item)),
        arguments
      );
    },
    find(fn, thisArg) {
      return apply(
        this,
        "find",
        fn,
        thisArg,
        (item) => toWrapped(this, item),
        arguments
      );
    },
    findIndex(fn, thisArg) {
      return apply(this, "findIndex", fn, thisArg, void 0, arguments);
    },
    findLast(fn, thisArg) {
      return apply(
        this,
        "findLast",
        fn,
        thisArg,
        (item) => toWrapped(this, item),
        arguments
      );
    },
    findLastIndex(fn, thisArg) {
      return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
    },
forEach(fn, thisArg) {
      return apply(this, "forEach", fn, thisArg, void 0, arguments);
    },
    includes(...args) {
      return searchProxy(this, "includes", args);
    },
    indexOf(...args) {
      return searchProxy(this, "indexOf", args);
    },
    join(separator) {
      return reactiveReadArray(this).join(separator);
    },
lastIndexOf(...args) {
      return searchProxy(this, "lastIndexOf", args);
    },
    map(fn, thisArg) {
      return apply(this, "map", fn, thisArg, void 0, arguments);
    },
    pop() {
      return noTracking(this, "pop");
    },
    push(...args) {
      return noTracking(this, "push", args);
    },
    reduce(fn, ...args) {
      return reduce(this, "reduce", fn, args);
    },
    reduceRight(fn, ...args) {
      return reduce(this, "reduceRight", fn, args);
    },
    shift() {
      return noTracking(this, "shift");
    },
some(fn, thisArg) {
      return apply(this, "some", fn, thisArg, void 0, arguments);
    },
    splice(...args) {
      return noTracking(this, "splice", args);
    },
    toReversed() {
      return reactiveReadArray(this).toReversed();
    },
    toSorted(comparer) {
      return reactiveReadArray(this).toSorted(comparer);
    },
    toSpliced(...args) {
      return reactiveReadArray(this).toSpliced(...args);
    },
    unshift(...args) {
      return noTracking(this, "unshift", args);
    },
    values() {
      return iterator(this, "values", (item) => toWrapped(this, item));
    }
  };
  function iterator(self2, method, wrapValue) {
    const arr = shallowReadArray(self2);
    const iter = arr[method]();
    if (arr !== self2 && ! isShallow(self2)) {
      iter._next = iter.next;
      iter.next = () => {
        const result = iter._next();
        if (!result.done) {
          result.value = wrapValue(result.value);
        }
        return result;
      };
    }
    return iter;
  }
  const arrayProto = Array.prototype;
  function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
    const arr = shallowReadArray(self2);
    const needsWrap = arr !== self2 && ! isShallow(self2);
    const methodFn = arr[method];
    if (methodFn !== arrayProto[method]) {
      const result2 = methodFn.apply(self2, args);
      return needsWrap ? toReactive(result2) : result2;
    }
    let wrappedFn = fn;
    if (arr !== self2) {
      if (needsWrap) {
        wrappedFn = function(item, index) {
          return fn.call(this, toWrapped(self2, item), index, self2);
        };
      } else if (fn.length > 2) {
        wrappedFn = function(item, index) {
          return fn.call(this, item, index, self2);
        };
      }
    }
    const result = methodFn.call(arr, wrappedFn, thisArg);
    return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
  }
  function reduce(self2, method, fn, args) {
    const arr = shallowReadArray(self2);
    let wrappedFn = fn;
    if (arr !== self2) {
      if (! isShallow(self2)) {
        wrappedFn = function(acc, item, index) {
          return fn.call(this, acc, toWrapped(self2, item), index, self2);
        };
      } else if (fn.length > 3) {
        wrappedFn = function(acc, item, index) {
          return fn.call(this, acc, item, index, self2);
        };
      }
    }
    return arr[method](wrappedFn, ...args);
  }
  function searchProxy(self2, method, args) {
    const arr = toRaw(self2);
    track(arr, "iterate", ARRAY_ITERATE_KEY);
    const res = arr[method](...args);
    if ((res === -1 || res === false) && isProxy(args[0])) {
      args[0] = toRaw(args[0]);
      return arr[method](...args);
    }
    return res;
  }
  function noTracking(self2, method, args = []) {
    pauseTracking();
    startBatch();
    const res = ( toRaw(self2))[method].apply(self2, args);
    endBatch();
    resetTracking();
    return res;
  }
  const isNonTrackableKeys = makeMap(`__proto__,__v_isRef,__isVue`);
  const builtInSymbols = new Set(
Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
  );
  function hasOwnProperty(key) {
    if (!isSymbol(key)) key = String(key);
    const obj = toRaw(this);
    track(obj, "has", key);
    return obj.hasOwnProperty(key);
  }
  class BaseReactiveHandler {
    constructor(_isReadonly = false, _isShallow = false) {
      this._isReadonly = _isReadonly;
      this._isShallow = _isShallow;
    }
    get(target, key, receiver) {
      if (key === "__v_skip") return target["__v_skip"];
      const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
      if (key === "__v_isReactive") {
        return !isReadonly2;
      } else if (key === "__v_isReadonly") {
        return isReadonly2;
      } else if (key === "__v_isShallow") {
        return isShallow2;
      } else if (key === "__v_raw") {
        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) ||

Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
          return target;
        }
        return;
      }
      const targetIsArray = isArray(target);
      if (!isReadonly2) {
        let fn;
        if (targetIsArray && (fn = arrayInstrumentations[key])) {
          return fn;
        }
        if (key === "hasOwnProperty") {
          return hasOwnProperty;
        }
      }
      const res = Reflect.get(
        target,
        key,



isRef(target) ? target : receiver
      );
      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
        return res;
      }
      if (!isReadonly2) {
        track(target, "get", key);
      }
      if (isShallow2) {
        return res;
      }
      if ( isRef(res)) {
        const value = targetIsArray && isIntegerKey(key) ? res : res.value;
        return isReadonly2 && isObject(value) ? readonly(value) : value;
      }
      if (isObject(res)) {
        return isReadonly2 ? readonly(res) : reactive(res);
      }
      return res;
    }
  }
  class MutableReactiveHandler extends BaseReactiveHandler {
    constructor(isShallow2 = false) {
      super(false, isShallow2);
    }
    set(target, key, value, receiver) {
      let oldValue = target[key];
      const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
      if (!this._isShallow) {
        const isOldValueReadonly = isReadonly(oldValue);
        if (! isShallow(value) && ! isReadonly(value)) {
          oldValue = toRaw(oldValue);
          value = toRaw(value);
        }
        if (!isArrayWithIntegerKey && isRef(oldValue) && ! isRef(value)) {
          if (isOldValueReadonly) {
            return true;
          } else {
            oldValue.value = value;
            return true;
          }
        }
      }
      const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
      const result = Reflect.set(
        target,
        key,
        value,
isRef(target) ? target : receiver
      );
      if (target === toRaw(receiver)) {
        if (!hadKey) {
          trigger(target, "add", key, value);
        } else if (hasChanged(value, oldValue)) {
          trigger(target, "set", key, value);
        }
      }
      return result;
    }
    deleteProperty(target, key) {
      const hadKey = hasOwn(target, key);
      target[key];
      const result = Reflect.deleteProperty(target, key);
      if (result && hadKey) {
        trigger(target, "delete", key, void 0);
      }
      return result;
    }
    has(target, key) {
      const result = Reflect.has(target, key);
      if (!isSymbol(key) || !builtInSymbols.has(key)) {
        track(target, "has", key);
      }
      return result;
    }
    ownKeys(target) {
      track(
        target,
        "iterate",
        isArray(target) ? "length" : ITERATE_KEY
      );
      return Reflect.ownKeys(target);
    }
  }
  class ReadonlyReactiveHandler extends BaseReactiveHandler {
    constructor(isShallow2 = false) {
      super(true, isShallow2);
    }
    set(target, key) {
      return true;
    }
    deleteProperty(target, key) {
      return true;
    }
  }
  const mutableHandlers = new MutableReactiveHandler();
  const readonlyHandlers = new ReadonlyReactiveHandler();
  const shallowReactiveHandlers = new MutableReactiveHandler(true);
  const shallowReadonlyHandlers = new ReadonlyReactiveHandler(true);
  const toShallow = (value) => value;
  const getProto = (v) => Reflect.getPrototypeOf(v);
  function createIterableMethod(method, isReadonly2, isShallow2) {
    return function(...args) {
      const target = this["__v_raw"];
      const rawTarget = toRaw(target);
      const targetIsMap = isMap(rawTarget);
      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
      const isKeyOnly = method === "keys" && targetIsMap;
      const innerIterator = target[method](...args);
      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
      !isReadonly2 && track(
        rawTarget,
        "iterate",
        isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
      );
      return extend(
Object.create(innerIterator),
        {
next() {
            const { value, done } = innerIterator.next();
            return done ? { value, done } : {
              value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
              done
            };
          }
        }
      );
    };
  }
  function createReadonlyMethod(type) {
    return function(...args) {
      return type === "delete" ? false : type === "clear" ? void 0 : this;
    };
  }
  function createInstrumentations(readonly2, shallow) {
    const instrumentations = {
      get(key) {
        const target = this["__v_raw"];
        const rawTarget = toRaw(target);
        const rawKey = toRaw(key);
        if (!readonly2) {
          if (hasChanged(key, rawKey)) {
            track(rawTarget, "get", key);
          }
          track(rawTarget, "get", rawKey);
        }
        const { has } = getProto(rawTarget);
        const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
        if (has.call(rawTarget, key)) {
          return wrap(target.get(key));
        } else if (has.call(rawTarget, rawKey)) {
          return wrap(target.get(rawKey));
        } else if (target !== rawTarget) {
          target.get(key);
        }
      },
      get size() {
        const target = this["__v_raw"];
        !readonly2 && track( toRaw(target), "iterate", ITERATE_KEY);
        return target.size;
      },
      has(key) {
        const target = this["__v_raw"];
        const rawTarget = toRaw(target);
        const rawKey = toRaw(key);
        if (!readonly2) {
          if (hasChanged(key, rawKey)) {
            track(rawTarget, "has", key);
          }
          track(rawTarget, "has", rawKey);
        }
        return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
      },
      forEach(callback, thisArg) {
        const observed = this;
        const target = observed["__v_raw"];
        const rawTarget = toRaw(target);
        const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
        !readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
        return target.forEach((value, key) => {
          return callback.call(thisArg, wrap(value), wrap(key), observed);
        });
      }
    };
    extend(
      instrumentations,
      readonly2 ? {
        add: createReadonlyMethod("add"),
        set: createReadonlyMethod("set"),
        delete: createReadonlyMethod("delete"),
        clear: createReadonlyMethod("clear")
      } : {
        add(value) {
          if (!shallow && ! isShallow(value) && ! isReadonly(value)) {
            value = toRaw(value);
          }
          const target = toRaw(this);
          const proto = getProto(target);
          const hadKey = proto.has.call(target, value);
          if (!hadKey) {
            target.add(value);
            trigger(target, "add", value, value);
          }
          return this;
        },
        set(key, value) {
          if (!shallow && ! isShallow(value) && ! isReadonly(value)) {
            value = toRaw(value);
          }
          const target = toRaw(this);
          const { has, get } = getProto(target);
          let hadKey = has.call(target, key);
          if (!hadKey) {
            key = toRaw(key);
            hadKey = has.call(target, key);
          }
          const oldValue = get.call(target, key);
          target.set(key, value);
          if (!hadKey) {
            trigger(target, "add", key, value);
          } else if (hasChanged(value, oldValue)) {
            trigger(target, "set", key, value);
          }
          return this;
        },
        delete(key) {
          const target = toRaw(this);
          const { has, get } = getProto(target);
          let hadKey = has.call(target, key);
          if (!hadKey) {
            key = toRaw(key);
            hadKey = has.call(target, key);
          }
          get ? get.call(target, key) : void 0;
          const result = target.delete(key);
          if (hadKey) {
            trigger(target, "delete", key, void 0);
          }
          return result;
        },
        clear() {
          const target = toRaw(this);
          const hadItems = target.size !== 0;
          const result = target.clear();
          if (hadItems) {
            trigger(
              target,
              "clear",
              void 0,
              void 0
            );
          }
          return result;
        }
      }
    );
    const iteratorMethods = [
      "keys",
      "values",
      "entries",
      Symbol.iterator
    ];
    iteratorMethods.forEach((method) => {
      instrumentations[method] = createIterableMethod(method, readonly2, shallow);
    });
    return instrumentations;
  }
  function createInstrumentationGetter(isReadonly2, shallow) {
    const instrumentations = createInstrumentations(isReadonly2, shallow);
    return (target, key, receiver) => {
      if (key === "__v_isReactive") {
        return !isReadonly2;
      } else if (key === "__v_isReadonly") {
        return isReadonly2;
      } else if (key === "__v_raw") {
        return target;
      }
      return Reflect.get(
        hasOwn(instrumentations, key) && key in target ? instrumentations : target,
        key,
        receiver
      );
    };
  }
  const mutableCollectionHandlers = {
    get: createInstrumentationGetter(false, false)
  };
  const shallowCollectionHandlers = {
    get: createInstrumentationGetter(false, true)
  };
  const readonlyCollectionHandlers = {
    get: createInstrumentationGetter(true, false)
  };
  const shallowReadonlyCollectionHandlers = {
    get: createInstrumentationGetter(true, true)
  };
  const reactiveMap = new WeakMap();
  const shallowReactiveMap = new WeakMap();
  const readonlyMap = new WeakMap();
  const shallowReadonlyMap = new WeakMap();
  function targetTypeMap(rawType) {
    switch (rawType) {
      case "Object":
      case "Array":
        return 1;
      case "Map":
      case "Set":
      case "WeakMap":
      case "WeakSet":
        return 2;
      default:
        return 0;
    }
  }
  function getTargetType(value) {
    return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
  }
function reactive(target) {
    if ( isReadonly(target)) {
      return target;
    }
    return createReactiveObject(
      target,
      false,
      mutableHandlers,
      mutableCollectionHandlers,
      reactiveMap
    );
  }
function shallowReactive(target) {
    return createReactiveObject(
      target,
      false,
      shallowReactiveHandlers,
      shallowCollectionHandlers,
      shallowReactiveMap
    );
  }
function readonly(target) {
    return createReactiveObject(
      target,
      true,
      readonlyHandlers,
      readonlyCollectionHandlers,
      readonlyMap
    );
  }
function shallowReadonly(target) {
    return createReactiveObject(
      target,
      true,
      shallowReadonlyHandlers,
      shallowReadonlyCollectionHandlers,
      shallowReadonlyMap
    );
  }
  function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
    if (!isObject(target)) {
      return target;
    }
    if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
      return target;
    }
    const targetType = getTargetType(target);
    if (targetType === 0) {
      return target;
    }
    const existingProxy = proxyMap.get(target);
    if (existingProxy) {
      return existingProxy;
    }
    const proxy = new Proxy(
      target,
      targetType === 2 ? collectionHandlers : baseHandlers
    );
    proxyMap.set(target, proxy);
    return proxy;
  }
function isReactive(value) {
    if ( isReadonly(value)) {
      return isReactive(value["__v_raw"]);
    }
    return !!(value && value["__v_isReactive"]);
  }
function isReadonly(value) {
    return !!(value && value["__v_isReadonly"]);
  }
function isShallow(value) {
    return !!(value && value["__v_isShallow"]);
  }
function isProxy(value) {
    return value ? !!value["__v_raw"] : false;
  }
function toRaw(observed) {
    const raw = observed && observed["__v_raw"];
    return raw ? toRaw(raw) : observed;
  }
  function markRaw(value) {
    if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
      def(value, "__v_skip", true);
    }
    return value;
  }
  const toReactive = (value) => isObject(value) ? reactive(value) : value;
  const toReadonly = (value) => isObject(value) ? readonly(value) : value;
function isRef(r) {
    return r ? r["__v_isRef"] === true : false;
  }
function ref(value) {
    return createRef(value, false);
  }
  function createRef(rawValue, shallow) {
    if ( isRef(rawValue)) {
      return rawValue;
    }
    return new RefImpl(rawValue, shallow);
  }
  class RefImpl {
    constructor(value, isShallow2) {
      this.dep = new Dep();
      this["__v_isRef"] = true;
      this["__v_isShallow"] = false;
      this._rawValue = isShallow2 ? value : toRaw(value);
      this._value = isShallow2 ? value : toReactive(value);
      this["__v_isShallow"] = isShallow2;
    }
    get value() {
      {
        this.dep.track();
      }
      return this._value;
    }
    set value(newValue) {
      const oldValue = this._rawValue;
      const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
      newValue = useDirectValue ? newValue : toRaw(newValue);
      if (hasChanged(newValue, oldValue)) {
        this._rawValue = newValue;
        this._value = useDirectValue ? newValue : toReactive(newValue);
        {
          this.dep.trigger();
        }
      }
    }
  }
  function unref(ref2) {
    return isRef(ref2) ? ref2.value : ref2;
  }
  const shallowUnwrapHandlers = {
    get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
    set: (target, key, value, receiver) => {
      const oldValue = target[key];
      if ( isRef(oldValue) && ! isRef(value)) {
        oldValue.value = value;
        return true;
      } else {
        return Reflect.set(target, key, value, receiver);
      }
    }
  };
  function proxyRefs(objectWithRefs) {
    return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
  }
  class ComputedRefImpl {
    constructor(fn, setter, isSSR) {
      this.fn = fn;
      this.setter = setter;
      this._value = void 0;
      this.dep = new Dep(this);
      this.__v_isRef = true;
      this.deps = void 0;
      this.depsTail = void 0;
      this.flags = 16;
      this.globalVersion = globalVersion - 1;
      this.next = void 0;
      this.effect = this;
      this["__v_isReadonly"] = !setter;
      this.isSSR = isSSR;
    }
notify() {
      this.flags |= 16;
      if (!(this.flags & 8) &&
activeSub !== this) {
        batch(this, true);
        return true;
      }
    }
    get value() {
      const link = this.dep.track();
      refreshComputed(this);
      if (link) {
        link.version = this.dep.version;
      }
      return this._value;
    }
    set value(newValue) {
      if (this.setter) {
        this.setter(newValue);
      }
    }
  }
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
    let getter;
    let setter;
    if (isFunction(getterOrOptions)) {
      getter = getterOrOptions;
    } else {
      getter = getterOrOptions.get;
      setter = getterOrOptions.set;
    }
    const cRef = new ComputedRefImpl(getter, setter, isSSR);
    return cRef;
  }
  const INITIAL_WATCHER_VALUE = {};
  const cleanupMap = new WeakMap();
  let activeWatcher = void 0;
  function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
    if (owner) {
      let cleanups = cleanupMap.get(owner);
      if (!cleanups) cleanupMap.set(owner, cleanups = []);
      cleanups.push(cleanupFn);
    }
  }
  function watch$1(source, cb, options = EMPTY_OBJ) {
    const { immediate, deep, once, scheduler, augmentJob, call } = options;
    const reactiveGetter = (source2) => {
      if (deep) return source2;
      if ( isShallow(source2) || deep === false || deep === 0)
        return traverse(source2, 1);
      return traverse(source2);
    };
    let effect2;
    let getter;
    let cleanup;
    let boundCleanup;
    let forceTrigger = false;
    let isMultiSource = false;
    if ( isRef(source)) {
      getter = () => source.value;
      forceTrigger = isShallow(source);
    } else if ( isReactive(source)) {
      getter = () => reactiveGetter(source);
      forceTrigger = true;
    } else if (isArray(source)) {
      isMultiSource = true;
      forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
      getter = () => source.map((s) => {
        if ( isRef(s)) {
          return s.value;
        } else if ( isReactive(s)) {
          return reactiveGetter(s);
        } else if (isFunction(s)) {
          return call ? call(s, 2) : s();
        } else ;
      });
    } else if (isFunction(source)) {
      if (cb) {
        getter = call ? () => call(source, 2) : source;
      } else {
        getter = () => {
          if (cleanup) {
            pauseTracking();
            try {
              cleanup();
            } finally {
              resetTracking();
            }
          }
          const currentEffect = activeWatcher;
          activeWatcher = effect2;
          try {
            return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
          } finally {
            activeWatcher = currentEffect;
          }
        };
      }
    } else {
      getter = NOOP;
    }
    if (cb && deep) {
      const baseGetter = getter;
      const depth = deep === true ? Infinity : deep;
      getter = () => traverse(baseGetter(), depth);
    }
    const scope = getCurrentScope();
    const watchHandle = () => {
      effect2.stop();
      if (scope && scope.active) {
        remove(scope.effects, effect2);
      }
    };
    if (once && cb) {
      const _cb = cb;
      cb = (...args) => {
        _cb(...args);
        watchHandle();
      };
    }
    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
    const job = (immediateFirstRun) => {
      if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
        return;
      }
      if (cb) {
        const newValue = effect2.run();
        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
          if (cleanup) {
            cleanup();
          }
          const currentWatcher = activeWatcher;
          activeWatcher = effect2;
          try {
            const args = [
              newValue,
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
              boundCleanup
            ];
            oldValue = newValue;
            call ? call(cb, 3, args) : (
cb(...args)
            );
          } finally {
            activeWatcher = currentWatcher;
          }
        }
      } else {
        effect2.run();
      }
    };
    if (augmentJob) {
      augmentJob(job);
    }
    effect2 = new ReactiveEffect(getter);
    effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
    boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
    cleanup = effect2.onStop = () => {
      const cleanups = cleanupMap.get(effect2);
      if (cleanups) {
        if (call) {
          call(cleanups, 4);
        } else {
          for (const cleanup2 of cleanups) cleanup2();
        }
        cleanupMap.delete(effect2);
      }
    };
    if (cb) {
      if (immediate) {
        job(true);
      } else {
        oldValue = effect2.run();
      }
    } else if (scheduler) {
      scheduler(job.bind(null, true), true);
    } else {
      effect2.run();
    }
    watchHandle.pause = effect2.pause.bind(effect2);
    watchHandle.resume = effect2.resume.bind(effect2);
    watchHandle.stop = watchHandle;
    return watchHandle;
  }
  function traverse(value, depth = Infinity, seen) {
    if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
      return value;
    }
    seen = seen || new Map();
    if ((seen.get(value) || 0) >= depth) {
      return value;
    }
    seen.set(value, depth);
    depth--;
    if ( isRef(value)) {
      traverse(value.value, depth, seen);
    } else if (isArray(value)) {
      for (let i = 0; i < value.length; i++) {
        traverse(value[i], depth, seen);
      }
    } else if (isSet(value) || isMap(value)) {
      value.forEach((v) => {
        traverse(v, depth, seen);
      });
    } else if (isPlainObject(value)) {
      for (const key in value) {
        traverse(value[key], depth, seen);
      }
      for (const key of Object.getOwnPropertySymbols(value)) {
        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
          traverse(value[key], depth, seen);
        }
      }
    }
    return value;
  }
  /**
  * @vue/runtime-core v3.5.28
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
  const stack = [];
  let isWarning = false;
  function warn$1(msg, ...args) {
    if (isWarning) return;
    isWarning = true;
    pauseTracking();
    const instance = stack.length ? stack[stack.length - 1].component : null;
    const appWarnHandler = instance && instance.appContext.config.warnHandler;
    const trace = getComponentTrace();
    if (appWarnHandler) {
      callWithErrorHandling(
        appWarnHandler,
        instance,
        11,
        [
msg + args.map((a) => {
            var _a, _b;
            return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
          }).join(""),
          instance && instance.proxy,
          trace.map(
            ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
          ).join("\n"),
          trace
        ]
      );
    } else {
      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
      if (trace.length &&
true) {
        warnArgs.push(`
`, ...formatTrace(trace));
      }
      console.warn(...warnArgs);
    }
    resetTracking();
    isWarning = false;
  }
  function getComponentTrace() {
    let currentVNode = stack[stack.length - 1];
    if (!currentVNode) {
      return [];
    }
    const normalizedStack = [];
    while (currentVNode) {
      const last = normalizedStack[0];
      if (last && last.vnode === currentVNode) {
        last.recurseCount++;
      } else {
        normalizedStack.push({
          vnode: currentVNode,
          recurseCount: 0
        });
      }
      const parentInstance = currentVNode.component && currentVNode.component.parent;
      currentVNode = parentInstance && parentInstance.vnode;
    }
    return normalizedStack;
  }
  function formatTrace(trace) {
    const logs = [];
    trace.forEach((entry, i) => {
      logs.push(...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
    });
    return logs;
  }
  function formatTraceEntry({ vnode, recurseCount }) {
    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
    const isRoot = vnode.component ? vnode.component.parent == null : false;
    const open = ` at <${formatComponentName(
    vnode.component,
    vnode.type,
    isRoot
  )}`;
    const close = `>` + postfix;
    return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
  }
  function formatProps(props) {
    const res = [];
    const keys = Object.keys(props);
    keys.slice(0, 3).forEach((key) => {
      res.push(...formatProp(key, props[key]));
    });
    if (keys.length > 3) {
      res.push(` ...`);
    }
    return res;
  }
  function formatProp(key, value, raw) {
    if (isString(value)) {
      value = JSON.stringify(value);
      return raw ? value : [`${key}=${value}`];
    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
      return raw ? value : [`${key}=${value}`];
    } else if ( isRef(value)) {
      value = formatProp(key, toRaw(value.value), true);
      return raw ? value : [`${key}=Ref<`, value, `>`];
    } else if (isFunction(value)) {
      return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
    } else {
      value = toRaw(value);
      return raw ? value : [`${key}=`, value];
    }
  }
  function callWithErrorHandling(fn, instance, type, args) {
    try {
      return args ? fn(...args) : fn();
    } catch (err) {
      handleError(err, instance, type);
    }
  }
  function callWithAsyncErrorHandling(fn, instance, type, args) {
    if (isFunction(fn)) {
      const res = callWithErrorHandling(fn, instance, type, args);
      if (res && isPromise(res)) {
        res.catch((err) => {
          handleError(err, instance, type);
        });
      }
      return res;
    }
    if (isArray(fn)) {
      const values = [];
      for (let i = 0; i < fn.length; i++) {
        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
      }
      return values;
    }
  }
  function handleError(err, instance, type, throwInDev = true) {
    const contextVNode = instance ? instance.vnode : null;
    const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
    if (instance) {
      let cur = instance.parent;
      const exposedInstance = instance.proxy;
      const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
      while (cur) {
        const errorCapturedHooks = cur.ec;
        if (errorCapturedHooks) {
          for (let i = 0; i < errorCapturedHooks.length; i++) {
            if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
              return;
            }
          }
        }
        cur = cur.parent;
      }
      if (errorHandler) {
        pauseTracking();
        callWithErrorHandling(errorHandler, null, 10, [
          err,
          exposedInstance,
          errorInfo
        ]);
        resetTracking();
        return;
      }
    }
    logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
  }
  function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
    if (throwInProd) {
      throw err;
    } else {
      console.error(err);
    }
  }
  const queue = [];
  let flushIndex = -1;
  const pendingPostFlushCbs = [];
  let activePostFlushCbs = null;
  let postFlushIndex = 0;
  const resolvedPromise = Promise.resolve();
  let currentFlushPromise = null;
  function nextTick(fn) {
    const p2 = currentFlushPromise || resolvedPromise;
    return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
  }
  function findInsertionIndex(id) {
    let start = flushIndex + 1;
    let end = queue.length;
    while (start < end) {
      const middle = start + end >>> 1;
      const middleJob = queue[middle];
      const middleJobId = getId(middleJob);
      if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
        start = middle + 1;
      } else {
        end = middle;
      }
    }
    return start;
  }
  function queueJob(job) {
    if (!(job.flags & 1)) {
      const jobId = getId(job);
      const lastJob = queue[queue.length - 1];
      if (!lastJob ||
!(job.flags & 2) && jobId >= getId(lastJob)) {
        queue.push(job);
      } else {
        queue.splice(findInsertionIndex(jobId), 0, job);
      }
      job.flags |= 1;
      queueFlush();
    }
  }
  function queueFlush() {
    if (!currentFlushPromise) {
      currentFlushPromise = resolvedPromise.then(flushJobs);
    }
  }
  function queuePostFlushCb(cb) {
    if (!isArray(cb)) {
      if (activePostFlushCbs && cb.id === -1) {
        activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
      } else if (!(cb.flags & 1)) {
        pendingPostFlushCbs.push(cb);
        cb.flags |= 1;
      }
    } else {
      pendingPostFlushCbs.push(...cb);
    }
    queueFlush();
  }
  function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
    for (; i < queue.length; i++) {
      const cb = queue[i];
      if (cb && cb.flags & 2) {
        if (instance && cb.id !== instance.uid) {
          continue;
        }
        queue.splice(i, 1);
        i--;
        if (cb.flags & 4) {
          cb.flags &= -2;
        }
        cb();
        if (!(cb.flags & 4)) {
          cb.flags &= -2;
        }
      }
    }
  }
  function flushPostFlushCbs(seen) {
    if (pendingPostFlushCbs.length) {
      const deduped = [...new Set(pendingPostFlushCbs)].sort(
        (a, b) => getId(a) - getId(b)
      );
      pendingPostFlushCbs.length = 0;
      if (activePostFlushCbs) {
        activePostFlushCbs.push(...deduped);
        return;
      }
      activePostFlushCbs = deduped;
      for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
        const cb = activePostFlushCbs[postFlushIndex];
        if (cb.flags & 4) {
          cb.flags &= -2;
        }
        if (!(cb.flags & 8)) cb();
        cb.flags &= -2;
      }
      activePostFlushCbs = null;
      postFlushIndex = 0;
    }
  }
  const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
  function flushJobs(seen) {
    try {
      for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
        const job = queue[flushIndex];
        if (job && !(job.flags & 8)) {
          if (false) ;
          if (job.flags & 4) {
            job.flags &= ~1;
          }
          callWithErrorHandling(
            job,
            job.i,
            job.i ? 15 : 14
          );
          if (!(job.flags & 4)) {
            job.flags &= ~1;
          }
        }
      }
    } finally {
      for (; flushIndex < queue.length; flushIndex++) {
        const job = queue[flushIndex];
        if (job) {
          job.flags &= -2;
        }
      }
      flushIndex = -1;
      queue.length = 0;
      flushPostFlushCbs();
      currentFlushPromise = null;
      if (queue.length || pendingPostFlushCbs.length) {
        flushJobs();
      }
    }
  }
  let currentRenderingInstance = null;
  let currentScopeId = null;
  function setCurrentRenderingInstance(instance) {
    const prev = currentRenderingInstance;
    currentRenderingInstance = instance;
    currentScopeId = instance && instance.type.__scopeId || null;
    return prev;
  }
  function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
    if (!ctx) return fn;
    if (fn._n) {
      return fn;
    }
    const renderFnWithContext = (...args) => {
      if (renderFnWithContext._d) {
        setBlockTracking(-1);
      }
      const prevInstance = setCurrentRenderingInstance(ctx);
      let res;
      try {
        res = fn(...args);
      } finally {
        setCurrentRenderingInstance(prevInstance);
        if (renderFnWithContext._d) {
          setBlockTracking(1);
        }
      }
      return res;
    };
    renderFnWithContext._n = true;
    renderFnWithContext._c = true;
    renderFnWithContext._d = true;
    return renderFnWithContext;
  }
  function withDirectives(vnode, directives) {
    if (currentRenderingInstance === null) {
      return vnode;
    }
    const instance = getComponentPublicInstance(currentRenderingInstance);
    const bindings = vnode.dirs || (vnode.dirs = []);
    for (let i = 0; i < directives.length; i++) {
      let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
      if (dir) {
        if (isFunction(dir)) {
          dir = {
            mounted: dir,
            updated: dir
          };
        }
        if (dir.deep) {
          traverse(value);
        }
        bindings.push({
          dir,
          instance,
          value,
          oldValue: void 0,
          arg,
          modifiers
        });
      }
    }
    return vnode;
  }
  function invokeDirectiveHook(vnode, prevVNode, instance, name) {
    const bindings = vnode.dirs;
    const oldBindings = prevVNode && prevVNode.dirs;
    for (let i = 0; i < bindings.length; i++) {
      const binding = bindings[i];
      if (oldBindings) {
        binding.oldValue = oldBindings[i].value;
      }
      let hook = binding.dir[name];
      if (hook) {
        pauseTracking();
        callWithAsyncErrorHandling(hook, instance, 8, [
          vnode.el,
          binding,
          vnode,
          prevVNode
        ]);
        resetTracking();
      }
    }
  }
  function provide(key, value) {
    if (currentInstance) {
      let provides = currentInstance.provides;
      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
      if (parentProvides === provides) {
        provides = currentInstance.provides = Object.create(parentProvides);
      }
      provides[key] = value;
    }
  }
  function inject(key, defaultValue, treatDefaultAsFactory = false) {
    const instance = getCurrentInstance();
    if (instance || currentApp) {
      let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
      if (provides && key in provides) {
        return provides[key];
      } else if (arguments.length > 1) {
        return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
      } else ;
    }
  }
  const ssrContextKey = Symbol.for("v-scx");
  const useSSRContext = () => {
    {
      const ctx = inject(ssrContextKey);
      return ctx;
    }
  };
  function watch(source, cb, options) {
    return doWatch(source, cb, options);
  }
  function doWatch(source, cb, options = EMPTY_OBJ) {
    const { immediate, deep, flush, once } = options;
    const baseWatchOptions = extend({}, options);
    const runsImmediately = cb && immediate || !cb && flush !== "post";
    let ssrCleanup;
    if (isInSSRComponentSetup) {
      if (flush === "sync") {
        const ctx = useSSRContext();
        ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
      } else if (!runsImmediately) {
        const watchStopHandle = () => {
        };
        watchStopHandle.stop = NOOP;
        watchStopHandle.resume = NOOP;
        watchStopHandle.pause = NOOP;
        return watchStopHandle;
      }
    }
    const instance = currentInstance;
    baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
    let isPre = false;
    if (flush === "post") {
      baseWatchOptions.scheduler = (job) => {
        queuePostRenderEffect(job, instance && instance.suspense);
      };
    } else if (flush !== "sync") {
      isPre = true;
      baseWatchOptions.scheduler = (job, isFirstRun) => {
        if (isFirstRun) {
          job();
        } else {
          queueJob(job);
        }
      };
    }
    baseWatchOptions.augmentJob = (job) => {
      if (cb) {
        job.flags |= 4;
      }
      if (isPre) {
        job.flags |= 2;
        if (instance) {
          job.id = instance.uid;
          job.i = instance;
        }
      }
    };
    const watchHandle = watch$1(source, cb, baseWatchOptions);
    if (isInSSRComponentSetup) {
      if (ssrCleanup) {
        ssrCleanup.push(watchHandle);
      } else if (runsImmediately) {
        watchHandle();
      }
    }
    return watchHandle;
  }
  function instanceWatch(source, value, options) {
    const publicThis = this.proxy;
    const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
    let cb;
    if (isFunction(value)) {
      cb = value;
    } else {
      cb = value.handler;
      options = value;
    }
    const reset = setCurrentInstance(this);
    const res = doWatch(getter, cb.bind(publicThis), options);
    reset();
    return res;
  }
  function createPathGetter(ctx, path) {
    const segments = path.split(".");
    return () => {
      let cur = ctx;
      for (let i = 0; i < segments.length && cur; i++) {
        cur = cur[segments[i]];
      }
      return cur;
    };
  }
  const TeleportEndKey = Symbol("_vte");
  const isTeleport = (type) => type.__isTeleport;
  const leaveCbKey = Symbol("_leaveCb");
  function setTransitionHooks(vnode, hooks) {
    if (vnode.shapeFlag & 6 && vnode.component) {
      vnode.transition = hooks;
      setTransitionHooks(vnode.component.subTree, hooks);
    } else if (vnode.shapeFlag & 128) {
      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
      vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
    } else {
      vnode.transition = hooks;
    }
  }
function defineComponent(options, extraOptions) {
    return isFunction(options) ? (


(() => extend({ name: options.name }, extraOptions, { setup: options }))()
    ) : options;
  }
  function markAsyncBoundary(instance) {
    instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
  }
  function isTemplateRefKey(refs, key) {
    let desc;
    return !!((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable);
  }
  const pendingSetRefMap = new WeakMap();
  function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
    if (isArray(rawRef)) {
      rawRef.forEach(
        (r, i) => setRef(
          r,
          oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
          parentSuspense,
          vnode,
          isUnmount
        )
      );
      return;
    }
    if (isAsyncWrapper(vnode) && !isUnmount) {
      if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) {
        setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
      }
      return;
    }
    const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
    const value = isUnmount ? null : refValue;
    const { i: owner, r: ref3 } = rawRef;
    const oldRef = oldRawRef && oldRawRef.r;
    const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
    const setupState = owner.setupState;
    const rawSetupState = toRaw(setupState);
    const canSetSetupRef = setupState === EMPTY_OBJ ? NO : (key) => {
      if (isTemplateRefKey(refs, key)) {
        return false;
      }
      return hasOwn(rawSetupState, key);
    };
    const canSetRef = (ref22, key) => {
      if (key && isTemplateRefKey(refs, key)) {
        return false;
      }
      return true;
    };
    if (oldRef != null && oldRef !== ref3) {
      invalidatePendingSetRef(oldRawRef);
      if (isString(oldRef)) {
        refs[oldRef] = null;
        if (canSetSetupRef(oldRef)) {
          setupState[oldRef] = null;
        }
      } else if ( isRef(oldRef)) {
        const oldRawRefAtom = oldRawRef;
        if (canSetRef(oldRef, oldRawRefAtom.k)) {
          oldRef.value = null;
        }
        if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
      }
    }
    if (isFunction(ref3)) {
      callWithErrorHandling(ref3, owner, 12, [value, refs]);
    } else {
      const _isString = isString(ref3);
      const _isRef = isRef(ref3);
      if (_isString || _isRef) {
        const doSet = () => {
          if (rawRef.f) {
            const existing = _isString ? canSetSetupRef(ref3) ? setupState[ref3] : refs[ref3] : canSetRef() || !rawRef.k ? ref3.value : refs[rawRef.k];
            if (isUnmount) {
              isArray(existing) && remove(existing, refValue);
            } else {
              if (!isArray(existing)) {
                if (_isString) {
                  refs[ref3] = [refValue];
                  if (canSetSetupRef(ref3)) {
                    setupState[ref3] = refs[ref3];
                  }
                } else {
                  const newVal = [refValue];
                  if (canSetRef(ref3, rawRef.k)) {
                    ref3.value = newVal;
                  }
                  if (rawRef.k) refs[rawRef.k] = newVal;
                }
              } else if (!existing.includes(refValue)) {
                existing.push(refValue);
              }
            }
          } else if (_isString) {
            refs[ref3] = value;
            if (canSetSetupRef(ref3)) {
              setupState[ref3] = value;
            }
          } else if (_isRef) {
            if (canSetRef(ref3, rawRef.k)) {
              ref3.value = value;
            }
            if (rawRef.k) refs[rawRef.k] = value;
          } else ;
        };
        if (value) {
          const job = () => {
            doSet();
            pendingSetRefMap.delete(rawRef);
          };
          job.id = -1;
          pendingSetRefMap.set(rawRef, job);
          queuePostRenderEffect(job, parentSuspense);
        } else {
          invalidatePendingSetRef(rawRef);
          doSet();
        }
      }
    }
  }
  function invalidatePendingSetRef(rawRef) {
    const pendingSetRef = pendingSetRefMap.get(rawRef);
    if (pendingSetRef) {
      pendingSetRef.flags |= 8;
      pendingSetRefMap.delete(rawRef);
    }
  }
  getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
  getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
  const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
  const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
  function onActivated(hook, target) {
    registerKeepAliveHook(hook, "a", target);
  }
  function onDeactivated(hook, target) {
    registerKeepAliveHook(hook, "da", target);
  }
  function registerKeepAliveHook(hook, type, target = currentInstance) {
    const wrappedHook = hook.__wdc || (hook.__wdc = () => {
      let current = target;
      while (current) {
        if (current.isDeactivated) {
          return;
        }
        current = current.parent;
      }
      return hook();
    });
    injectHook(type, wrappedHook, target);
    if (target) {
      let current = target.parent;
      while (current && current.parent) {
        if (isKeepAlive(current.parent.vnode)) {
          injectToKeepAliveRoot(wrappedHook, type, target, current);
        }
        current = current.parent;
      }
    }
  }
  function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
    const injected = injectHook(
      type,
      hook,
      keepAliveRoot,
      true
);
    onUnmounted(() => {
      remove(keepAliveRoot[type], injected);
    }, target);
  }
  function injectHook(type, hook, target = currentInstance, prepend = false) {
    if (target) {
      const hooks = target[type] || (target[type] = []);
      const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
        pauseTracking();
        const reset = setCurrentInstance(target);
        const res = callWithAsyncErrorHandling(hook, target, type, args);
        reset();
        resetTracking();
        return res;
      });
      if (prepend) {
        hooks.unshift(wrappedHook);
      } else {
        hooks.push(wrappedHook);
      }
      return wrappedHook;
    }
  }
  const createHook = (lifecycle) => (hook, target = currentInstance) => {
    if (!isInSSRComponentSetup || lifecycle === "sp") {
      injectHook(lifecycle, (...args) => hook(...args), target);
    }
  };
  const onBeforeMount = createHook("bm");
  const onMounted = createHook("m");
  const onBeforeUpdate = createHook(
    "bu"
  );
  const onUpdated = createHook("u");
  const onBeforeUnmount = createHook(
    "bum"
  );
  const onUnmounted = createHook("um");
  const onServerPrefetch = createHook(
    "sp"
  );
  const onRenderTriggered = createHook("rtg");
  const onRenderTracked = createHook("rtc");
  function onErrorCaptured(hook, target = currentInstance) {
    injectHook("ec", hook, target);
  }
  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
  function renderList(source, renderItem, cache2, index) {
    let ret;
    const cached = cache2;
    const sourceIsArray = isArray(source);
    if (sourceIsArray || isString(source)) {
      const sourceIsReactiveArray = sourceIsArray && isReactive(source);
      let needsWrap = false;
      let isReadonlySource = false;
      if (sourceIsReactiveArray) {
        needsWrap = ! isShallow(source);
        isReadonlySource = isReadonly(source);
        source = shallowReadArray(source);
      }
      ret = new Array(source.length);
      for (let i = 0, l = source.length; i < l; i++) {
        ret[i] = renderItem(
          needsWrap ? isReadonlySource ? toReadonly(toReactive(source[i])) : toReactive(source[i]) : source[i],
          i,
          void 0,
          cached
        );
      }
    } else if (typeof source === "number") {
      ret = new Array(source);
      for (let i = 0; i < source; i++) {
        ret[i] = renderItem(i + 1, i, void 0, cached);
      }
    } else if (isObject(source)) {
      if (source[Symbol.iterator]) {
        ret = Array.from(
          source,
          (item, i) => renderItem(item, i, void 0, cached)
        );
      } else {
        const keys = Object.keys(source);
        ret = new Array(keys.length);
        for (let i = 0, l = keys.length; i < l; i++) {
          const key = keys[i];
          ret[i] = renderItem(source[key], key, i, cached);
        }
      }
    } else {
      ret = [];
    }
    return ret;
  }
  const getPublicInstance = (i) => {
    if (!i) return null;
    if (isStatefulComponent(i)) return getComponentPublicInstance(i);
    return getPublicInstance(i.parent);
  };
  const publicPropertiesMap = (


extend( Object.create(null), {
      $: (i) => i,
      $el: (i) => i.vnode.el,
      $data: (i) => i.data,
      $props: (i) => i.props,
      $attrs: (i) => i.attrs,
      $slots: (i) => i.slots,
      $refs: (i) => i.refs,
      $parent: (i) => getPublicInstance(i.parent),
      $root: (i) => getPublicInstance(i.root),
      $host: (i) => i.ce,
      $emit: (i) => i.emit,
      $options: (i) => resolveMergedOptions(i),
      $forceUpdate: (i) => i.f || (i.f = () => {
        queueJob(i.update);
      }),
      $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
      $watch: (i) => instanceWatch.bind(i)
    })
  );
  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
  const PublicInstanceProxyHandlers = {
    get({ _: instance }, key) {
      if (key === "__v_skip") {
        return true;
      }
      const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
      if (key[0] !== "$") {
        const n = accessCache[key];
        if (n !== void 0) {
          switch (n) {
            case 1:
              return setupState[key];
            case 2:
              return data[key];
            case 4:
              return ctx[key];
            case 3:
              return props[key];
          }
        } else if (hasSetupBinding(setupState, key)) {
          accessCache[key] = 1;
          return setupState[key];
        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
          accessCache[key] = 2;
          return data[key];
        } else if (hasOwn(props, key)) {
          accessCache[key] = 3;
          return props[key];
        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
          accessCache[key] = 4;
          return ctx[key];
        } else if (shouldCacheAccess) {
          accessCache[key] = 0;
        }
      }
      const publicGetter = publicPropertiesMap[key];
      let cssModule, globalProperties;
      if (publicGetter) {
        if (key === "$attrs") {
          track(instance.attrs, "get", "");
        }
        return publicGetter(instance);
      } else if (
(cssModule = type.__cssModules) && (cssModule = cssModule[key])
      ) {
        return cssModule;
      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
        accessCache[key] = 4;
        return ctx[key];
      } else if (
globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
      ) {
        {
          return globalProperties[key];
        }
      } else ;
    },
    set({ _: instance }, key, value) {
      const { data, setupState, ctx } = instance;
      if (hasSetupBinding(setupState, key)) {
        setupState[key] = value;
        return true;
      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
        data[key] = value;
        return true;
      } else if (hasOwn(instance.props, key)) {
        return false;
      }
      if (key[0] === "$" && key.slice(1) in instance) {
        return false;
      } else {
        {
          ctx[key] = value;
        }
      }
      return true;
    },
    has({
      _: { data, setupState, accessCache, ctx, appContext, props, type }
    }, key) {
      let cssModules;
      return !!(accessCache[key] || data !== EMPTY_OBJ && key[0] !== "$" && hasOwn(data, key) || hasSetupBinding(setupState, key) || hasOwn(props, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
    },
    defineProperty(target, key, descriptor) {
      if (descriptor.get != null) {
        target._.accessCache[key] = 0;
      } else if (hasOwn(descriptor, "value")) {
        this.set(target, key, descriptor.value, null);
      }
      return Reflect.defineProperty(target, key, descriptor);
    }
  };
  function normalizePropsOrEmits(props) {
    return isArray(props) ? props.reduce(
      (normalized, p2) => (normalized[p2] = null, normalized),
      {}
    ) : props;
  }
  let shouldCacheAccess = true;
  function applyOptions(instance) {
    const options = resolveMergedOptions(instance);
    const publicThis = instance.proxy;
    const ctx = instance.ctx;
    shouldCacheAccess = false;
    if (options.beforeCreate) {
      callHook(options.beforeCreate, instance, "bc");
    }
    const {
data: dataOptions,
      computed: computedOptions,
      methods,
      watch: watchOptions,
      provide: provideOptions,
      inject: injectOptions,
created,
      beforeMount,
      mounted,
      beforeUpdate,
      updated,
      activated,
      deactivated,
      beforeDestroy,
      beforeUnmount,
      destroyed,
      unmounted,
      render: render2,
      renderTracked,
      renderTriggered,
      errorCaptured,
      serverPrefetch,
expose,
      inheritAttrs,
components,
      directives,
      filters
    } = options;
    const checkDuplicateProperties = null;
    if (injectOptions) {
      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
    }
    if (methods) {
      for (const key in methods) {
        const methodHandler = methods[key];
        if (isFunction(methodHandler)) {
          {
            ctx[key] = methodHandler.bind(publicThis);
          }
        }
      }
    }
    if (dataOptions) {
      const data = dataOptions.call(publicThis, publicThis);
      if (!isObject(data)) ;
      else {
        instance.data = reactive(data);
      }
    }
    shouldCacheAccess = true;
    if (computedOptions) {
      for (const key in computedOptions) {
        const opt = computedOptions[key];
        const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
        const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;
        const c = computed({
          get,
          set
        });
        Object.defineProperty(ctx, key, {
          enumerable: true,
          configurable: true,
          get: () => c.value,
          set: (v) => c.value = v
        });
      }
    }
    if (watchOptions) {
      for (const key in watchOptions) {
        createWatcher(watchOptions[key], ctx, publicThis, key);
      }
    }
    if (provideOptions) {
      const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
      Reflect.ownKeys(provides).forEach((key) => {
        provide(key, provides[key]);
      });
    }
    if (created) {
      callHook(created, instance, "c");
    }
    function registerLifecycleHook(register, hook) {
      if (isArray(hook)) {
        hook.forEach((_hook) => register(_hook.bind(publicThis)));
      } else if (hook) {
        register(hook.bind(publicThis));
      }
    }
    registerLifecycleHook(onBeforeMount, beforeMount);
    registerLifecycleHook(onMounted, mounted);
    registerLifecycleHook(onBeforeUpdate, beforeUpdate);
    registerLifecycleHook(onUpdated, updated);
    registerLifecycleHook(onActivated, activated);
    registerLifecycleHook(onDeactivated, deactivated);
    registerLifecycleHook(onErrorCaptured, errorCaptured);
    registerLifecycleHook(onRenderTracked, renderTracked);
    registerLifecycleHook(onRenderTriggered, renderTriggered);
    registerLifecycleHook(onBeforeUnmount, beforeUnmount);
    registerLifecycleHook(onUnmounted, unmounted);
    registerLifecycleHook(onServerPrefetch, serverPrefetch);
    if (isArray(expose)) {
      if (expose.length) {
        const exposed = instance.exposed || (instance.exposed = {});
        expose.forEach((key) => {
          Object.defineProperty(exposed, key, {
            get: () => publicThis[key],
            set: (val) => publicThis[key] = val,
            enumerable: true
          });
        });
      } else if (!instance.exposed) {
        instance.exposed = {};
      }
    }
    if (render2 && instance.render === NOOP) {
      instance.render = render2;
    }
    if (inheritAttrs != null) {
      instance.inheritAttrs = inheritAttrs;
    }
    if (components) instance.components = components;
    if (directives) instance.directives = directives;
    if (serverPrefetch) {
      markAsyncBoundary(instance);
    }
  }
  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
    if (isArray(injectOptions)) {
      injectOptions = normalizeInject(injectOptions);
    }
    for (const key in injectOptions) {
      const opt = injectOptions[key];
      let injected;
      if (isObject(opt)) {
        if ("default" in opt) {
          injected = inject(
            opt.from || key,
            opt.default,
            true
          );
        } else {
          injected = inject(opt.from || key);
        }
      } else {
        injected = inject(opt);
      }
      if ( isRef(injected)) {
        Object.defineProperty(ctx, key, {
          enumerable: true,
          configurable: true,
          get: () => injected.value,
          set: (v) => injected.value = v
        });
      } else {
        ctx[key] = injected;
      }
    }
  }
  function callHook(hook, instance, type) {
    callWithAsyncErrorHandling(
      isArray(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy),
      instance,
      type
    );
  }
  function createWatcher(raw, ctx, publicThis, key) {
    let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
    if (isString(raw)) {
      const handler = ctx[raw];
      if (isFunction(handler)) {
        {
          watch(getter, handler);
        }
      }
    } else if (isFunction(raw)) {
      {
        watch(getter, raw.bind(publicThis));
      }
    } else if (isObject(raw)) {
      if (isArray(raw)) {
        raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
      } else {
        const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
        if (isFunction(handler)) {
          watch(getter, handler, raw);
        }
      }
    } else ;
  }
  function resolveMergedOptions(instance) {
    const base = instance.type;
    const { mixins, extends: extendsOptions } = base;
    const {
      mixins: globalMixins,
      optionsCache: cache2,
      config: { optionMergeStrategies }
    } = instance.appContext;
    const cached = cache2.get(base);
    let resolved;
    if (cached) {
      resolved = cached;
    } else if (!globalMixins.length && !mixins && !extendsOptions) {
      {
        resolved = base;
      }
    } else {
      resolved = {};
      if (globalMixins.length) {
        globalMixins.forEach(
          (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
        );
      }
      mergeOptions(resolved, base, optionMergeStrategies);
    }
    if (isObject(base)) {
      cache2.set(base, resolved);
    }
    return resolved;
  }
  function mergeOptions(to, from, strats, asMixin = false) {
    const { mixins, extends: extendsOptions } = from;
    if (extendsOptions) {
      mergeOptions(to, extendsOptions, strats, true);
    }
    if (mixins) {
      mixins.forEach(
        (m) => mergeOptions(to, m, strats, true)
      );
    }
    for (const key in from) {
      if (asMixin && key === "expose") ;
      else {
        const strat = internalOptionMergeStrats[key] || strats && strats[key];
        to[key] = strat ? strat(to[key], from[key]) : from[key];
      }
    }
    return to;
  }
  const internalOptionMergeStrats = {
    data: mergeDataFn,
    props: mergeEmitsOrPropsOptions,
    emits: mergeEmitsOrPropsOptions,
methods: mergeObjectOptions,
    computed: mergeObjectOptions,
beforeCreate: mergeAsArray,
    created: mergeAsArray,
    beforeMount: mergeAsArray,
    mounted: mergeAsArray,
    beforeUpdate: mergeAsArray,
    updated: mergeAsArray,
    beforeDestroy: mergeAsArray,
    beforeUnmount: mergeAsArray,
    destroyed: mergeAsArray,
    unmounted: mergeAsArray,
    activated: mergeAsArray,
    deactivated: mergeAsArray,
    errorCaptured: mergeAsArray,
    serverPrefetch: mergeAsArray,
components: mergeObjectOptions,
    directives: mergeObjectOptions,
watch: mergeWatchOptions,
provide: mergeDataFn,
    inject: mergeInject
  };
  function mergeDataFn(to, from) {
    if (!from) {
      return to;
    }
    if (!to) {
      return from;
    }
    return function mergedDataFn() {
      return extend(
        isFunction(to) ? to.call(this, this) : to,
        isFunction(from) ? from.call(this, this) : from
      );
    };
  }
  function mergeInject(to, from) {
    return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
  }
  function normalizeInject(raw) {
    if (isArray(raw)) {
      const res = {};
      for (let i = 0; i < raw.length; i++) {
        res[raw[i]] = raw[i];
      }
      return res;
    }
    return raw;
  }
  function mergeAsArray(to, from) {
    return to ? [...new Set([].concat(to, from))] : from;
  }
  function mergeObjectOptions(to, from) {
    return to ? extend( Object.create(null), to, from) : from;
  }
  function mergeEmitsOrPropsOptions(to, from) {
    if (to) {
      if (isArray(to) && isArray(from)) {
        return [... new Set([...to, ...from])];
      }
      return extend(
Object.create(null),
        normalizePropsOrEmits(to),
        normalizePropsOrEmits(from != null ? from : {})
      );
    } else {
      return from;
    }
  }
  function mergeWatchOptions(to, from) {
    if (!to) return from;
    if (!from) return to;
    const merged = extend( Object.create(null), to);
    for (const key in from) {
      merged[key] = mergeAsArray(to[key], from[key]);
    }
    return merged;
  }
  function createAppContext() {
    return {
      app: null,
      config: {
        isNativeTag: NO,
        performance: false,
        globalProperties: {},
        optionMergeStrategies: {},
        errorHandler: void 0,
        warnHandler: void 0,
        compilerOptions: {}
      },
      mixins: [],
      components: {},
      directives: {},
      provides: Object.create(null),
      optionsCache: new WeakMap(),
      propsCache: new WeakMap(),
      emitsCache: new WeakMap()
    };
  }
  let uid$1 = 0;
  function createAppAPI(render2, hydrate) {
    return function createApp2(rootComponent, rootProps = null) {
      if (!isFunction(rootComponent)) {
        rootComponent = extend({}, rootComponent);
      }
      if (rootProps != null && !isObject(rootProps)) {
        rootProps = null;
      }
      const context = createAppContext();
      const installedPlugins = new WeakSet();
      const pluginCleanupFns = [];
      let isMounted = false;
      const app = context.app = {
        _uid: uid$1++,
        _component: rootComponent,
        _props: rootProps,
        _container: null,
        _context: context,
        _instance: null,
        version: version$1,
        get config() {
          return context.config;
        },
        set config(v) {
        },
        use(plugin, ...options) {
          if (installedPlugins.has(plugin)) ;
          else if (plugin && isFunction(plugin.install)) {
            installedPlugins.add(plugin);
            plugin.install(app, ...options);
          } else if (isFunction(plugin)) {
            installedPlugins.add(plugin);
            plugin(app, ...options);
          } else ;
          return app;
        },
        mixin(mixin) {
          {
            if (!context.mixins.includes(mixin)) {
              context.mixins.push(mixin);
            }
          }
          return app;
        },
        component(name, component) {
          if (!component) {
            return context.components[name];
          }
          context.components[name] = component;
          return app;
        },
        directive(name, directive) {
          if (!directive) {
            return context.directives[name];
          }
          context.directives[name] = directive;
          return app;
        },
        mount(rootContainer, isHydrate, namespace) {
          if (!isMounted) {
            const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
            vnode.appContext = context;
            if (namespace === true) {
              namespace = "svg";
            } else if (namespace === false) {
              namespace = void 0;
            }
            {
              render2(vnode, rootContainer, namespace);
            }
            isMounted = true;
            app._container = rootContainer;
            rootContainer.__vue_app__ = app;
            return getComponentPublicInstance(vnode.component);
          }
        },
        onUnmount(cleanupFn) {
          pluginCleanupFns.push(cleanupFn);
        },
        unmount() {
          if (isMounted) {
            callWithAsyncErrorHandling(
              pluginCleanupFns,
              app._instance,
              16
            );
            render2(null, app._container);
            delete app._container.__vue_app__;
          }
        },
        provide(key, value) {
          context.provides[key] = value;
          return app;
        },
        runWithContext(fn) {
          const lastApp = currentApp;
          currentApp = app;
          try {
            return fn();
          } finally {
            currentApp = lastApp;
          }
        }
      };
      return app;
    };
  }
  let currentApp = null;
  const getModelModifiers = (props, modelName) => {
    return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
  };
  function emit(instance, event, ...rawArgs) {
    if (instance.isUnmounted) return;
    const props = instance.vnode.props || EMPTY_OBJ;
    let args = rawArgs;
    const isModelListener2 = event.startsWith("update:");
    const modifiers = isModelListener2 && getModelModifiers(props, event.slice(7));
    if (modifiers) {
      if (modifiers.trim) {
        args = rawArgs.map((a) => isString(a) ? a.trim() : a);
      }
      if (modifiers.number) {
        args = rawArgs.map(looseToNumber);
      }
    }
    let handlerName;
    let handler = props[handlerName = toHandlerKey(event)] ||
props[handlerName = toHandlerKey(camelize(event))];
    if (!handler && isModelListener2) {
      handler = props[handlerName = toHandlerKey(hyphenate(event))];
    }
    if (handler) {
      callWithAsyncErrorHandling(
        handler,
        instance,
        6,
        args
      );
    }
    const onceHandler = props[handlerName + `Once`];
    if (onceHandler) {
      if (!instance.emitted) {
        instance.emitted = {};
      } else if (instance.emitted[handlerName]) {
        return;
      }
      instance.emitted[handlerName] = true;
      callWithAsyncErrorHandling(
        onceHandler,
        instance,
        6,
        args
      );
    }
  }
  const mixinEmitsCache = new WeakMap();
  function normalizeEmitsOptions(comp, appContext, asMixin = false) {
    const cache2 = asMixin ? mixinEmitsCache : appContext.emitsCache;
    const cached = cache2.get(comp);
    if (cached !== void 0) {
      return cached;
    }
    const raw = comp.emits;
    let normalized = {};
    let hasExtends = false;
    if (!isFunction(comp)) {
      const extendEmits = (raw2) => {
        const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
        if (normalizedFromExtend) {
          hasExtends = true;
          extend(normalized, normalizedFromExtend);
        }
      };
      if (!asMixin && appContext.mixins.length) {
        appContext.mixins.forEach(extendEmits);
      }
      if (comp.extends) {
        extendEmits(comp.extends);
      }
      if (comp.mixins) {
        comp.mixins.forEach(extendEmits);
      }
    }
    if (!raw && !hasExtends) {
      if (isObject(comp)) {
        cache2.set(comp, null);
      }
      return null;
    }
    if (isArray(raw)) {
      raw.forEach((key) => normalized[key] = null);
    } else {
      extend(normalized, raw);
    }
    if (isObject(comp)) {
      cache2.set(comp, normalized);
    }
    return normalized;
  }
  function isEmitListener(options, key) {
    if (!options || !isOn(key)) {
      return false;
    }
    key = key.slice(2).replace(/Once$/, "");
    return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
  }
  function markAttrsAccessed() {
  }
  function renderComponentRoot(instance) {
    const {
      type: Component,
      vnode,
      proxy,
      withProxy,
      propsOptions: [propsOptions],
      slots,
      attrs,
      emit: emit2,
      render: render2,
      renderCache,
      props,
      data,
      setupState,
      ctx,
      inheritAttrs
    } = instance;
    const prev = setCurrentRenderingInstance(instance);
    let result;
    let fallthroughAttrs;
    try {
      if (vnode.shapeFlag & 4) {
        const proxyToUse = withProxy || proxy;
        const thisProxy = false ? new Proxy(proxyToUse, {
          get(target, key, receiver) {
            warn$1(
              `Property '${String(
              key
            )}' was accessed via 'this'. Avoid using 'this' in templates.`
            );
            return Reflect.get(target, key, receiver);
          }
        }) : proxyToUse;
        result = normalizeVNode(
          render2.call(
            thisProxy,
            proxyToUse,
            renderCache,
            false ? shallowReadonly(props) : props,
            setupState,
            data,
            ctx
          )
        );
        fallthroughAttrs = attrs;
      } else {
        const render22 = Component;
        if (false) ;
        result = normalizeVNode(
          render22.length > 1 ? render22(
            false ? shallowReadonly(props) : props,
            false ? {
              get attrs() {
                markAttrsAccessed();
                return shallowReadonly(attrs);
              },
              slots,
              emit: emit2
            } : { attrs, slots, emit: emit2 }
          ) : render22(
            false ? shallowReadonly(props) : props,
            null
          )
        );
        fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
      }
    } catch (err) {
      blockStack.length = 0;
      handleError(err, instance, 1);
      result = createVNode(Comment);
    }
    let root = result;
    if (fallthroughAttrs && inheritAttrs !== false) {
      const keys = Object.keys(fallthroughAttrs);
      const { shapeFlag } = root;
      if (keys.length) {
        if (shapeFlag & (1 | 6)) {
          if (propsOptions && keys.some(isModelListener)) {
            fallthroughAttrs = filterModelListeners(
              fallthroughAttrs,
              propsOptions
            );
          }
          root = cloneVNode(root, fallthroughAttrs, false, true);
        }
      }
    }
    if (vnode.dirs) {
      root = cloneVNode(root, null, false, true);
      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
    }
    if (vnode.transition) {
      setTransitionHooks(root, vnode.transition);
    }
    {
      result = root;
    }
    setCurrentRenderingInstance(prev);
    return result;
  }
  const getFunctionalFallthrough = (attrs) => {
    let res;
    for (const key in attrs) {
      if (key === "class" || key === "style" || isOn(key)) {
        (res || (res = {}))[key] = attrs[key];
      }
    }
    return res;
  };
  const filterModelListeners = (attrs, props) => {
    const res = {};
    for (const key in attrs) {
      if (!isModelListener(key) || !(key.slice(9) in props)) {
        res[key] = attrs[key];
      }
    }
    return res;
  };
  function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
    const { props: prevProps, children: prevChildren, component } = prevVNode;
    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
    const emits = component.emitsOptions;
    if (nextVNode.dirs || nextVNode.transition) {
      return true;
    }
    if (optimized && patchFlag >= 0) {
      if (patchFlag & 1024) {
        return true;
      }
      if (patchFlag & 16) {
        if (!prevProps) {
          return !!nextProps;
        }
        return hasPropsChanged(prevProps, nextProps, emits);
      } else if (patchFlag & 8) {
        const dynamicProps = nextVNode.dynamicProps;
        for (let i = 0; i < dynamicProps.length; i++) {
          const key = dynamicProps[i];
          if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emits, key)) {
            return true;
          }
        }
      }
    } else {
      if (prevChildren || nextChildren) {
        if (!nextChildren || !nextChildren.$stable) {
          return true;
        }
      }
      if (prevProps === nextProps) {
        return false;
      }
      if (!prevProps) {
        return !!nextProps;
      }
      if (!nextProps) {
        return true;
      }
      return hasPropsChanged(prevProps, nextProps, emits);
    }
    return false;
  }
  function hasPropsChanged(prevProps, nextProps, emitsOptions) {
    const nextKeys = Object.keys(nextProps);
    if (nextKeys.length !== Object.keys(prevProps).length) {
      return true;
    }
    for (let i = 0; i < nextKeys.length; i++) {
      const key = nextKeys[i];
      if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) {
        return true;
      }
    }
    return false;
  }
  function hasPropValueChanged(nextProps, prevProps, key) {
    const nextProp = nextProps[key];
    const prevProp = prevProps[key];
    if (key === "style" && isObject(nextProp) && isObject(prevProp)) {
      return !looseEqual(nextProp, prevProp);
    }
    return nextProp !== prevProp;
  }
  function updateHOCHostEl({ vnode, parent }, el) {
    while (parent) {
      const root = parent.subTree;
      if (root.suspense && root.suspense.activeBranch === vnode) {
        root.el = vnode.el;
      }
      if (root === vnode) {
        (vnode = parent.vnode).el = el;
        parent = parent.parent;
      } else {
        break;
      }
    }
  }
  const internalObjectProto = {};
  const createInternalObject = () => Object.create(internalObjectProto);
  const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
  function initProps(instance, rawProps, isStateful, isSSR = false) {
    const props = {};
    const attrs = createInternalObject();
    instance.propsDefaults = Object.create(null);
    setFullProps(instance, rawProps, props, attrs);
    for (const key in instance.propsOptions[0]) {
      if (!(key in props)) {
        props[key] = void 0;
      }
    }
    if (isStateful) {
      instance.props = isSSR ? props : shallowReactive(props);
    } else {
      if (!instance.type.props) {
        instance.props = attrs;
      } else {
        instance.props = props;
      }
    }
    instance.attrs = attrs;
  }
  function updateProps(instance, rawProps, rawPrevProps, optimized) {
    const {
      props,
      attrs,
      vnode: { patchFlag }
    } = instance;
    const rawCurrentProps = toRaw(props);
    const [options] = instance.propsOptions;
    let hasAttrsChanged = false;
    if (


(optimized || patchFlag > 0) && !(patchFlag & 16)
    ) {
      if (patchFlag & 8) {
        const propsToUpdate = instance.vnode.dynamicProps;
        for (let i = 0; i < propsToUpdate.length; i++) {
          let key = propsToUpdate[i];
          if (isEmitListener(instance.emitsOptions, key)) {
            continue;
          }
          const value = rawProps[key];
          if (options) {
            if (hasOwn(attrs, key)) {
              if (value !== attrs[key]) {
                attrs[key] = value;
                hasAttrsChanged = true;
              }
            } else {
              const camelizedKey = camelize(key);
              props[camelizedKey] = resolvePropValue(
                options,
                rawCurrentProps,
                camelizedKey,
                value,
                instance,
                false
              );
            }
          } else {
            if (value !== attrs[key]) {
              attrs[key] = value;
              hasAttrsChanged = true;
            }
          }
        }
      }
    } else {
      if (setFullProps(instance, rawProps, props, attrs)) {
        hasAttrsChanged = true;
      }
      let kebabKey;
      for (const key in rawCurrentProps) {
        if (!rawProps ||
!hasOwn(rawProps, key) &&

((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
          if (options) {
            if (rawPrevProps &&
(rawPrevProps[key] !== void 0 ||
rawPrevProps[kebabKey] !== void 0)) {
              props[key] = resolvePropValue(
                options,
                rawCurrentProps,
                key,
                void 0,
                instance,
                true
              );
            }
          } else {
            delete props[key];
          }
        }
      }
      if (attrs !== rawCurrentProps) {
        for (const key in attrs) {
          if (!rawProps || !hasOwn(rawProps, key) && true) {
            delete attrs[key];
            hasAttrsChanged = true;
          }
        }
      }
    }
    if (hasAttrsChanged) {
      trigger(instance.attrs, "set", "");
    }
  }
  function setFullProps(instance, rawProps, props, attrs) {
    const [options, needCastKeys] = instance.propsOptions;
    let hasAttrsChanged = false;
    let rawCastValues;
    if (rawProps) {
      for (let key in rawProps) {
        if (isReservedProp(key)) {
          continue;
        }
        const value = rawProps[key];
        let camelKey;
        if (options && hasOwn(options, camelKey = camelize(key))) {
          if (!needCastKeys || !needCastKeys.includes(camelKey)) {
            props[camelKey] = value;
          } else {
            (rawCastValues || (rawCastValues = {}))[camelKey] = value;
          }
        } else if (!isEmitListener(instance.emitsOptions, key)) {
          if (!(key in attrs) || value !== attrs[key]) {
            attrs[key] = value;
            hasAttrsChanged = true;
          }
        }
      }
    }
    if (needCastKeys) {
      const rawCurrentProps = toRaw(props);
      const castValues = rawCastValues || EMPTY_OBJ;
      for (let i = 0; i < needCastKeys.length; i++) {
        const key = needCastKeys[i];
        props[key] = resolvePropValue(
          options,
          rawCurrentProps,
          key,
          castValues[key],
          instance,
          !hasOwn(castValues, key)
        );
      }
    }
    return hasAttrsChanged;
  }
  function resolvePropValue(options, props, key, value, instance, isAbsent) {
    const opt = options[key];
    if (opt != null) {
      const hasDefault = hasOwn(opt, "default");
      if (hasDefault && value === void 0) {
        const defaultValue = opt.default;
        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
          const { propsDefaults } = instance;
          if (key in propsDefaults) {
            value = propsDefaults[key];
          } else {
            const reset = setCurrentInstance(instance);
            value = propsDefaults[key] = defaultValue.call(
              null,
              props
            );
            reset();
          }
        } else {
          value = defaultValue;
        }
        if (instance.ce) {
          instance.ce._setProp(key, value);
        }
      }
      if (opt[
        0
]) {
        if (isAbsent && !hasDefault) {
          value = false;
        } else if (opt[
          1
] && (value === "" || value === hyphenate(key))) {
          value = true;
        }
      }
    }
    return value;
  }
  const mixinPropsCache = new WeakMap();
  function normalizePropsOptions(comp, appContext, asMixin = false) {
    const cache2 = asMixin ? mixinPropsCache : appContext.propsCache;
    const cached = cache2.get(comp);
    if (cached) {
      return cached;
    }
    const raw = comp.props;
    const normalized = {};
    const needCastKeys = [];
    let hasExtends = false;
    if (!isFunction(comp)) {
      const extendProps = (raw2) => {
        hasExtends = true;
        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
        extend(normalized, props);
        if (keys) needCastKeys.push(...keys);
      };
      if (!asMixin && appContext.mixins.length) {
        appContext.mixins.forEach(extendProps);
      }
      if (comp.extends) {
        extendProps(comp.extends);
      }
      if (comp.mixins) {
        comp.mixins.forEach(extendProps);
      }
    }
    if (!raw && !hasExtends) {
      if (isObject(comp)) {
        cache2.set(comp, EMPTY_ARR);
      }
      return EMPTY_ARR;
    }
    if (isArray(raw)) {
      for (let i = 0; i < raw.length; i++) {
        const normalizedKey = camelize(raw[i]);
        if (validatePropName(normalizedKey)) {
          normalized[normalizedKey] = EMPTY_OBJ;
        }
      }
    } else if (raw) {
      for (const key in raw) {
        const normalizedKey = camelize(key);
        if (validatePropName(normalizedKey)) {
          const opt = raw[key];
          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
          const propType = prop.type;
          let shouldCast = false;
          let shouldCastTrue = true;
          if (isArray(propType)) {
            for (let index = 0; index < propType.length; ++index) {
              const type = propType[index];
              const typeName = isFunction(type) && type.name;
              if (typeName === "Boolean") {
                shouldCast = true;
                break;
              } else if (typeName === "String") {
                shouldCastTrue = false;
              }
            }
          } else {
            shouldCast = isFunction(propType) && propType.name === "Boolean";
          }
          prop[
            0
] = shouldCast;
          prop[
            1
] = shouldCastTrue;
          if (shouldCast || hasOwn(prop, "default")) {
            needCastKeys.push(normalizedKey);
          }
        }
      }
    }
    const res = [normalized, needCastKeys];
    if (isObject(comp)) {
      cache2.set(comp, res);
    }
    return res;
  }
  function validatePropName(key) {
    if (key[0] !== "$" && !isReservedProp(key)) {
      return true;
    }
    return false;
  }
  const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
  const normalizeSlot = (key, rawSlot, ctx) => {
    if (rawSlot._n) {
      return rawSlot;
    }
    const normalized = withCtx((...args) => {
      if (false) ;
      return normalizeSlotValue(rawSlot(...args));
    }, ctx);
    normalized._c = false;
    return normalized;
  };
  const normalizeObjectSlots = (rawSlots, slots, instance) => {
    const ctx = rawSlots._ctx;
    for (const key in rawSlots) {
      if (isInternalKey(key)) continue;
      const value = rawSlots[key];
      if (isFunction(value)) {
        slots[key] = normalizeSlot(key, value, ctx);
      } else if (value != null) {
        const normalized = normalizeSlotValue(value);
        slots[key] = () => normalized;
      }
    }
  };
  const normalizeVNodeSlots = (instance, children) => {
    const normalized = normalizeSlotValue(children);
    instance.slots.default = () => normalized;
  };
  const assignSlots = (slots, children, optimized) => {
    for (const key in children) {
      if (optimized || !isInternalKey(key)) {
        slots[key] = children[key];
      }
    }
  };
  const initSlots = (instance, children, optimized) => {
    const slots = instance.slots = createInternalObject();
    if (instance.vnode.shapeFlag & 32) {
      const type = children._;
      if (type) {
        assignSlots(slots, children, optimized);
        if (optimized) {
          def(slots, "_", type, true);
        }
      } else {
        normalizeObjectSlots(children, slots);
      }
    } else if (children) {
      normalizeVNodeSlots(instance, children);
    }
  };
  const updateSlots = (instance, children, optimized) => {
    const { vnode, slots } = instance;
    let needDeletionCheck = true;
    let deletionComparisonTarget = EMPTY_OBJ;
    if (vnode.shapeFlag & 32) {
      const type = children._;
      if (type) {
        if (optimized && type === 1) {
          needDeletionCheck = false;
        } else {
          assignSlots(slots, children, optimized);
        }
      } else {
        needDeletionCheck = !children.$stable;
        normalizeObjectSlots(children, slots);
      }
      deletionComparisonTarget = children;
    } else if (children) {
      normalizeVNodeSlots(instance, children);
      deletionComparisonTarget = { default: 1 };
    }
    if (needDeletionCheck) {
      for (const key in slots) {
        if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
          delete slots[key];
        }
      }
    }
  };
  const queuePostRenderEffect = queueEffectWithSuspense;
  function createRenderer(options) {
    return baseCreateRenderer(options);
  }
  function baseCreateRenderer(options, createHydrationFns) {
    const target = getGlobalThis();
    target.__VUE__ = true;
    const {
      insert: hostInsert,
      remove: hostRemove,
      patchProp: hostPatchProp,
      createElement: hostCreateElement,
      createText: hostCreateText,
      createComment: hostCreateComment,
      setText: hostSetText,
      setElementText: hostSetElementText,
      parentNode: hostParentNode,
      nextSibling: hostNextSibling,
      setScopeId: hostSetScopeId = NOOP,
      insertStaticContent: hostInsertStaticContent
    } = options;
    const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
      if (n1 === n2) {
        return;
      }
      if (n1 && !isSameVNodeType(n1, n2)) {
        anchor = getNextHostNode(n1);
        unmount(n1, parentComponent, parentSuspense, true);
        n1 = null;
      }
      if (n2.patchFlag === -2) {
        optimized = false;
        n2.dynamicChildren = null;
      }
      const { type, ref: ref3, shapeFlag } = n2;
      switch (type) {
        case Text:
          processText(n1, n2, container, anchor);
          break;
        case Comment:
          processCommentNode(n1, n2, container, anchor);
          break;
        case Static:
          if (n1 == null) {
            mountStaticNode(n2, container, anchor, namespace);
          }
          break;
        case Fragment:
          processFragment(
            n1,
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
          break;
        default:
          if (shapeFlag & 1) {
            processElement(
              n1,
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
          } else if (shapeFlag & 6) {
            processComponent(
              n1,
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
          } else if (shapeFlag & 64) {
            type.process(
              n1,
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized,
              internals
            );
          } else if (shapeFlag & 128) {
            type.process(
              n1,
              n2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized,
              internals
            );
          } else ;
      }
      if (ref3 != null && parentComponent) {
        setRef(ref3, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
      } else if (ref3 == null && n1 && n1.ref != null) {
        setRef(n1.ref, null, parentSuspense, n1, true);
      }
    };
    const processText = (n1, n2, container, anchor) => {
      if (n1 == null) {
        hostInsert(
          n2.el = hostCreateText(n2.children),
          container,
          anchor
        );
      } else {
        const el = n2.el = n1.el;
        if (n2.children !== n1.children) {
          hostSetText(el, n2.children);
        }
      }
    };
    const processCommentNode = (n1, n2, container, anchor) => {
      if (n1 == null) {
        hostInsert(
          n2.el = hostCreateComment(n2.children || ""),
          container,
          anchor
        );
      } else {
        n2.el = n1.el;
      }
    };
    const mountStaticNode = (n2, container, anchor, namespace) => {
      [n2.el, n2.anchor] = hostInsertStaticContent(
        n2.children,
        container,
        anchor,
        namespace,
        n2.el,
        n2.anchor
      );
    };
    const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
      let next;
      while (el && el !== anchor) {
        next = hostNextSibling(el);
        hostInsert(el, container, nextSibling);
        el = next;
      }
      hostInsert(anchor, container, nextSibling);
    };
    const removeStaticNode = ({ el, anchor }) => {
      let next;
      while (el && el !== anchor) {
        next = hostNextSibling(el);
        hostRemove(el);
        el = next;
      }
      hostRemove(anchor);
    };
    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      if (n2.type === "svg") {
        namespace = "svg";
      } else if (n2.type === "math") {
        namespace = "mathml";
      }
      if (n1 == null) {
        mountElement(
          n2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      } else {
        const customElement = n1.el && n1.el._isVueCE ? n1.el : null;
        try {
          if (customElement) {
            customElement._beginPatch();
          }
          patchElement(
            n1,
            n2,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } finally {
          if (customElement) {
            customElement._endPatch();
          }
        }
      }
    };
    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      let el;
      let vnodeHook;
      const { props, shapeFlag, transition, dirs } = vnode;
      el = vnode.el = hostCreateElement(
        vnode.type,
        namespace,
        props && props.is,
        props
      );
      if (shapeFlag & 8) {
        hostSetElementText(el, vnode.children);
      } else if (shapeFlag & 16) {
        mountChildren(
          vnode.children,
          el,
          null,
          parentComponent,
          parentSuspense,
          resolveChildrenNamespace(vnode, namespace),
          slotScopeIds,
          optimized
        );
      }
      if (dirs) {
        invokeDirectiveHook(vnode, null, parentComponent, "created");
      }
      setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
      if (props) {
        for (const key in props) {
          if (key !== "value" && !isReservedProp(key)) {
            hostPatchProp(el, key, null, props[key], namespace, parentComponent);
          }
        }
        if ("value" in props) {
          hostPatchProp(el, "value", null, props.value, namespace);
        }
        if (vnodeHook = props.onVnodeBeforeMount) {
          invokeVNodeHook(vnodeHook, parentComponent, vnode);
        }
      }
      if (dirs) {
        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
      }
      const needCallTransitionHooks = needTransition(parentSuspense, transition);
      if (needCallTransitionHooks) {
        transition.beforeEnter(el);
      }
      hostInsert(el, container, anchor);
      if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
        queuePostRenderEffect(() => {
          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
          needCallTransitionHooks && transition.enter(el);
          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
        }, parentSuspense);
      }
    };
    const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
      if (scopeId) {
        hostSetScopeId(el, scopeId);
      }
      if (slotScopeIds) {
        for (let i = 0; i < slotScopeIds.length; i++) {
          hostSetScopeId(el, slotScopeIds[i]);
        }
      }
      if (parentComponent) {
        let subTree = parentComponent.subTree;
        if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
          const parentVNode = parentComponent.vnode;
          setScopeId(
            el,
            parentVNode,
            parentVNode.scopeId,
            parentVNode.slotScopeIds,
            parentComponent.parent
          );
        }
      }
    };
    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
      for (let i = start; i < children.length; i++) {
        const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
        patch(
          null,
          child,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      }
    };
    const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      const el = n2.el = n1.el;
      let { patchFlag, dynamicChildren, dirs } = n2;
      patchFlag |= n1.patchFlag & 16;
      const oldProps = n1.props || EMPTY_OBJ;
      const newProps = n2.props || EMPTY_OBJ;
      let vnodeHook;
      parentComponent && toggleRecurse(parentComponent, false);
      if (vnodeHook = newProps.onVnodeBeforeUpdate) {
        invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
      }
      if (dirs) {
        invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
      }
      parentComponent && toggleRecurse(parentComponent, true);
      if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
        hostSetElementText(el, "");
      }
      if (dynamicChildren) {
        patchBlockChildren(
          n1.dynamicChildren,
          dynamicChildren,
          el,
          parentComponent,
          parentSuspense,
          resolveChildrenNamespace(n2, namespace),
          slotScopeIds
        );
      } else if (!optimized) {
        patchChildren(
          n1,
          n2,
          el,
          null,
          parentComponent,
          parentSuspense,
          resolveChildrenNamespace(n2, namespace),
          slotScopeIds,
          false
        );
      }
      if (patchFlag > 0) {
        if (patchFlag & 16) {
          patchProps(el, oldProps, newProps, parentComponent, namespace);
        } else {
          if (patchFlag & 2) {
            if (oldProps.class !== newProps.class) {
              hostPatchProp(el, "class", null, newProps.class, namespace);
            }
          }
          if (patchFlag & 4) {
            hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
          }
          if (patchFlag & 8) {
            const propsToUpdate = n2.dynamicProps;
            for (let i = 0; i < propsToUpdate.length; i++) {
              const key = propsToUpdate[i];
              const prev = oldProps[key];
              const next = newProps[key];
              if (next !== prev || key === "value") {
                hostPatchProp(el, key, prev, next, namespace, parentComponent);
              }
            }
          }
        }
        if (patchFlag & 1) {
          if (n1.children !== n2.children) {
            hostSetElementText(el, n2.children);
          }
        }
      } else if (!optimized && dynamicChildren == null) {
        patchProps(el, oldProps, newProps, parentComponent, namespace);
      }
      if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
        queuePostRenderEffect(() => {
          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
          dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
        }, parentSuspense);
      }
    };
    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
      for (let i = 0; i < newChildren.length; i++) {
        const oldVNode = oldChildren[i];
        const newVNode = newChildren[i];
        const container = (

oldVNode.el &&

(oldVNode.type === Fragment ||

!isSameVNodeType(oldVNode, newVNode) ||
oldVNode.shapeFlag & (6 | 64 | 128)) ? hostParentNode(oldVNode.el) : (

fallbackContainer
          )
        );
        patch(
          oldVNode,
          newVNode,
          container,
          null,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          true
        );
      }
    };
    const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
      if (oldProps !== newProps) {
        if (oldProps !== EMPTY_OBJ) {
          for (const key in oldProps) {
            if (!isReservedProp(key) && !(key in newProps)) {
              hostPatchProp(
                el,
                key,
                oldProps[key],
                null,
                namespace,
                parentComponent
              );
            }
          }
        }
        for (const key in newProps) {
          if (isReservedProp(key)) continue;
          const next = newProps[key];
          const prev = oldProps[key];
          if (next !== prev && key !== "value") {
            hostPatchProp(el, key, prev, next, namespace, parentComponent);
          }
        }
        if ("value" in newProps) {
          hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
        }
      }
    };
    const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
      const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
      let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
      if (fragmentSlotScopeIds) {
        slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
      }
      if (n1 == null) {
        hostInsert(fragmentStartAnchor, container, anchor);
        hostInsert(fragmentEndAnchor, container, anchor);
        mountChildren(



n2.children || [],
          container,
          fragmentEndAnchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      } else {
        if (patchFlag > 0 && patchFlag & 64 && dynamicChildren &&

n1.dynamicChildren && n1.dynamicChildren.length === dynamicChildren.length) {
          patchBlockChildren(
            n1.dynamicChildren,
            dynamicChildren,
            container,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds
          );
          if (



n2.key != null || parentComponent && n2 === parentComponent.subTree
          ) {
            traverseStaticChildren(
              n1,
              n2,
              true
);
          }
        } else {
          patchChildren(
            n1,
            n2,
            container,
            fragmentEndAnchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        }
      }
    };
    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      n2.slotScopeIds = slotScopeIds;
      if (n1 == null) {
        if (n2.shapeFlag & 512) {
          parentComponent.ctx.activate(
            n2,
            container,
            anchor,
            namespace,
            optimized
          );
        } else {
          mountComponent(
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            optimized
          );
        }
      } else {
        updateComponent(n1, n2, optimized);
      }
    };
    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
      const instance = initialVNode.component = createComponentInstance(
        initialVNode,
        parentComponent,
        parentSuspense
      );
      if (isKeepAlive(initialVNode)) {
        instance.ctx.renderer = internals;
      }
      {
        setupComponent(instance, false, optimized);
      }
      if (instance.asyncDep) {
        parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
        if (!initialVNode.el) {
          const placeholder = instance.subTree = createVNode(Comment);
          processCommentNode(null, placeholder, container, anchor);
          initialVNode.placeholder = placeholder.el;
        }
      } else {
        setupRenderEffect(
          instance,
          initialVNode,
          container,
          anchor,
          parentSuspense,
          namespace,
          optimized
        );
      }
    };
    const updateComponent = (n1, n2, optimized) => {
      const instance = n2.component = n1.component;
      if (shouldUpdateComponent(n1, n2, optimized)) {
        if (instance.asyncDep && !instance.asyncResolved) {
          updateComponentPreRender(instance, n2, optimized);
          return;
        } else {
          instance.next = n2;
          instance.update();
        }
      } else {
        n2.el = n1.el;
        instance.vnode = n2;
      }
    };
    const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
      const componentUpdateFn = () => {
        if (!instance.isMounted) {
          let vnodeHook;
          const { el, props } = initialVNode;
          const { bm, m, parent, root, type } = instance;
          const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
          toggleRecurse(instance, false);
          if (bm) {
            invokeArrayFns(bm);
          }
          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
            invokeVNodeHook(vnodeHook, parent, initialVNode);
          }
          toggleRecurse(instance, true);
          {
            if (root.ce && root.ce._hasShadowRoot()) {
              root.ce._injectChildStyle(type);
            }
            const subTree = instance.subTree = renderComponentRoot(instance);
            patch(
              null,
              subTree,
              container,
              anchor,
              instance,
              parentSuspense,
              namespace
            );
            initialVNode.el = subTree.el;
          }
          if (m) {
            queuePostRenderEffect(m, parentSuspense);
          }
          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
            const scopedInitialVNode = initialVNode;
            queuePostRenderEffect(
              () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
              parentSuspense
            );
          }
          if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
            instance.a && queuePostRenderEffect(instance.a, parentSuspense);
          }
          instance.isMounted = true;
          initialVNode = container = anchor = null;
        } else {
          let { next, bu, u, parent, vnode } = instance;
          {
            const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
            if (nonHydratedAsyncRoot) {
              if (next) {
                next.el = vnode.el;
                updateComponentPreRender(instance, next, optimized);
              }
              nonHydratedAsyncRoot.asyncDep.then(() => {
                queuePostRenderEffect(() => {
                  if (!instance.isUnmounted) update();
                }, parentSuspense);
              });
              return;
            }
          }
          let originNext = next;
          let vnodeHook;
          toggleRecurse(instance, false);
          if (next) {
            next.el = vnode.el;
            updateComponentPreRender(instance, next, optimized);
          } else {
            next = vnode;
          }
          if (bu) {
            invokeArrayFns(bu);
          }
          if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
            invokeVNodeHook(vnodeHook, parent, next, vnode);
          }
          toggleRecurse(instance, true);
          const nextTree = renderComponentRoot(instance);
          const prevTree = instance.subTree;
          instance.subTree = nextTree;
          patch(
            prevTree,
            nextTree,
hostParentNode(prevTree.el),
getNextHostNode(prevTree),
            instance,
            parentSuspense,
            namespace
          );
          next.el = nextTree.el;
          if (originNext === null) {
            updateHOCHostEl(instance, nextTree.el);
          }
          if (u) {
            queuePostRenderEffect(u, parentSuspense);
          }
          if (vnodeHook = next.props && next.props.onVnodeUpdated) {
            queuePostRenderEffect(
              () => invokeVNodeHook(vnodeHook, parent, next, vnode),
              parentSuspense
            );
          }
        }
      };
      instance.scope.on();
      const effect2 = instance.effect = new ReactiveEffect(componentUpdateFn);
      instance.scope.off();
      const update = instance.update = effect2.run.bind(effect2);
      const job = instance.job = effect2.runIfDirty.bind(effect2);
      job.i = instance;
      job.id = instance.uid;
      effect2.scheduler = () => queueJob(job);
      toggleRecurse(instance, true);
      update();
    };
    const updateComponentPreRender = (instance, nextVNode, optimized) => {
      nextVNode.component = instance;
      const prevProps = instance.vnode.props;
      instance.vnode = nextVNode;
      instance.next = null;
      updateProps(instance, nextVNode.props, prevProps, optimized);
      updateSlots(instance, nextVNode.children, optimized);
      pauseTracking();
      flushPreFlushCbs(instance);
      resetTracking();
    };
    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
      const c1 = n1 && n1.children;
      const prevShapeFlag = n1 ? n1.shapeFlag : 0;
      const c2 = n2.children;
      const { patchFlag, shapeFlag } = n2;
      if (patchFlag > 0) {
        if (patchFlag & 128) {
          patchKeyedChildren(
            c1,
            c2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
          return;
        } else if (patchFlag & 256) {
          patchUnkeyedChildren(
            c1,
            c2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
          return;
        }
      }
      if (shapeFlag & 8) {
        if (prevShapeFlag & 16) {
          unmountChildren(c1, parentComponent, parentSuspense);
        }
        if (c2 !== c1) {
          hostSetElementText(container, c2);
        }
      } else {
        if (prevShapeFlag & 16) {
          if (shapeFlag & 16) {
            patchKeyedChildren(
              c1,
              c2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
          } else {
            unmountChildren(c1, parentComponent, parentSuspense, true);
          }
        } else {
          if (prevShapeFlag & 8) {
            hostSetElementText(container, "");
          }
          if (shapeFlag & 16) {
            mountChildren(
              c2,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
          }
        }
      }
    };
    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      c1 = c1 || EMPTY_ARR;
      c2 = c2 || EMPTY_ARR;
      const oldLength = c1.length;
      const newLength = c2.length;
      const commonLength = Math.min(oldLength, newLength);
      let i;
      for (i = 0; i < commonLength; i++) {
        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
        patch(
          c1[i],
          nextChild,
          container,
          null,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      }
      if (oldLength > newLength) {
        unmountChildren(
          c1,
          parentComponent,
          parentSuspense,
          true,
          false,
          commonLength
        );
      } else {
        mountChildren(
          c2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized,
          commonLength
        );
      }
    };
    const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
      let i = 0;
      const l2 = c2.length;
      let e1 = c1.length - 1;
      let e2 = l2 - 1;
      while (i <= e1 && i <= e2) {
        const n1 = c1[i];
        const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
        if (isSameVNodeType(n1, n2)) {
          patch(
            n1,
            n2,
            container,
            null,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else {
          break;
        }
        i++;
      }
      while (i <= e1 && i <= e2) {
        const n1 = c1[e1];
        const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
        if (isSameVNodeType(n1, n2)) {
          patch(
            n1,
            n2,
            container,
            null,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else {
          break;
        }
        e1--;
        e2--;
      }
      if (i > e1) {
        if (i <= e2) {
          const nextPos = e2 + 1;
          const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
          while (i <= e2) {
            patch(
              null,
              c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
            i++;
          }
        }
      } else if (i > e2) {
        while (i <= e1) {
          unmount(c1[i], parentComponent, parentSuspense, true);
          i++;
        }
      } else {
        const s1 = i;
        const s2 = i;
        const keyToNewIndexMap = new Map();
        for (i = s2; i <= e2; i++) {
          const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
          if (nextChild.key != null) {
            keyToNewIndexMap.set(nextChild.key, i);
          }
        }
        let j;
        let patched = 0;
        const toBePatched = e2 - s2 + 1;
        let moved = false;
        let maxNewIndexSoFar = 0;
        const newIndexToOldIndexMap = new Array(toBePatched);
        for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
        for (i = s1; i <= e1; i++) {
          const prevChild = c1[i];
          if (patched >= toBePatched) {
            unmount(prevChild, parentComponent, parentSuspense, true);
            continue;
          }
          let newIndex;
          if (prevChild.key != null) {
            newIndex = keyToNewIndexMap.get(prevChild.key);
          } else {
            for (j = s2; j <= e2; j++) {
              if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
                newIndex = j;
                break;
              }
            }
          }
          if (newIndex === void 0) {
            unmount(prevChild, parentComponent, parentSuspense, true);
          } else {
            newIndexToOldIndexMap[newIndex - s2] = i + 1;
            if (newIndex >= maxNewIndexSoFar) {
              maxNewIndexSoFar = newIndex;
            } else {
              moved = true;
            }
            patch(
              prevChild,
              c2[newIndex],
              container,
              null,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
            patched++;
          }
        }
        const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
        j = increasingNewIndexSequence.length - 1;
        for (i = toBePatched - 1; i >= 0; i--) {
          const nextIndex = s2 + i;
          const nextChild = c2[nextIndex];
          const anchorVNode = c2[nextIndex + 1];
          const anchor = nextIndex + 1 < l2 ? (
anchorVNode.el || resolveAsyncComponentPlaceholder(anchorVNode)
          ) : parentAnchor;
          if (newIndexToOldIndexMap[i] === 0) {
            patch(
              null,
              nextChild,
              container,
              anchor,
              parentComponent,
              parentSuspense,
              namespace,
              slotScopeIds,
              optimized
            );
          } else if (moved) {
            if (j < 0 || i !== increasingNewIndexSequence[j]) {
              move(nextChild, container, anchor, 2);
            } else {
              j--;
            }
          }
        }
      }
    };
    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
      const { el, type, transition, children, shapeFlag } = vnode;
      if (shapeFlag & 6) {
        move(vnode.component.subTree, container, anchor, moveType);
        return;
      }
      if (shapeFlag & 128) {
        vnode.suspense.move(container, anchor, moveType);
        return;
      }
      if (shapeFlag & 64) {
        type.move(vnode, container, anchor, internals);
        return;
      }
      if (type === Fragment) {
        hostInsert(el, container, anchor);
        for (let i = 0; i < children.length; i++) {
          move(children[i], container, anchor, moveType);
        }
        hostInsert(vnode.anchor, container, anchor);
        return;
      }
      if (type === Static) {
        moveStaticNode(vnode, container, anchor);
        return;
      }
      const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
      if (needTransition2) {
        if (moveType === 0) {
          transition.beforeEnter(el);
          hostInsert(el, container, anchor);
          queuePostRenderEffect(() => transition.enter(el), parentSuspense);
        } else {
          const { leave, delayLeave, afterLeave } = transition;
          const remove22 = () => {
            if (vnode.ctx.isUnmounted) {
              hostRemove(el);
            } else {
              hostInsert(el, container, anchor);
            }
          };
          const performLeave = () => {
            if (el._isLeaving) {
              el[leaveCbKey](
                true
);
            }
            leave(el, () => {
              remove22();
              afterLeave && afterLeave();
            });
          };
          if (delayLeave) {
            delayLeave(el, remove22, performLeave);
          } else {
            performLeave();
          }
        }
      } else {
        hostInsert(el, container, anchor);
      }
    };
    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
      const {
        type,
        props,
        ref: ref3,
        children,
        dynamicChildren,
        shapeFlag,
        patchFlag,
        dirs,
        cacheIndex
      } = vnode;
      if (patchFlag === -2) {
        optimized = false;
      }
      if (ref3 != null) {
        pauseTracking();
        setRef(ref3, null, parentSuspense, vnode, true);
        resetTracking();
      }
      if (cacheIndex != null) {
        parentComponent.renderCache[cacheIndex] = void 0;
      }
      if (shapeFlag & 256) {
        parentComponent.ctx.deactivate(vnode);
        return;
      }
      const shouldInvokeDirs = shapeFlag & 1 && dirs;
      const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
      let vnodeHook;
      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
        invokeVNodeHook(vnodeHook, parentComponent, vnode);
      }
      if (shapeFlag & 6) {
        unmountComponent(vnode.component, parentSuspense, doRemove);
      } else {
        if (shapeFlag & 128) {
          vnode.suspense.unmount(parentSuspense, doRemove);
          return;
        }
        if (shouldInvokeDirs) {
          invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
        }
        if (shapeFlag & 64) {
          vnode.type.remove(
            vnode,
            parentComponent,
            parentSuspense,
            internals,
            doRemove
          );
        } else if (dynamicChildren &&




!dynamicChildren.hasOnce &&
(type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
          unmountChildren(
            dynamicChildren,
            parentComponent,
            parentSuspense,
            false,
            true
          );
        } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
          unmountChildren(children, parentComponent, parentSuspense);
        }
        if (doRemove) {
          remove2(vnode);
        }
      }
      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
        queuePostRenderEffect(() => {
          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
          shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
        }, parentSuspense);
      }
    };
    const remove2 = (vnode) => {
      const { type, el, anchor, transition } = vnode;
      if (type === Fragment) {
        {
          removeFragment(el, anchor);
        }
        return;
      }
      if (type === Static) {
        removeStaticNode(vnode);
        return;
      }
      const performRemove = () => {
        hostRemove(el);
        if (transition && !transition.persisted && transition.afterLeave) {
          transition.afterLeave();
        }
      };
      if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
        const { leave, delayLeave } = transition;
        const performLeave = () => leave(el, performRemove);
        if (delayLeave) {
          delayLeave(vnode.el, performRemove, performLeave);
        } else {
          performLeave();
        }
      } else {
        performRemove();
      }
    };
    const removeFragment = (cur, end) => {
      let next;
      while (cur !== end) {
        next = hostNextSibling(cur);
        hostRemove(cur);
        cur = next;
      }
      hostRemove(end);
    };
    const unmountComponent = (instance, parentSuspense, doRemove) => {
      const { bum, scope, job, subTree, um, m, a } = instance;
      invalidateMount(m);
      invalidateMount(a);
      if (bum) {
        invokeArrayFns(bum);
      }
      scope.stop();
      if (job) {
        job.flags |= 8;
        unmount(subTree, instance, parentSuspense, doRemove);
      }
      if (um) {
        queuePostRenderEffect(um, parentSuspense);
      }
      queuePostRenderEffect(() => {
        instance.isUnmounted = true;
      }, parentSuspense);
    };
    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
      for (let i = start; i < children.length; i++) {
        unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
      }
    };
    const getNextHostNode = (vnode) => {
      if (vnode.shapeFlag & 6) {
        return getNextHostNode(vnode.component.subTree);
      }
      if (vnode.shapeFlag & 128) {
        return vnode.suspense.next();
      }
      const el = hostNextSibling(vnode.anchor || vnode.el);
      const teleportEnd = el && el[TeleportEndKey];
      return teleportEnd ? hostNextSibling(teleportEnd) : el;
    };
    let isFlushing = false;
    const render2 = (vnode, container, namespace) => {
      let instance;
      if (vnode == null) {
        if (container._vnode) {
          unmount(container._vnode, null, null, true);
          instance = container._vnode.component;
        }
      } else {
        patch(
          container._vnode || null,
          vnode,
          container,
          null,
          null,
          null,
          namespace
        );
      }
      container._vnode = vnode;
      if (!isFlushing) {
        isFlushing = true;
        flushPreFlushCbs(instance);
        flushPostFlushCbs();
        isFlushing = false;
      }
    };
    const internals = {
      p: patch,
      um: unmount,
      m: move,
      r: remove2,
      mt: mountComponent,
      mc: mountChildren,
      pc: patchChildren,
      pbc: patchBlockChildren,
      n: getNextHostNode,
      o: options
    };
    let hydrate;
    return {
      render: render2,
      hydrate,
      createApp: createAppAPI(render2)
    };
  }
  function resolveChildrenNamespace({ type, props }, currentNamespace) {
    return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
  }
  function toggleRecurse({ effect: effect2, job }, allowed) {
    if (allowed) {
      effect2.flags |= 32;
      job.flags |= 4;
    } else {
      effect2.flags &= -33;
      job.flags &= -5;
    }
  }
  function needTransition(parentSuspense, transition) {
    return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
  }
  function traverseStaticChildren(n1, n2, shallow = false) {
    const ch1 = n1.children;
    const ch2 = n2.children;
    if (isArray(ch1) && isArray(ch2)) {
      for (let i = 0; i < ch1.length; i++) {
        const c1 = ch1[i];
        let c2 = ch2[i];
        if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
          if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
            c2 = ch2[i] = cloneIfMounted(ch2[i]);
            c2.el = c1.el;
          }
          if (!shallow && c2.patchFlag !== -2)
            traverseStaticChildren(c1, c2);
        }
        if (c2.type === Text) {
          if (c2.patchFlag === -1) {
            c2 = ch2[i] = cloneIfMounted(c2);
          }
          c2.el = c1.el;
        }
        if (c2.type === Comment && !c2.el) {
          c2.el = c1.el;
        }
      }
    }
  }
  function getSequence(arr) {
    const p2 = arr.slice();
    const result = [0];
    let i, j, u, v, c;
    const len = arr.length;
    for (i = 0; i < len; i++) {
      const arrI = arr[i];
      if (arrI !== 0) {
        j = result[result.length - 1];
        if (arr[j] < arrI) {
          p2[i] = j;
          result.push(i);
          continue;
        }
        u = 0;
        v = result.length - 1;
        while (u < v) {
          c = u + v >> 1;
          if (arr[result[c]] < arrI) {
            u = c + 1;
          } else {
            v = c;
          }
        }
        if (arrI < arr[result[u]]) {
          if (u > 0) {
            p2[i] = result[u - 1];
          }
          result[u] = i;
        }
      }
    }
    u = result.length;
    v = result[u - 1];
    while (u-- > 0) {
      result[u] = v;
      v = p2[v];
    }
    return result;
  }
  function locateNonHydratedAsyncRoot(instance) {
    const subComponent = instance.subTree.component;
    if (subComponent) {
      if (subComponent.asyncDep && !subComponent.asyncResolved) {
        return subComponent;
      } else {
        return locateNonHydratedAsyncRoot(subComponent);
      }
    }
  }
  function invalidateMount(hooks) {
    if (hooks) {
      for (let i = 0; i < hooks.length; i++)
        hooks[i].flags |= 8;
    }
  }
  function resolveAsyncComponentPlaceholder(anchorVnode) {
    if (anchorVnode.placeholder) {
      return anchorVnode.placeholder;
    }
    const instance = anchorVnode.component;
    if (instance) {
      return resolveAsyncComponentPlaceholder(instance.subTree);
    }
    return null;
  }
  const isSuspense = (type) => type.__isSuspense;
  function queueEffectWithSuspense(fn, suspense) {
    if (suspense && suspense.pendingBranch) {
      if (isArray(fn)) {
        suspense.effects.push(...fn);
      } else {
        suspense.effects.push(fn);
      }
    } else {
      queuePostFlushCb(fn);
    }
  }
  const Fragment = Symbol.for("v-fgt");
  const Text = Symbol.for("v-txt");
  const Comment = Symbol.for("v-cmt");
  const Static = Symbol.for("v-stc");
  const blockStack = [];
  let currentBlock = null;
  function openBlock(disableTracking = false) {
    blockStack.push(currentBlock = disableTracking ? null : []);
  }
  function closeBlock() {
    blockStack.pop();
    currentBlock = blockStack[blockStack.length - 1] || null;
  }
  let isBlockTreeEnabled = 1;
  function setBlockTracking(value, inVOnce = false) {
    isBlockTreeEnabled += value;
    if (value < 0 && currentBlock && inVOnce) {
      currentBlock.hasOnce = true;
    }
  }
  function setupBlock(vnode) {
    vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
    closeBlock();
    if (isBlockTreeEnabled > 0 && currentBlock) {
      currentBlock.push(vnode);
    }
    return vnode;
  }
  function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
    return setupBlock(
      createBaseVNode(
        type,
        props,
        children,
        patchFlag,
        dynamicProps,
        shapeFlag,
        true
      )
    );
  }
  function createBlock(type, props, children, patchFlag, dynamicProps) {
    return setupBlock(
      createVNode(
        type,
        props,
        children,
        patchFlag,
        dynamicProps,
        true
      )
    );
  }
  function isVNode(value) {
    return value ? value.__v_isVNode === true : false;
  }
  function isSameVNodeType(n1, n2) {
    return n1.type === n2.type && n1.key === n2.key;
  }
  const normalizeKey = ({ key }) => key != null ? key : null;
  const normalizeRef = ({
    ref: ref3,
    ref_key,
    ref_for
  }) => {
    if (typeof ref3 === "number") {
      ref3 = "" + ref3;
    }
    return ref3 != null ? isString(ref3) || isRef(ref3) || isFunction(ref3) ? { i: currentRenderingInstance, r: ref3, k: ref_key, f: !!ref_for } : ref3 : null;
  };
  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
    const vnode = {
      __v_isVNode: true,
      __v_skip: true,
      type,
      props,
      key: props && normalizeKey(props),
      ref: props && normalizeRef(props),
      scopeId: currentScopeId,
      slotScopeIds: null,
      children,
      component: null,
      suspense: null,
      ssContent: null,
      ssFallback: null,
      dirs: null,
      transition: null,
      el: null,
      anchor: null,
      target: null,
      targetStart: null,
      targetAnchor: null,
      staticCount: 0,
      shapeFlag,
      patchFlag,
      dynamicProps,
      dynamicChildren: null,
      appContext: null,
      ctx: currentRenderingInstance
    };
    if (needFullChildrenNormalization) {
      normalizeChildren(vnode, children);
      if (shapeFlag & 128) {
        type.normalize(vnode);
      }
    } else if (children) {
      vnode.shapeFlag |= isString(children) ? 8 : 16;
    }
    if (isBlockTreeEnabled > 0 &&
!isBlockNode &&
currentBlock &&



(vnode.patchFlag > 0 || shapeFlag & 6) &&

vnode.patchFlag !== 32) {
      currentBlock.push(vnode);
    }
    return vnode;
  }
  const createVNode = _createVNode;
  function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
    if (!type || type === NULL_DYNAMIC_COMPONENT) {
      type = Comment;
    }
    if (isVNode(type)) {
      const cloned = cloneVNode(
        type,
        props,
        true
);
      if (children) {
        normalizeChildren(cloned, children);
      }
      if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
        if (cloned.shapeFlag & 6) {
          currentBlock[currentBlock.indexOf(type)] = cloned;
        } else {
          currentBlock.push(cloned);
        }
      }
      cloned.patchFlag = -2;
      return cloned;
    }
    if (isClassComponent(type)) {
      type = type.__vccOpts;
    }
    if (props) {
      props = guardReactiveProps(props);
      let { class: klass, style } = props;
      if (klass && !isString(klass)) {
        props.class = normalizeClass(klass);
      }
      if (isObject(style)) {
        if ( isProxy(style) && !isArray(style)) {
          style = extend({}, style);
        }
        props.style = normalizeStyle(style);
      }
    }
    const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
    return createBaseVNode(
      type,
      props,
      children,
      patchFlag,
      dynamicProps,
      shapeFlag,
      isBlockNode,
      true
    );
  }
  function guardReactiveProps(props) {
    if (!props) return null;
    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
  }
  function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
    const { props, ref: ref3, patchFlag, children, transition } = vnode;
    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
    const cloned = {
      __v_isVNode: true,
      __v_skip: true,
      type: vnode.type,
      props: mergedProps,
      key: mergedProps && normalizeKey(mergedProps),
      ref: extraProps && extraProps.ref ? (


mergeRef && ref3 ? isArray(ref3) ? ref3.concat(normalizeRef(extraProps)) : [ref3, normalizeRef(extraProps)] : normalizeRef(extraProps)
      ) : ref3,
      scopeId: vnode.scopeId,
      slotScopeIds: vnode.slotScopeIds,
      children,
      target: vnode.target,
      targetStart: vnode.targetStart,
      targetAnchor: vnode.targetAnchor,
      staticCount: vnode.staticCount,
      shapeFlag: vnode.shapeFlag,



patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
      dynamicProps: vnode.dynamicProps,
      dynamicChildren: vnode.dynamicChildren,
      appContext: vnode.appContext,
      dirs: vnode.dirs,
      transition,



component: vnode.component,
      suspense: vnode.suspense,
      ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
      ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
      placeholder: vnode.placeholder,
      el: vnode.el,
      anchor: vnode.anchor,
      ctx: vnode.ctx,
      ce: vnode.ce
    };
    if (transition && cloneTransition) {
      setTransitionHooks(
        cloned,
        transition.clone(cloned)
      );
    }
    return cloned;
  }
  function createTextVNode(text = " ", flag = 0) {
    return createVNode(Text, null, text, flag);
  }
  function createCommentVNode(text = "", asBlock = false) {
    return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
  }
  function normalizeVNode(child) {
    if (child == null || typeof child === "boolean") {
      return createVNode(Comment);
    } else if (isArray(child)) {
      return createVNode(
        Fragment,
        null,
child.slice()
      );
    } else if (isVNode(child)) {
      return cloneIfMounted(child);
    } else {
      return createVNode(Text, null, String(child));
    }
  }
  function cloneIfMounted(child) {
    return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
  }
  function normalizeChildren(vnode, children) {
    let type = 0;
    const { shapeFlag } = vnode;
    if (children == null) {
      children = null;
    } else if (isArray(children)) {
      type = 16;
    } else if (typeof children === "object") {
      if (shapeFlag & (1 | 64)) {
        const slot = children.default;
        if (slot) {
          slot._c && (slot._d = false);
          normalizeChildren(vnode, slot());
          slot._c && (slot._d = true);
        }
        return;
      } else {
        type = 32;
        const slotFlag = children._;
        if (!slotFlag && !isInternalObject(children)) {
          children._ctx = currentRenderingInstance;
        } else if (slotFlag === 3 && currentRenderingInstance) {
          if (currentRenderingInstance.slots._ === 1) {
            children._ = 1;
          } else {
            children._ = 2;
            vnode.patchFlag |= 1024;
          }
        }
      }
    } else if (isFunction(children)) {
      children = { default: children, _ctx: currentRenderingInstance };
      type = 32;
    } else {
      children = String(children);
      if (shapeFlag & 64) {
        type = 16;
        children = [createTextVNode(children)];
      } else {
        type = 8;
      }
    }
    vnode.children = children;
    vnode.shapeFlag |= type;
  }
  function mergeProps(...args) {
    const ret = {};
    for (let i = 0; i < args.length; i++) {
      const toMerge = args[i];
      for (const key in toMerge) {
        if (key === "class") {
          if (ret.class !== toMerge.class) {
            ret.class = normalizeClass([ret.class, toMerge.class]);
          }
        } else if (key === "style") {
          ret.style = normalizeStyle([ret.style, toMerge.style]);
        } else if (isOn(key)) {
          const existing = ret[key];
          const incoming = toMerge[key];
          if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
            ret[key] = existing ? [].concat(existing, incoming) : incoming;
          }
        } else if (key !== "") {
          ret[key] = toMerge[key];
        }
      }
    }
    return ret;
  }
  function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
    callWithAsyncErrorHandling(hook, instance, 7, [
      vnode,
      prevVNode
    ]);
  }
  const emptyAppContext = createAppContext();
  let uid = 0;
  function createComponentInstance(vnode, parent, suspense) {
    const type = vnode.type;
    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
    const instance = {
      uid: uid++,
      vnode,
      type,
      parent,
      appContext,
      root: null,
next: null,
      subTree: null,
effect: null,
      update: null,
job: null,
      scope: new EffectScope(
        true
),
      render: null,
      proxy: null,
      exposed: null,
      exposeProxy: null,
      withProxy: null,
      provides: parent ? parent.provides : Object.create(appContext.provides),
      ids: parent ? parent.ids : ["", 0, 0],
      accessCache: null,
      renderCache: [],
components: null,
      directives: null,
propsOptions: normalizePropsOptions(type, appContext),
      emitsOptions: normalizeEmitsOptions(type, appContext),
emit: null,
emitted: null,
propsDefaults: EMPTY_OBJ,
inheritAttrs: type.inheritAttrs,
ctx: EMPTY_OBJ,
      data: EMPTY_OBJ,
      props: EMPTY_OBJ,
      attrs: EMPTY_OBJ,
      slots: EMPTY_OBJ,
      refs: EMPTY_OBJ,
      setupState: EMPTY_OBJ,
      setupContext: null,
suspense,
      suspenseId: suspense ? suspense.pendingId : 0,
      asyncDep: null,
      asyncResolved: false,

isMounted: false,
      isUnmounted: false,
      isDeactivated: false,
      bc: null,
      c: null,
      bm: null,
      m: null,
      bu: null,
      u: null,
      um: null,
      bum: null,
      da: null,
      a: null,
      rtg: null,
      rtc: null,
      ec: null,
      sp: null
    };
    {
      instance.ctx = { _: instance };
    }
    instance.root = parent ? parent.root : instance;
    instance.emit = emit.bind(null, instance);
    if (vnode.ce) {
      vnode.ce(instance);
    }
    return instance;
  }
  let currentInstance = null;
  const getCurrentInstance = () => currentInstance || currentRenderingInstance;
  let internalSetCurrentInstance;
  let setInSSRSetupState;
  {
    const g = getGlobalThis();
    const registerGlobalSetter = (key, setter) => {
      let setters;
      if (!(setters = g[key])) setters = g[key] = [];
      setters.push(setter);
      return (v) => {
        if (setters.length > 1) setters.forEach((set) => set(v));
        else setters[0](v);
      };
    };
    internalSetCurrentInstance = registerGlobalSetter(
      `__VUE_INSTANCE_SETTERS__`,
      (v) => currentInstance = v
    );
    setInSSRSetupState = registerGlobalSetter(
      `__VUE_SSR_SETTERS__`,
      (v) => isInSSRComponentSetup = v
    );
  }
  const setCurrentInstance = (instance) => {
    const prev = currentInstance;
    internalSetCurrentInstance(instance);
    instance.scope.on();
    return () => {
      instance.scope.off();
      internalSetCurrentInstance(prev);
    };
  };
  const unsetCurrentInstance = () => {
    currentInstance && currentInstance.scope.off();
    internalSetCurrentInstance(null);
  };
  function isStatefulComponent(instance) {
    return instance.vnode.shapeFlag & 4;
  }
  let isInSSRComponentSetup = false;
  function setupComponent(instance, isSSR = false, optimized = false) {
    isSSR && setInSSRSetupState(isSSR);
    const { props, children } = instance.vnode;
    const isStateful = isStatefulComponent(instance);
    initProps(instance, props, isStateful, isSSR);
    initSlots(instance, children, optimized || isSSR);
    const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
    isSSR && setInSSRSetupState(false);
    return setupResult;
  }
  function setupStatefulComponent(instance, isSSR) {
    const Component = instance.type;
    instance.accessCache = Object.create(null);
    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
    const { setup } = Component;
    if (setup) {
      pauseTracking();
      const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
      const reset = setCurrentInstance(instance);
      const setupResult = callWithErrorHandling(
        setup,
        instance,
        0,
        [
          instance.props,
          setupContext
        ]
      );
      const isAsyncSetup = isPromise(setupResult);
      resetTracking();
      reset();
      if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {
        markAsyncBoundary(instance);
      }
      if (isAsyncSetup) {
        setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
        if (isSSR) {
          return setupResult.then((resolvedResult) => {
            handleSetupResult(instance, resolvedResult);
          }).catch((e) => {
            handleError(e, instance, 0);
          });
        } else {
          instance.asyncDep = setupResult;
        }
      } else {
        handleSetupResult(instance, setupResult);
      }
    } else {
      finishComponentSetup(instance);
    }
  }
  function handleSetupResult(instance, setupResult, isSSR) {
    if (isFunction(setupResult)) {
      if (instance.type.__ssrInlineRender) {
        instance.ssrRender = setupResult;
      } else {
        instance.render = setupResult;
      }
    } else if (isObject(setupResult)) {
      instance.setupState = proxyRefs(setupResult);
    } else ;
    finishComponentSetup(instance);
  }
  function finishComponentSetup(instance, isSSR, skipOptions) {
    const Component = instance.type;
    if (!instance.render) {
      instance.render = Component.render || NOOP;
    }
    {
      const reset = setCurrentInstance(instance);
      pauseTracking();
      try {
        applyOptions(instance);
      } finally {
        resetTracking();
        reset();
      }
    }
  }
  const attrsProxyHandlers = {
    get(target, key) {
      track(target, "get", "");
      return target[key];
    }
  };
  function createSetupContext(instance) {
    const expose = (exposed) => {
      instance.exposed = exposed || {};
    };
    {
      return {
        attrs: new Proxy(instance.attrs, attrsProxyHandlers),
        slots: instance.slots,
        emit: instance.emit,
        expose
      };
    }
  }
  function getComponentPublicInstance(instance) {
    if (instance.exposed) {
      return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
        get(target, key) {
          if (key in target) {
            return target[key];
          } else if (key in publicPropertiesMap) {
            return publicPropertiesMap[key](instance);
          }
        },
        has(target, key) {
          return key in target || key in publicPropertiesMap;
        }
      }));
    } else {
      return instance.proxy;
    }
  }
  const classifyRE = /(?:^|[-_])\w/g;
  const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
  function getComponentName(Component, includeInferred = true) {
    return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
  }
  function formatComponentName(instance, Component, isRoot = false) {
    let name = getComponentName(Component);
    if (!name && Component.__file) {
      const match = Component.__file.match(/([^/\\]+)\.\w+$/);
      if (match) {
        name = match[1];
      }
    }
    if (!name && instance) {
      const inferFromRegistry = (registry) => {
        for (const key in registry) {
          if (registry[key] === Component) {
            return key;
          }
        }
      };
      name = inferFromRegistry(instance.components) || instance.parent && inferFromRegistry(
        instance.parent.type.components
      ) || inferFromRegistry(instance.appContext.components);
    }
    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
  }
  function isClassComponent(value) {
    return isFunction(value) && "__vccOpts" in value;
  }
  const computed = (getterOrOptions, debugOptions) => {
    const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
    return c;
  };
  const version$1 = "3.5.28";
  /**
  * @vue/runtime-dom v3.5.28
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
  let policy = void 0;
  const tt = typeof window !== "undefined" && window.trustedTypes;
  if (tt) {
    try {
      policy = tt.createPolicy("vue", {
        createHTML: (val) => val
      });
    } catch (e) {
    }
  }
  const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
  const svgNS = "http://www.w3.org/2000/svg";
  const mathmlNS = "http://www.w3.org/1998/Math/MathML";
  const doc = typeof document !== "undefined" ? document : null;
  const templateContainer = doc && doc.createElement("template");
  const nodeOps = {
    insert: (child, parent, anchor) => {
      parent.insertBefore(child, anchor || null);
    },
    remove: (child) => {
      const parent = child.parentNode;
      if (parent) {
        parent.removeChild(child);
      }
    },
    createElement: (tag, namespace, is, props) => {
      const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
      if (tag === "select" && props && props.multiple != null) {
        el.setAttribute("multiple", props.multiple);
      }
      return el;
    },
    createText: (text) => doc.createTextNode(text),
    createComment: (text) => doc.createComment(text),
    setText: (node, text) => {
      node.nodeValue = text;
    },
    setElementText: (el, text) => {
      el.textContent = text;
    },
    parentNode: (node) => node.parentNode,
    nextSibling: (node) => node.nextSibling,
    querySelector: (selector) => doc.querySelector(selector),
    setScopeId(el, id) {
      el.setAttribute(id, "");
    },



insertStaticContent(content, parent, anchor, namespace, start, end) {
      const before = anchor ? anchor.previousSibling : parent.lastChild;
      if (start && (start === end || start.nextSibling)) {
        while (true) {
          parent.insertBefore(start.cloneNode(true), anchor);
          if (start === end || !(start = start.nextSibling)) break;
        }
      } else {
        templateContainer.innerHTML = unsafeToTrustedHTML(
          namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content
        );
        const template = templateContainer.content;
        if (namespace === "svg" || namespace === "mathml") {
          const wrapper = template.firstChild;
          while (wrapper.firstChild) {
            template.appendChild(wrapper.firstChild);
          }
          template.removeChild(wrapper);
        }
        parent.insertBefore(template, anchor);
      }
      return [
before ? before.nextSibling : parent.firstChild,
anchor ? anchor.previousSibling : parent.lastChild
      ];
    }
  };
  const vtcKey = Symbol("_vtc");
  function patchClass(el, value, isSVG) {
    const transitionClasses = el[vtcKey];
    if (transitionClasses) {
      value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
    }
    if (value == null) {
      el.removeAttribute("class");
    } else if (isSVG) {
      el.setAttribute("class", value);
    } else {
      el.className = value;
    }
  }
  const vShowOriginalDisplay = Symbol("_vod");
  const vShowHidden = Symbol("_vsh");
  const CSS_VAR_TEXT = Symbol("");
  function useCssVars(getter) {
    const instance = getCurrentInstance();
    if (!instance) {
      return;
    }
    const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
      Array.from(
        document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
      ).forEach((node) => setVarsOnNode(node, vars));
    };
    const setVars = () => {
      const vars = getter(instance.proxy);
      if (instance.ce) {
        setVarsOnNode(instance.ce, vars);
      } else {
        setVarsOnVNode(instance.subTree, vars);
      }
      updateTeleports(vars);
    };
    onBeforeUpdate(() => {
      queuePostFlushCb(setVars);
    });
    onMounted(() => {
      watch(setVars, NOOP, { flush: "post" });
      const ob = new MutationObserver(setVars);
      ob.observe(instance.subTree.el.parentNode, { childList: true });
      onUnmounted(() => ob.disconnect());
    });
  }
  function setVarsOnVNode(vnode, vars) {
    if (vnode.shapeFlag & 128) {
      const suspense = vnode.suspense;
      vnode = suspense.activeBranch;
      if (suspense.pendingBranch && !suspense.isHydrating) {
        suspense.effects.push(() => {
          setVarsOnVNode(suspense.activeBranch, vars);
        });
      }
    }
    while (vnode.component) {
      vnode = vnode.component.subTree;
    }
    if (vnode.shapeFlag & 1 && vnode.el) {
      setVarsOnNode(vnode.el, vars);
    } else if (vnode.type === Fragment) {
      vnode.children.forEach((c) => setVarsOnVNode(c, vars));
    } else if (vnode.type === Static) {
      let { el, anchor } = vnode;
      while (el) {
        setVarsOnNode(el, vars);
        if (el === anchor) break;
        el = el.nextSibling;
      }
    }
  }
  function setVarsOnNode(el, vars) {
    if (el.nodeType === 1) {
      const style = el.style;
      let cssText = "";
      for (const key in vars) {
        const value = normalizeCssVarValue(vars[key]);
        style.setProperty(`--${key}`, value);
        cssText += `--${key}: ${value};`;
      }
      style[CSS_VAR_TEXT] = cssText;
    }
  }
  const displayRE = /(?:^|;)\s*display\s*:/;
  function patchStyle(el, prev, next) {
    const style = el.style;
    const isCssString = isString(next);
    let hasControlledDisplay = false;
    if (next && !isCssString) {
      if (prev) {
        if (!isString(prev)) {
          for (const key in prev) {
            if (next[key] == null) {
              setStyle(style, key, "");
            }
          }
        } else {
          for (const prevStyle of prev.split(";")) {
            const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
            if (next[key] == null) {
              setStyle(style, key, "");
            }
          }
        }
      }
      for (const key in next) {
        if (key === "display") {
          hasControlledDisplay = true;
        }
        setStyle(style, key, next[key]);
      }
    } else {
      if (isCssString) {
        if (prev !== next) {
          const cssVarText = style[CSS_VAR_TEXT];
          if (cssVarText) {
            next += ";" + cssVarText;
          }
          style.cssText = next;
          hasControlledDisplay = displayRE.test(next);
        }
      } else if (prev) {
        el.removeAttribute("style");
      }
    }
    if (vShowOriginalDisplay in el) {
      el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
      if (el[vShowHidden]) {
        style.display = "none";
      }
    }
  }
  const importantRE = /\s*!important$/;
  function setStyle(style, name, val) {
    if (isArray(val)) {
      val.forEach((v) => setStyle(style, name, v));
    } else {
      if (val == null) val = "";
      if (name.startsWith("--")) {
        style.setProperty(name, val);
      } else {
        const prefixed = autoPrefix(style, name);
        if (importantRE.test(val)) {
          style.setProperty(
            hyphenate(prefixed),
            val.replace(importantRE, ""),
            "important"
          );
        } else {
          style[prefixed] = val;
        }
      }
    }
  }
  const prefixes = ["Webkit", "Moz", "ms"];
  const prefixCache = {};
  function autoPrefix(style, rawName) {
    const cached = prefixCache[rawName];
    if (cached) {
      return cached;
    }
    let name = camelize(rawName);
    if (name !== "filter" && name in style) {
      return prefixCache[rawName] = name;
    }
    name = capitalize(name);
    for (let i = 0; i < prefixes.length; i++) {
      const prefixed = prefixes[i] + name;
      if (prefixed in style) {
        return prefixCache[rawName] = prefixed;
      }
    }
    return rawName;
  }
  const xlinkNS = "http://www.w3.org/1999/xlink";
  function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
    if (isSVG && key.startsWith("xlink:")) {
      if (value == null) {
        el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
      } else {
        el.setAttributeNS(xlinkNS, key, value);
      }
    } else {
      if (value == null || isBoolean && !includeBooleanAttr(value)) {
        el.removeAttribute(key);
      } else {
        el.setAttribute(
          key,
          isBoolean ? "" : isSymbol(value) ? String(value) : value
        );
      }
    }
  }
  function patchDOMProp(el, key, value, parentComponent, attrName) {
    if (key === "innerHTML" || key === "textContent") {
      if (value != null) {
        el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
      }
      return;
    }
    const tag = el.tagName;
    if (key === "value" && tag !== "PROGRESS" &&
!tag.includes("-")) {
      const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
      const newValue = value == null ? (

el.type === "checkbox" ? "on" : ""
      ) : String(value);
      if (oldValue !== newValue || !("_value" in el)) {
        el.value = newValue;
      }
      if (value == null) {
        el.removeAttribute(key);
      }
      el._value = value;
      return;
    }
    let needRemove = false;
    if (value === "" || value == null) {
      const type = typeof el[key];
      if (type === "boolean") {
        value = includeBooleanAttr(value);
      } else if (value == null && type === "string") {
        value = "";
        needRemove = true;
      } else if (type === "number") {
        value = 0;
        needRemove = true;
      }
    }
    try {
      el[key] = value;
    } catch (e) {
    }
    needRemove && el.removeAttribute(attrName || key);
  }
  function addEventListener(el, event, handler, options) {
    el.addEventListener(event, handler, options);
  }
  function removeEventListener(el, event, handler, options) {
    el.removeEventListener(event, handler, options);
  }
  const veiKey = Symbol("_vei");
  function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
    const invokers = el[veiKey] || (el[veiKey] = {});
    const existingInvoker = invokers[rawName];
    if (nextValue && existingInvoker) {
      existingInvoker.value = nextValue;
    } else {
      const [name, options] = parseName(rawName);
      if (nextValue) {
        const invoker = invokers[rawName] = createInvoker(
          nextValue,
          instance
        );
        addEventListener(el, name, invoker, options);
      } else if (existingInvoker) {
        removeEventListener(el, name, existingInvoker, options);
        invokers[rawName] = void 0;
      }
    }
  }
  const optionsModifierRE = /(?:Once|Passive|Capture)$/;
  function parseName(name) {
    let options;
    if (optionsModifierRE.test(name)) {
      options = {};
      let m;
      while (m = name.match(optionsModifierRE)) {
        name = name.slice(0, name.length - m[0].length);
        options[m[0].toLowerCase()] = true;
      }
    }
    const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
    return [event, options];
  }
  let cachedNow = 0;
  const p = Promise.resolve();
  const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
  function createInvoker(initialValue, instance) {
    const invoker = (e) => {
      if (!e._vts) {
        e._vts = Date.now();
      } else if (e._vts <= invoker.attached) {
        return;
      }
      callWithAsyncErrorHandling(
        patchStopImmediatePropagation(e, invoker.value),
        instance,
        5,
        [e]
      );
    };
    invoker.value = initialValue;
    invoker.attached = getNow();
    return invoker;
  }
  function patchStopImmediatePropagation(e, value) {
    if (isArray(value)) {
      const originalStop = e.stopImmediatePropagation;
      e.stopImmediatePropagation = () => {
        originalStop.call(e);
        e._stopped = true;
      };
      return value.map(
        (fn) => (e2) => !e2._stopped && fn && fn(e2)
      );
    } else {
      return value;
    }
  }
  const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 &&
key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
  const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
    const isSVG = namespace === "svg";
    if (key === "class") {
      patchClass(el, nextValue, isSVG);
    } else if (key === "style") {
      patchStyle(el, prevValue, nextValue);
    } else if (isOn(key)) {
      if (!isModelListener(key)) {
        patchEvent(el, key, prevValue, nextValue, parentComponent);
      }
    } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
      patchDOMProp(el, key, nextValue);
      if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
        patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
      }
    } else if (
el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))
    ) {
      patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
    } else {
      if (key === "true-value") {
        el._trueValue = nextValue;
      } else if (key === "false-value") {
        el._falseValue = nextValue;
      }
      patchAttr(el, key, nextValue, isSVG);
    }
  };
  function shouldSetAsProp(el, key, value, isSVG) {
    if (isSVG) {
      if (key === "innerHTML" || key === "textContent") {
        return true;
      }
      if (key in el && isNativeOn(key) && isFunction(value)) {
        return true;
      }
      return false;
    }
    if (key === "spellcheck" || key === "draggable" || key === "translate" || key === "autocorrect") {
      return false;
    }
    if (key === "sandbox" && el.tagName === "IFRAME") {
      return false;
    }
    if (key === "form") {
      return false;
    }
    if (key === "list" && el.tagName === "INPUT") {
      return false;
    }
    if (key === "type" && el.tagName === "TEXTAREA") {
      return false;
    }
    if (key === "width" || key === "height") {
      const tag = el.tagName;
      if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
        return false;
      }
    }
    if (isNativeOn(key) && isString(value)) {
      return false;
    }
    return key in el;
  }
  const REMOVAL = {};
function defineCustomElement(options, extraOptions, _createApp) {
    let Comp = defineComponent(options, extraOptions);
    if (isPlainObject(Comp)) Comp = extend({}, Comp, extraOptions);
    class VueCustomElement extends VueElement {
      constructor(initialProps) {
        super(Comp, initialProps, _createApp);
      }
    }
    VueCustomElement.def = Comp;
    return VueCustomElement;
  }
  const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
  };
  class VueElement extends BaseClass {
    constructor(_def, _props = {}, _createApp = createApp) {
      super();
      this._def = _def;
      this._props = _props;
      this._createApp = _createApp;
      this._isVueCE = true;
      this._instance = null;
      this._app = null;
      this._nonce = this._def.nonce;
      this._connected = false;
      this._resolved = false;
      this._patching = false;
      this._dirty = false;
      this._numberProps = null;
      this._styleChildren = new WeakSet();
      this._ob = null;
      if (this.shadowRoot && _createApp !== createApp) {
        this._root = this.shadowRoot;
      } else {
        if (_def.shadowRoot !== false) {
          this.attachShadow(
            extend({}, _def.shadowRootOptions, {
              mode: "open"
            })
          );
          this._root = this.shadowRoot;
        } else {
          this._root = this;
        }
      }
    }
    connectedCallback() {
      if (!this.isConnected) return;
      if (!this.shadowRoot && !this._resolved) {
        this._parseSlots();
      }
      this._connected = true;
      let parent = this;
      while (parent = parent && (parent.parentNode || parent.host)) {
        if (parent instanceof VueElement) {
          this._parent = parent;
          break;
        }
      }
      if (!this._instance) {
        if (this._resolved) {
          this._mount(this._def);
        } else {
          if (parent && parent._pendingResolve) {
            this._pendingResolve = parent._pendingResolve.then(() => {
              this._pendingResolve = void 0;
              this._resolveDef();
            });
          } else {
            this._resolveDef();
          }
        }
      }
    }
    _setParent(parent = this._parent) {
      if (parent) {
        this._instance.parent = parent._instance;
        this._inheritParentContext(parent);
      }
    }
    _inheritParentContext(parent = this._parent) {
      if (parent && this._app) {
        Object.setPrototypeOf(
          this._app._context.provides,
          parent._instance.provides
        );
      }
    }
    disconnectedCallback() {
      this._connected = false;
      nextTick(() => {
        if (!this._connected) {
          if (this._ob) {
            this._ob.disconnect();
            this._ob = null;
          }
          this._app && this._app.unmount();
          if (this._instance) this._instance.ce = void 0;
          this._app = this._instance = null;
          if (this._teleportTargets) {
            this._teleportTargets.clear();
            this._teleportTargets = void 0;
          }
        }
      });
    }
    _processMutations(mutations) {
      for (const m of mutations) {
        this._setAttr(m.attributeName);
      }
    }
_resolveDef() {
      if (this._pendingResolve) {
        return;
      }
      for (let i = 0; i < this.attributes.length; i++) {
        this._setAttr(this.attributes[i].name);
      }
      this._ob = new MutationObserver(this._processMutations.bind(this));
      this._ob.observe(this, { attributes: true });
      const resolve = (def2, isAsync = false) => {
        this._resolved = true;
        this._pendingResolve = void 0;
        const { props, styles } = def2;
        let numberProps;
        if (props && !isArray(props)) {
          for (const key in props) {
            const opt = props[key];
            if (opt === Number || opt && opt.type === Number) {
              if (key in this._props) {
                this._props[key] = toNumber(this._props[key]);
              }
              (numberProps || (numberProps = Object.create(null)))[camelize(key)] = true;
            }
          }
        }
        this._numberProps = numberProps;
        this._resolveProps(def2);
        if (this.shadowRoot) {
          this._applyStyles(styles);
        }
        this._mount(def2);
      };
      const asyncDef = this._def.__asyncLoader;
      if (asyncDef) {
        this._pendingResolve = asyncDef().then((def2) => {
          def2.configureApp = this._def.configureApp;
          resolve(this._def = def2, true);
        });
      } else {
        resolve(this._def);
      }
    }
    _mount(def2) {
      this._app = this._createApp(def2);
      this._inheritParentContext();
      if (def2.configureApp) {
        def2.configureApp(this._app);
      }
      this._app._ceVNode = this._createVNode();
      this._app.mount(this._root);
      const exposed = this._instance && this._instance.exposed;
      if (!exposed) return;
      for (const key in exposed) {
        if (!hasOwn(this, key)) {
          Object.defineProperty(this, key, {
get: () => unref(exposed[key])
          });
        }
      }
    }
    _resolveProps(def2) {
      const { props } = def2;
      const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
      for (const key of Object.keys(this)) {
        if (key[0] !== "_" && declaredPropKeys.includes(key)) {
          this._setProp(key, this[key]);
        }
      }
      for (const key of declaredPropKeys.map(camelize)) {
        Object.defineProperty(this, key, {
          get() {
            return this._getProp(key);
          },
          set(val) {
            this._setProp(key, val, true, !this._patching);
          }
        });
      }
    }
    _setAttr(key) {
      if (key.startsWith("data-v-")) return;
      const has = this.hasAttribute(key);
      let value = has ? this.getAttribute(key) : REMOVAL;
      const camelKey = camelize(key);
      if (has && this._numberProps && this._numberProps[camelKey]) {
        value = toNumber(value);
      }
      this._setProp(camelKey, value, false, true);
    }
_getProp(key) {
      return this._props[key];
    }
_setProp(key, val, shouldReflect = true, shouldUpdate = false) {
      if (val !== this._props[key]) {
        this._dirty = true;
        if (val === REMOVAL) {
          delete this._props[key];
        } else {
          this._props[key] = val;
          if (key === "key" && this._app) {
            this._app._ceVNode.key = val;
          }
        }
        if (shouldUpdate && this._instance) {
          this._update();
        }
        if (shouldReflect) {
          const ob = this._ob;
          if (ob) {
            this._processMutations(ob.takeRecords());
            ob.disconnect();
          }
          if (val === true) {
            this.setAttribute(hyphenate(key), "");
          } else if (typeof val === "string" || typeof val === "number") {
            this.setAttribute(hyphenate(key), val + "");
          } else if (!val) {
            this.removeAttribute(hyphenate(key));
          }
          ob && ob.observe(this, { attributes: true });
        }
      }
    }
    _update() {
      const vnode = this._createVNode();
      if (this._app) vnode.appContext = this._app._context;
      render(vnode, this._root);
    }
    _createVNode() {
      const baseProps = {};
      if (!this.shadowRoot) {
        baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
      }
      const vnode = createVNode(this._def, extend(baseProps, this._props));
      if (!this._instance) {
        vnode.ce = (instance) => {
          this._instance = instance;
          instance.ce = this;
          instance.isCE = true;
          const dispatch = (event, args) => {
            this.dispatchEvent(
              new CustomEvent(
                event,
                isPlainObject(args[0]) ? extend({ detail: args }, args[0]) : { detail: args }
              )
            );
          };
          instance.emit = (event, ...args) => {
            dispatch(event, args);
            if (hyphenate(event) !== event) {
              dispatch(hyphenate(event), args);
            }
          };
          this._setParent();
        };
      }
      return vnode;
    }
    _applyStyles(styles, owner) {
      if (!styles) return;
      if (owner) {
        if (owner === this._def || this._styleChildren.has(owner)) {
          return;
        }
        this._styleChildren.add(owner);
      }
      const nonce = this._nonce;
      for (let i = styles.length - 1; i >= 0; i--) {
        const s = document.createElement("style");
        if (nonce) s.setAttribute("nonce", nonce);
        s.textContent = styles[i];
        this.shadowRoot.prepend(s);
      }
    }
_parseSlots() {
      const slots = this._slots = {};
      let n;
      while (n = this.firstChild) {
        const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
        (slots[slotName] || (slots[slotName] = [])).push(n);
        this.removeChild(n);
      }
    }
_renderSlots() {
      const outlets = this._getSlots();
      const scopeId = this._instance.type.__scopeId;
      for (let i = 0; i < outlets.length; i++) {
        const o = outlets[i];
        const slotName = o.getAttribute("name") || "default";
        const content = this._slots[slotName];
        const parent = o.parentNode;
        if (content) {
          for (const n of content) {
            if (scopeId && n.nodeType === 1) {
              const id = scopeId + "-s";
              const walker = document.createTreeWalker(n, 1);
              n.setAttribute(id, "");
              let child;
              while (child = walker.nextNode()) {
                child.setAttribute(id, "");
              }
            }
            parent.insertBefore(n, o);
          }
        } else {
          while (o.firstChild) parent.insertBefore(o.firstChild, o);
        }
        parent.removeChild(o);
      }
    }
_getSlots() {
      const roots = [this];
      if (this._teleportTargets) {
        roots.push(...this._teleportTargets);
      }
      const slots = new Set();
      for (const root of roots) {
        const found = root.querySelectorAll("slot");
        for (let i = 0; i < found.length; i++) {
          slots.add(found[i]);
        }
      }
      return Array.from(slots);
    }
_injectChildStyle(comp) {
      this._applyStyles(comp.styles, comp);
    }
_beginPatch() {
      this._patching = true;
      this._dirty = false;
    }
_endPatch() {
      this._patching = false;
      if (this._dirty && this._instance) {
        this._update();
      }
    }
_hasShadowRoot() {
      return this._def.shadowRoot !== false;
    }
_removeChildStyle(comp) {
    }
  }
  const getModelAssigner = (vnode) => {
    const fn = vnode.props["onUpdate:modelValue"] || false;
    return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
  };
  function onCompositionStart(e) {
    e.target.composing = true;
  }
  function onCompositionEnd(e) {
    const target = e.target;
    if (target.composing) {
      target.composing = false;
      target.dispatchEvent(new Event("input"));
    }
  }
  const assignKey = Symbol("_assign");
  function castValue(value, trim, number) {
    if (trim) value = value.trim();
    if (number) value = looseToNumber(value);
    return value;
  }
  const vModelText = {
    created(el, { modifiers: { lazy, trim, number } }, vnode) {
      el[assignKey] = getModelAssigner(vnode);
      const castToNumber = number || vnode.props && vnode.props.type === "number";
      addEventListener(el, lazy ? "change" : "input", (e) => {
        if (e.target.composing) return;
        el[assignKey](castValue(el.value, trim, castToNumber));
      });
      if (trim || castToNumber) {
        addEventListener(el, "change", () => {
          el.value = castValue(el.value, trim, castToNumber);
        });
      }
      if (!lazy) {
        addEventListener(el, "compositionstart", onCompositionStart);
        addEventListener(el, "compositionend", onCompositionEnd);
        addEventListener(el, "change", onCompositionEnd);
      }
    },
mounted(el, { value }) {
      el.value = value == null ? "" : value;
    },
    beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
      el[assignKey] = getModelAssigner(vnode);
      if (el.composing) return;
      const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
      const newValue = value == null ? "" : value;
      if (elValue === newValue) {
        return;
      }
      if (document.activeElement === el && el.type !== "range") {
        if (lazy && value === oldValue) {
          return;
        }
        if (trim && el.value.trim() === newValue) {
          return;
        }
      }
      el.value = newValue;
    }
  };
  const vModelCheckbox = {
deep: true,
    created(el, _, vnode) {
      el[assignKey] = getModelAssigner(vnode);
      addEventListener(el, "change", () => {
        const modelValue = el._modelValue;
        const elementValue = getValue(el);
        const checked = el.checked;
        const assign = el[assignKey];
        if (isArray(modelValue)) {
          const index = looseIndexOf(modelValue, elementValue);
          const found = index !== -1;
          if (checked && !found) {
            assign(modelValue.concat(elementValue));
          } else if (!checked && found) {
            const filtered = [...modelValue];
            filtered.splice(index, 1);
            assign(filtered);
          }
        } else if (isSet(modelValue)) {
          const cloned = new Set(modelValue);
          if (checked) {
            cloned.add(elementValue);
          } else {
            cloned.delete(elementValue);
          }
          assign(cloned);
        } else {
          assign(getCheckboxValue(el, checked));
        }
      });
    },
mounted: setChecked,
    beforeUpdate(el, binding, vnode) {
      el[assignKey] = getModelAssigner(vnode);
      setChecked(el, binding, vnode);
    }
  };
  function setChecked(el, { value, oldValue }, vnode) {
    el._modelValue = value;
    let checked;
    if (isArray(value)) {
      checked = looseIndexOf(value, vnode.props.value) > -1;
    } else if (isSet(value)) {
      checked = value.has(vnode.props.value);
    } else {
      if (value === oldValue) return;
      checked = looseEqual(value, getCheckboxValue(el, true));
    }
    if (el.checked !== checked) {
      el.checked = checked;
    }
  }
  function getValue(el) {
    return "_value" in el ? el._value : el.value;
  }
  function getCheckboxValue(el, checked) {
    const key = checked ? "_trueValue" : "_falseValue";
    return key in el ? el[key] : checked;
  }
  const rendererOptions = extend({ patchProp }, nodeOps);
  let renderer;
  function ensureRenderer() {
    return renderer || (renderer = createRenderer(rendererOptions));
  }
  const render = ((...args) => {
    ensureRenderer().render(...args);
  });
  const createApp = ((...args) => {
    const app = ensureRenderer().createApp(...args);
    const { mount } = app;
    app.mount = (containerOrSelector) => {
      const container = normalizeContainer(containerOrSelector);
      if (!container) return;
      const component = app._component;
      if (!isFunction(component) && !component.render && !component.template) {
        component.template = container.innerHTML;
      }
      if (container.nodeType === 1) {
        container.textContent = "";
      }
      const proxy = mount(container, false, resolveRootNamespace(container));
      if (container instanceof Element) {
        container.removeAttribute("v-cloak");
        container.setAttribute("data-v-app", "");
      }
      return proxy;
    };
    return app;
  });
  function resolveRootNamespace(container) {
    if (container instanceof SVGElement) {
      return "svg";
    }
    if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
      return "mathml";
    }
  }
  function normalizeContainer(container) {
    if (isString(container)) {
      const res = document.querySelector(container);
      return res;
    }
    return container;
  }
  class CacheManager {
    constructor(prefix = "us_cache_") {
      this.prefix = prefix;
      this.stats = {
        hits: 0,
        misses: 0,
        sets: 0
      };
    }
    get(key) {
      const fullKey = this.prefix + key;
      const data = GM_getValue(fullKey);
      if (data !== void 0 && data !== null) {
        try {
          const parsed = typeof data === "string" ? JSON.parse(data) : data;
          if (Date.now() < parsed.expire) {
            this.stats.hits++;
            return parsed.value;
          } else {
            GM_deleteValue(fullKey);
            this.stats.misses++;
          }
        } catch (e) {
          GM_deleteValue(fullKey);
          this.stats.misses++;
        }
      } else {
        this.stats.misses++;
      }
      return void 0;
    }
    set(key, value, ttlMinutes = 1440) {
      const fullKey = this.prefix + key;
      const data = {
        value,
        expire: Date.now() + ttlMinutes * 60 * 1e3,
        createdAt: Date.now()
      };
      GM_setValue(fullKey, JSON.stringify(data));
      this.stats.sets++;
    }
    has(key) {
      return this.get(key) !== void 0;
    }
    delete(key) {
      GM_deleteValue(this.prefix + key);
    }
    clear(filters = []) {
      const keys = GM_listValues();
      let count = 0;
      keys.forEach((key) => {
        if (key.startsWith(this.prefix)) {
          let shouldDelete = false;
          if (filters.length === 0) {
            shouldDelete = true;
          } else {
            for (const filter of filters) {
              if (key.indexOf(`_${filter}`) !== -1) {
                shouldDelete = true;
                break;
              }
            }
          }
          if (shouldDelete) {
            GM_deleteValue(key);
            count++;
          }
        }
      });
      return count;
    }
    getStats() {
      const hitRate = this.stats.hits + this.stats.misses > 0 ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(2) : "0.00";
      return {
        ...this.stats,
        hitRate: `${hitRate}%`
      };
    }
    resetStats() {
      this.stats = {
        hits: 0,
        misses: 0,
        sets: 0
      };
    }
    listKeys() {
      const keys = GM_listValues();
      return keys.filter((key) => key.startsWith(this.prefix)).map((key) => key.replace(this.prefix, ""));
    }
    cleanExpired() {
      const keys = this.listKeys();
      let count = 0;
      keys.forEach((key) => {
        const fullKey = this.prefix + key;
        const data = GM_getValue(fullKey);
        if (data !== void 0 && data !== null) {
          try {
            const parsed = typeof data === "string" ? JSON.parse(data) : data;
            if (Date.now() >= parsed.expire) {
              GM_deleteValue(fullKey);
              count++;
            }
          } catch (e) {
            GM_deleteValue(fullKey);
            count++;
          }
        }
      });
      return count;
    }
  }
  const cache = new CacheManager();
  class RequestQueue {
    constructor(maxConcurrent = 6) {
      this.maxConcurrent = maxConcurrent;
      this.queue = [];
      this.running = 0;
      this.pendingRequests = new Map();
    }
    async enqueue(requestFn, options = {}) {
      const { key, priority = 0 } = options;
      if (key && this.pendingRequests.has(key)) {
        return this.pendingRequests.get(key);
      }
      const promise = new Promise((resolve, reject) => {
        this.queue.push({
          requestFn,
          resolve,
          reject,
          priority,
          key
        });
      });
      if (key) {
        this.pendingRequests.set(key, promise);
      }
      this.queue.sort((a, b) => b.priority - a.priority);
      this.processQueue();
      return promise;
    }
    getStatus() {
      return {
        running: this.running,
        queued: this.queue.length,
        pending: this.pendingRequests.size,
        maxConcurrent: this.maxConcurrent
      };
    }
    clear() {
      this.queue = [];
      this.pendingRequests.clear();
    }
    async processQueue() {
      while (this.running < this.maxConcurrent && this.queue.length > 0) {
        const task = this.queue.shift();
        if (task) {
          this.running++;
          this.executeTask(task);
        }
      }
    }
    async executeTask(task) {
      const { requestFn, resolve, reject, key } = task;
      try {
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      } finally {
        this.running--;
        if (key) {
          this.pendingRequests.delete(key);
        }
        this.processQueue();
      }
    }
  }
  const requestQueue = new RequestQueue(6);
  class ApiClient {
    constructor(name) {
      this.name = name;
      this.cache = cache;
      this.queue = requestQueue;
    }
    async request(options) {
      const {
        requestFn,
        cacheKey,
        cacheTTL = 1440,
        useCache = true,
        useQueue = true,
        priority = 0
      } = options;
      if (useCache && cacheKey) {
        const cached = this.cache.get(cacheKey);
        if (cached !== void 0) {
          return {
            data: cached,
            meta: {
              cached: true,
              source: this.name,
              timestamp: ( new Date()).toISOString()
            }
          };
        }
      }
      try {
        let result;
        if (useQueue) {
          result = await this.queue.enqueue(requestFn, {
            key: cacheKey,
            priority
          });
        } else {
          result = await requestFn();
        }
        const processedData = await this.handleResponse(result);
        if (useCache && cacheKey) {
          const ttl = this.determineTTL(processedData, cacheTTL);
          this.cache.set(cacheKey, processedData, ttl);
        }
        return {
          data: processedData,
          meta: {
            cached: false,
            source: this.name,
            timestamp: ( new Date()).toISOString()
          }
        };
      } catch (error) {
        if (useCache && cacheKey) {
          this.cache.set(cacheKey, null, 5);
        }
        return {
          data: null,
          meta: {
            error: error.message || String(error),
            source: this.name,
            timestamp: ( new Date()).toISOString()
          }
        };
      }
    }
    async handleResponse(response) {
      return response;
    }
    determineTTL(data, defaultTTL) {
      if (data && (Array.isArray(data) ? data.length > 0 : Object.keys(data).length > 0)) {
        return defaultTTL;
      }
      return Math.min(defaultTTL, 60);
    }
    buildCacheKey(...parts) {
      return `${this.name.toLowerCase()}_${parts.filter(Boolean).join("_")}`;
    }
  }
  const version = "1.6.0";
  const pkg = {
    version
  };
  var define_process_env_default = {};
  class ConfigManager {
    constructor() {
      this.listeners = [];
      this.config = reactive({
        tmdb: {
          apiKey: GM_getValue("tmdb_api_key", ""),
          baseUrl: "https://api.themoviedb.org/3",
          language: "zh-CN",
          cacheTTL: 1440
        },
        emby: {
          server: GM_getValue("emby_server", ""),
          apiKey: GM_getValue("emby_api_key", ""),
          cacheTTL: 60
        },
        bangumi: {
          apiKey: GM_getValue("bangumi_token", ""),
          baseUrl: "https://api.bgm.tv",
          cacheTTL: 1440
        },
        imdb: {
          baseUrl: "https://www.imdb.com",
          cacheTTL: 10080
        },
        nullbr: {
          baseUrl: "https://api.nullbr.eu.org",
          appId: GM_getValue("nullbr_app_id", define_process_env_default.NULLBR_APP_ID || ""),
          apiKey: GM_getValue("nullbr_api_key", define_process_env_default.NULLBR_API_KEY || ""),
          cacheTTL: 10080,
          userAgent: `tampermonkey_emby_enhance/${pkg.version}`,
          enable115: GM_getValue("nullbr_enable_115", true),
          enableMagnet: GM_getValue("nullbr_enable_magnet", false)
        },
        state: {}
      });
    }
    update(service, updates) {
      const config = this.config[service];
      Object.assign(config, updates);
      if (service === "tmdb" && updates.apiKey !== void 0) {
        GM_setValue("tmdb_api_key", updates.apiKey);
      } else if (service === "emby") {
        if (updates.server !== void 0) GM_setValue("emby_server", updates.server);
        if (updates.apiKey !== void 0) GM_setValue("emby_api_key", updates.apiKey);
      } else if (service === "bangumi" && updates.apiKey !== void 0) {
        GM_setValue("bangumi_token", updates.apiKey);
      } else if (service === "nullbr") {
        if (updates.appId !== void 0) GM_setValue("nullbr_app_id", updates.appId);
        if (updates.apiKey !== void 0) GM_setValue("nullbr_api_key", updates.apiKey);
        if (updates.enable115 !== void 0) GM_setValue("nullbr_enable_115", updates.enable115);
        if (updates.enableMagnet !== void 0) GM_setValue("nullbr_enable_magnet", updates.enableMagnet);
      }
      this.notifyListeners(service, config);
    }
    validate(service) {
      const config = this.config[service];
      switch (service) {
        case "tmdb":
          return !!config.apiKey && config.apiKey.length > 0;
        case "emby":
          return !!config.server && !!config.apiKey;
        case "bangumi":
          return !!config.apiKey && config.apiKey.length > 0;
        case "imdb":
          return true;
        case "nullbr":
          return !!config.appId && !!config.apiKey;
        default:
          return false;
      }
    }
    addListener(listener) {
      this.listeners.push(listener);
    }
    removeListener(listener) {
      const index = this.listeners.indexOf(listener);
      if (index > -1) {
        this.listeners.splice(index, 1);
      }
    }
    getSummary() {
      return {
        tmdb: {
          hasApiKey: !!this.config.tmdb.apiKey,
          language: this.config.tmdb.language
        },
        emby: {
          hasServer: !!this.config.emby.server,
          hasApiKey: !!this.config.emby.apiKey,
          server: this.config.emby.server || "(未配置)"
        },
        bangumi: {
          hasToken: !!this.config.bangumi.apiKey
        },
        nullbr: {
          enable115: !!this.config.nullbr.enable115,
          enableMagnet: !!this.config.nullbr.enableMagnet
        }
      };
    }
    notifyListeners(service, config) {
      this.listeners.forEach((listener) => {
        try {
          listener(service, config);
        } catch (error) {
          console.error("Config listener error:", error);
        }
      });
    }
  }
  const configManager = new ConfigManager();
  const CONFIG = configManager.config;
  const configService = configManager;
  class TmdbService extends ApiClient {
    constructor() {
      super("TMDB");
    }
    async searchMovie(query, year = "") {
      if (!CONFIG.tmdb.apiKey) {
        return {
          data: [],
          meta: { error: "API Key not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const cacheKey = this.buildCacheKey("search", "movie", query, year);
      const config = CONFIG.tmdb;
      return this.request({
        requestFn: async () => {
          const params = new URLSearchParams({
            api_key: config.apiKey,
            query,
            language: config.language || "zh-CN",
            include_adult: "false"
          });
          if (year) {
            params.append("primary_release_year", year);
          }
          const url = `${config.baseUrl}/search/movie?${params.toString()}`;
          const response = await GM.xmlHttpRequest({ url, responseType: "json" });
          const data = response.response;
          let results = [];
          if (data.results && data.results.length > 0) {
            results = data.results;
          }
          return results;
        },
        cacheKey,
        cacheTTL: 1440,
        useCache: true,
        useQueue: true,
        priority: 5
      });
    }
    async searchTv(query, year = "") {
      if (!CONFIG.tmdb.apiKey) {
        return {
          data: [],
          meta: { error: "API Key not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const cacheKey = this.buildCacheKey("search", "tv", query, year);
      const config = CONFIG.tmdb;
      return this.request({
        requestFn: async () => {
          const params = new URLSearchParams({
            api_key: config.apiKey,
            query,
            language: config.language || "zh-CN",
            include_adult: "false"
          });
          if (year) {
            params.append("first_air_date_year", year);
          }
          const url = `${config.baseUrl}/search/tv?${params.toString()}`;
          const response = await GM.xmlHttpRequest({ url, responseType: "json" });
          const data = response.response;
          return data.results || [];
        },
        cacheKey,
        cacheTTL: 1440,
        useCache: true,
        useQueue: true,
        priority: 5
      });
    }
    async getMovieDetails(id) {
      return this.getDetailsBase(id, "movie");
    }
    async getTvDetails(id) {
      return this.getDetailsBase(id, "tv");
    }
    determineTTL(data, defaultTTL) {
      if (Array.isArray(data)) {
        return data.length > 0 ? defaultTTL : 60;
      }
      return defaultTTL;
    }
    async getDetailsBase(id, type) {
      if (!CONFIG.tmdb.apiKey) {
        return {
          data: null,
          meta: { error: "API Key not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const cacheKey = this.buildCacheKey("details", type, id);
      const config = CONFIG.tmdb;
      return this.request({
        requestFn: async () => {
          const params = new URLSearchParams({
            api_key: config.apiKey,
            language: config.language || "zh-CN"
          });
          const url = `${config.baseUrl}/${type}/${id}?${params.toString()}`;
          const response = await GM.xmlHttpRequest({ url, responseType: "json" });
          return response.response;
        },
        cacheKey,
        cacheTTL: 2880,
        useCache: true,
        useQueue: true
      });
    }
  }
  const tmdbService = new TmdbService();
  class EmbyService extends ApiClient {
    constructor() {
      super("Emby");
    }
    async checkExistence(tmdbId) {
      const { server, apiKey } = CONFIG.emby;
      if (!server || !apiKey) {
        return {
          data: void 0,
          meta: { error: "Emby not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const queryId = `tmdb.${tmdbId}`;
      const params = new URLSearchParams({
        Recursive: "true",
        AnyProviderIdEquals: queryId,
        Fields: "ProviderIds,MediaSources,MediaStreams,ProductionYear,ChildCount,RecursiveItemCount,Path,IndexNumber",
        api_key: apiKey
      });
      const url = `${server}/emby/Items?${params.toString()}`;
      const cacheKey = this.buildCacheKey("check", tmdbId);
      const result = await this.request({
        requestFn: async () => {
          const data = (await GM.xmlHttpRequest({ url, responseType: "json" })).response;
          if (data.Items && data.Items.length > 0) {
            const item = data.Items[0];
            await this.enrichSeriesInfo(item, server, apiKey);
            return item;
          }
          return void 0;
        },
        cacheKey,
        cacheTTL: 1440,
        useCache: true,
        useQueue: true,
        priority: 3
      });
      if (result.meta) {
        result.meta.url = url;
      }
      return result;
    }
async searchByName(name) {
      const { server, apiKey } = CONFIG.emby;
      if (!server || !apiKey) {
        return {
          data: [],
          meta: { error: "Emby not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const params = new URLSearchParams({
        Recursive: "true",
        SearchTerm: name,
        IncludeItemTypes: "Movie,Series",
        Fields: "ProviderIds,MediaSources,MediaStreams,ProductionYear,ChildCount,RecursiveItemCount,Path,IndexNumber",
        api_key: apiKey
      });
      const url = `${server}/emby/Items?${params.toString()}`;
      const cacheKey = this.buildCacheKey("search", name);
      return this.request({
        requestFn: async () => {
          const data = (await GM.xmlHttpRequest({ url, responseType: "json" })).response;
          return data.Items || [];
        },
        cacheKey,
        cacheTTL: 60,
        useCache: true,
        useQueue: true,
        priority: 3
      });
    }
async getByDoubanId(doubanId) {
      const { server, apiKey } = CONFIG.emby;
      if (!server || !apiKey) {
        return {
          data: void 0,
          meta: { error: "Emby not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const queryId = `douban.${doubanId}`;
      const params = new URLSearchParams({
        Recursive: "true",
        AnyProviderIdEquals: queryId,
        Fields: "ProviderIds,MediaSources,MediaStreams,ProductionYear,ChildCount,RecursiveItemCount,Path,IndexNumber",
        api_key: apiKey
      });
      const url = `${server}/emby/Items?${params.toString()}`;
      const cacheKey = this.buildCacheKey("douban", doubanId);
      return this.request({
        requestFn: async () => {
          const data = (await GM.xmlHttpRequest({ url, responseType: "json" })).response;
          if (data.Items && data.Items.length > 0) {
            const item = data.Items[0];
            await this.enrichSeriesInfo(item, server, apiKey);
            return item;
          }
          return void 0;
        },
        cacheKey,
        cacheTTL: 1440,
        useCache: true,
        useQueue: true,
        priority: 3
      });
    }
async enrichSeriesInfo(item, server, apiKey) {
      if (item.Type !== "Series") return;
      try {
        const seasonParams = new URLSearchParams({
          ParentId: item.Id,
          IncludeItemTypes: "Season",
          Fields: "ChildCount,RecursiveItemCount,Path,IndexNumber",
          api_key: apiKey
        });
        const seasonUrl = `${server}/emby/Items?${seasonParams.toString()}`;
        const seasonData = (await GM.xmlHttpRequest({ url: seasonUrl, responseType: "json" })).response;
        if (seasonData.Items && seasonData.Items.length > 0) {
          item.Seasons = seasonData.Items;
          const totalEpisodes = item.Seasons.reduce((acc, s) => acc + (s.RecursiveItemCount || 0), 0);
          if (totalEpisodes === 0) {
            const episodeParams = new URLSearchParams({
              ParentId: item.Id,
              IncludeItemTypes: "Episode",
              Recursive: "true",
              Fields: "ParentIndexNumber",
              api_key: apiKey
            });
            const allEpUrl = `${server}/emby/Items?${episodeParams.toString()}`;
            const allEpData = (await GM.xmlHttpRequest({ url: allEpUrl, responseType: "json" })).response;
            if (allEpData.Items && allEpData.Items.length > 0) {
              const seasonMap = {};
              allEpData.Items.forEach((ep) => {
                const sNum = ep.ParentIndexNumber || 1;
                seasonMap[sNum] = (seasonMap[sNum] || 0) + 1;
              });
              if (item.Seasons) {
                item.Seasons.forEach((s) => {
                  let ids = s.IndexNumber;
                  if (ids === void 0) {
                    const m = s.Name.match(/(\d+)/);
                    if (m) ids = parseInt(m[1], 10);
                  }
                  if (ids !== void 0 && seasonMap[ids]) {
                    s.RecursiveItemCount = seasonMap[ids];
                    s.ChildCount = seasonMap[ids];
                  }
                });
              }
            }
          }
        }
      } catch (e) {
        console.log(`[Emby] Failed to fetch seasons/episodes: ${e}`);
      }
    }
    getWebUrl(item) {
      if (!item) return "";
      const { server } = CONFIG.emby;
      return `${server}/web/index.html#!/item?id=${item.Id}&serverId=${item.ServerId || ""}`;
    }
    determineTTL(data, defaultTTL) {
      return data ? defaultTTL : 60;
    }
  }
  const embyService = new EmbyService();
  class MediaService {
    async checkMedia(title, year, mediaType, searchQueries = [title], doubanId = "") {
      try {
        if (doubanId) {
          const doubanResult = await embyService.getByDoubanId(doubanId);
          if (doubanResult.data) {
            const item = doubanResult.data;
            return {
              tmdbId: null,
              embyItem: item,
              status: "found",
              statusMessage: `Found: ${item.Name}`,
              title,
              mediaType,
              searchQueries
            };
          }
        }
        const embySearch = await embyService.searchByName(title);
        const embyItems = embySearch.data || [];
        if (embyItems.length === 1) {
          const item = embyItems[0];
          const { server, apiKey } = this.getEmbyConfig();
          if (server && apiKey) {
            await embyService.enrichSeriesInfo(item, server, apiKey);
          }
          return {
            tmdbId: null,
            embyItem: item,
            status: "found",
            statusMessage: `Found: ${item.Name}`,
            title,
            mediaType,
            searchQueries
          };
        }
        if (embyItems.length > 1) {
          const { server, apiKey } = this.getEmbyConfig();
          if (server && apiKey) {
            await Promise.all(embyItems.map((item) => embyService.enrichSeriesInfo(item, server, apiKey)));
          }
          return {
            tmdbId: null,
            embyItem: embyItems[0],
            embyItems,
            status: "found",
            statusMessage: `Found: ${embyItems[0].Name} (+${embyItems.length - 1} more)`,
            title,
            mediaType,
            searchQueries
          };
        }
        const tmdbResults = await this.searchTmdbForDisplay(title, year, mediaType);
        const tmdbId = tmdbResults.length > 0 ? tmdbResults[0].id : null;
        const tmdbInfo = tmdbId ? { id: tmdbId, mediaType } : void 0;
        return {
          tmdbId,
          embyItem: null,
          status: "not-found",
          statusMessage: "Not in Emby",
          title,
          mediaType,
          searchQueries,
          tmdbInfo,
          tmdbResults
        };
      } catch (error) {
        return {
          tmdbId: null,
          embyItem: null,
          status: "error",
          statusMessage: `Error: ${error.message || error}`,
          title,
          mediaType,
          searchQueries
        };
      }
    }
async getTmdbId(title, year, mediaType) {
      var _a, _b, _c, _d;
      if (mediaType === "tv") {
        const result = await tmdbService.searchTv(title, year);
        if ((_a = result.data) == null ? void 0 : _a.length) return result.data[0].id;
        const retry = await tmdbService.searchTv(title);
        if ((_b = retry.data) == null ? void 0 : _b.length) return retry.data[0].id;
      } else {
        const result = await tmdbService.searchMovie(title, year);
        if ((_c = result.data) == null ? void 0 : _c.length) return result.data[0].id;
        const retry = await tmdbService.searchMovie(title);
        if ((_d = retry.data) == null ? void 0 : _d.length) return retry.data[0].id;
      }
      return null;
    }
async searchTmdbForDisplay(title, year, mediaType) {
      var _a, _b, _c, _d;
      const normalize = (items, type) => {
        return items.map((item) => ({
          id: item.id,
          title: type === "tv" ? item.name || item.original_name : item.title || item.original_title,
          year: type === "tv" ? (item.first_air_date || "").substring(0, 4) : (item.release_date || "").substring(0, 4),
          overview: item.overview || "",
          posterPath: item.poster_path || "",
          mediaType: type
        }));
      };
      if (mediaType === "tv") {
        const result = await tmdbService.searchTv(title, year);
        if ((_a = result.data) == null ? void 0 : _a.length) return normalize(result.data, "tv");
        const retry = await tmdbService.searchTv(title);
        if ((_b = retry.data) == null ? void 0 : _b.length) return normalize(retry.data, "tv");
      } else {
        const result = await tmdbService.searchMovie(title, year);
        if ((_c = result.data) == null ? void 0 : _c.length) return normalize(result.data, "movie");
        const retry = await tmdbService.searchMovie(title);
        if ((_d = retry.data) == null ? void 0 : _d.length) return normalize(retry.data, "movie");
      }
      return [];
    }
    getEmbyConfig() {
      return {
        server: CONFIG.emby.server || "",
        apiKey: CONFIG.emby.apiKey || ""
      };
    }
  }
  const mediaService = new MediaService();
  class UIController {
mountDot(cover, size = "medium", inline) {
      const dot = document.createElement("us-status-dot");
      dot.setAttribute("status", "loading");
      dot.setAttribute("size", size);
      const dotWrapper = document.createElement("div");
      if (inline) {
        dotWrapper.style.display = "inline-block";
      } else {
        dotWrapper.style.position = "absolute";
        dotWrapper.style.zIndex = "99";
        dotWrapper.style.left = "0";
        dotWrapper.style.top = "0";
      }
      const sizeMap = {
        mini: "12px",
        small: "20px",
        medium: "28px",
        large: "36px"
      };
      dotWrapper.style.width = sizeMap[size];
      dotWrapper.style.height = sizeMap[size];
      dotWrapper.appendChild(dot);
      cover.style.position = "relative";
      cover.appendChild(dotWrapper);
      return dot;
    }
updateDot(dotEl, result) {
      dotEl.setAttribute("status", result.status);
      dotEl.setAttribute("title", result.statusMessage);
    }
bindInfoCard(dotEl, result) {
      const handler = (event) => {
        event.preventDefault();
        event.stopPropagation();
        this.showInfoCard(result);
      };
      dotEl.addEventListener("dotClick", handler);
      dotEl.addEventListener("click", handler);
    }
showInfoCard(result) {
      const existing = document.querySelector("us-info-card");
      if (existing) existing.remove();
      const card = document.createElement("us-info-card");
      card.setAttribute("title", result.title);
      card.setAttribute("visible", "true");
      const cardEl = card;
      cardEl.embyItem = result.embyItem;
      cardEl.embyItems = result.embyItems;
      cardEl.searchQueries = result.searchQueries;
      cardEl.tmdbInfo = result.tmdbInfo;
      cardEl.tmdbResults = result.tmdbResults;
      card.addEventListener("close", () => {
        card.remove();
      });
      document.body.appendChild(card);
    }
  }
  const uiController = new UIController();
  function isCustomPageConfig(config) {
    return "handler" in config;
  }
  class AdapterEngine {
    constructor() {
      this.processedElements = new WeakSet();
    }
run(config) {
      if (config.globalStyles) {
        GM.addStyle(config.globalStyles);
      }
      const url = location.href;
      for (const page of config.pages) {
        if (!page.match(url)) continue;
        if (isCustomPageConfig(page)) {
          page.handler();
          return;
        }
        this.processPage(page);
        return;
      }
    }
processPage(page) {
      const scan = () => this.scanItems(page);
      scan();
      if (page.observe) {
        const observer = new MutationObserver(() => scan());
        observer.observe(document.body, {
          childList: true,
          subtree: true
        });
      }
    }
scanItems(page) {
      const items = page.getItems();
      items.forEach((item) => {
        if (this.processedElements.has(item)) return;
        this.processedElements.add(item);
        this.processItem(item, page);
      });
    }
async processItem(item, page) {
      const { itemConfig, dotSize } = page;
      let title = itemConfig.getTitle(item);
      let mediaType = itemConfig.getType(item);
      let year = itemConfig.getYear(item);
      if (hasSeasonInfo(title)) {
        mediaType = "tv";
        year = "";
        title = removeSeasonInfo(title);
      }
      const cover = itemConfig.getCover(item);
      if (!cover) return;
      if (page.beforeMount) {
        page.beforeMount(cover);
      }
      const dot = uiController.mountDot(cover, dotSize || "medium");
      const doubanId = itemConfig.getDoubanId ? itemConfig.getDoubanId(item) : "";
      const searchQueries = [title];
      const fullTitle = itemConfig.getTitle(item);
      if (fullTitle !== title) searchQueries.unshift(fullTitle);
      const result = await mediaService.checkMedia(title, year, mediaType, searchQueries, doubanId);
      uiController.updateDot(dot, result);
      uiController.bindInfoCard(dot, result);
    }
  }
  const SEASON_REGEX = /(?:[\s:：(（\[【]|^)(?:第[0-9一二三四五六七八九十]+季|Season\s*\d+|S\d+).*/i;
  function removeSeasonInfo(title) {
    return title.replace(SEASON_REGEX, "").trim();
  }
  function hasSeasonInfo(title) {
    return SEASON_REGEX.test(title);
  }
  const adapterEngine = new AdapterEngine();
  const doubanConfig = {
    name: "Douban",
    match: (url) => url.includes("movie.douban.com") || url.includes("m.douban.com"),
    pages: [
{
        name: "subject",
        match: () => location.pathname.startsWith("/subject/"),
        getItems: () => {
          const container = document.querySelector("#mainpic");
          return container ? [container] : [];
        },
        itemConfig: {
          getTitle: () => {
            var _a;
            const titleEl = document.querySelector("#content h1 span");
            return ((_a = titleEl == null ? void 0 : titleEl.textContent) == null ? void 0 : _a.trim()) || "";
          },
          getYear: () => {
            var _a;
            const yearEl = document.querySelector("#content h1 .year");
            return ((_a = yearEl == null ? void 0 : yearEl.textContent) == null ? void 0 : _a.replace(/[()]/g, "").trim()) || "";
          },
          getType: () => {
            var _a;
            const titleEl = document.querySelector("#content h1 span");
            const title = ((_a = titleEl == null ? void 0 : titleEl.textContent) == null ? void 0 : _a.trim()) || "";
            const infoEl = document.querySelector("#info");
            const infoText = (infoEl == null ? void 0 : infoEl.textContent) || "";
            if (infoText.includes("集数")) return "tv";
            if (/(?:[\s:：(（\[【]|^)(?:第[0-9一二三四五六七八九十]+季|Season\s*\d+|S\d+)/i.test(title)) return "tv";
            return "movie";
          },
          getCover: (el) => el,
          getDoubanId: () => location.pathname.split("/").filter(Boolean)[1] || ""
        },
        dotSize: "medium",
        observe: false,
        beforeMount: (cover) => {
          cover.style.marginLeft = "0";
        }
      },
{
        name: "explore",
        match: () => location.pathname.startsWith("/explore"),
        getItems: () => document.querySelectorAll(".subject-list-list li"),
        itemConfig: {
          getTitle: (el) => {
            var _a;
            return ((_a = el == null ? void 0 : el.querySelector(".drc-subject-info-title-text")) == null ? void 0 : _a.textContent) || "";
          },
          getYear: (el) => {
            var _a, _b, _c;
            return ((_c = (_b = (_a = el == null ? void 0 : el.querySelector(".drc-subject-info-subtitle")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.match(/\b(19|20)\d{2}\b/)) == null ? void 0 : _c[0]) || "";
          },
          getType: (card) => {
            var _a;
            return ((_a = card.querySelector(".drc-subject-card")) == null ? void 0 : _a.classList.contains("tv")) ? "tv" : "movie";
          },
          getCover: (card) => card.querySelector(".drc-cover-container"),
          getDoubanId: (card) => {
            var _a, _b;
            return ((_b = new URL(((_a = card.querySelector("a")) == null ? void 0 : _a.href) || "").searchParams.get("uri")) == null ? void 0 : _b.split("/").slice(-1)[0]) || "";
          }
        },
        dotSize: "small",
        observe: true
      },
{
        name: "chart",
        match: () => location.pathname.startsWith("/chart"),
        getItems: () => document.querySelectorAll(".indent tr.item"),
        itemConfig: {
          getTitle: (el) => {
            var _a;
            return ((_a = el == null ? void 0 : el.querySelector("a.nbg")) == null ? void 0 : _a.getAttribute("title")) || "";
          },
          getYear: (el) => {
            var _a, _b, _c;
            return ((_c = (_b = (_a = el == null ? void 0 : el.querySelector("td p")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.match(/\b(19|20)\d{2}\b/)) == null ? void 0 : _c[0]) || "";
          },
          getType: () => "movie",
          getCover: (card) => card.querySelector("a.nbg"),
          getDoubanId: (el) => {
            var _a;
            return new URL(((_a = el == null ? void 0 : el.querySelector("a.nbg")) == null ? void 0 : _a.href) || "").pathname.split("/").filter(Boolean)[1] || "";
          }
        },
        dotSize: "small",
        observe: true
      },
{
        name: "subject_collection",
        match: () => location.pathname.startsWith("/subject_collection"),
        getItems: () => document.querySelectorAll(".frc-subject-card-l"),
        itemConfig: {
          getTitle: (el) => {
            var _a;
            return ((_a = el == null ? void 0 : el.querySelector("h3.frc-subject-info-title")) == null ? void 0 : _a.textContent) || "";
          },
          getYear: (el) => {
            var _a, _b, _c;
            return ((_c = (_b = (_a = el == null ? void 0 : el.querySelector(".frc-subject-info-content")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.match(/\b(19|20)\d{2}\b/)) == null ? void 0 : _c[0]) || "";
          },
          getType: (card) => {
            var _a, _b;
            return ((_b = (_a = card.parentElement) == null ? void 0 : _a.parentElement) == null ? void 0 : _b.classList.contains("tv")) ? "tv" : "movie";
          },
          getCover: (card) => card.querySelector(".frc-size-cover"),
          getDoubanId: (el) => {
            var _a;
            return new URL(((_a = el.querySelector(".frc-subject-item-tag-vendor")) == null ? void 0 : _a.href) || "").pathname.split("/").filter(Boolean)[1] || "";
          }
        },
        dotSize: "medium",
        observe: true
      }
    ]
  };
  const gygConfig = {
    name: "GYG",
    match: (url) => url.includes("gyg.si"),
    pages: [
{
        name: "list",
        match: () => ["/mv", "/tv", "/ac", "/"].includes(location.pathname),
        getItems: () => document.querySelectorAll(".content-list li"),
        itemConfig: {
          getTitle: (item) => {
            var _a;
            return ((_a = item.querySelector("a")) == null ? void 0 : _a.getAttribute("title")) || "";
          },
          getYear: (item) => {
            var _a, _b, _c;
            return ((_c = (_b = (_a = item.querySelector(".li-bottom .tag")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.match(/\b(19|20)\d{2}\b/)) == null ? void 0 : _c[0]) || "";
          },
          getType: (item) => {
            var _a, _b;
            return ((_b = (_a = item.querySelector(".cover a")) == null ? void 0 : _a.getAttribute("href")) == null ? void 0 : _b.startsWith("/mv")) ? "movie" : "tv";
          },
          getCover: (item) => item.querySelector(".cover"),
          getDoubanId: () => ""
        },
        dotSize: "medium",
        observe: false
      },
      {
        name: "hits",
        match: (url) => new URL(url).pathname.startsWith("/hits"),
        getItems: () => document.querySelectorAll(".content-list li"),
        itemConfig: {
          getTitle: (item) => {
            var _a;
            return ((_a = item.querySelector("a")) == null ? void 0 : _a.getAttribute("title")) || "";
          },
          getYear: (item) => {
            var _a, _b, _c;
            return ((_c = (_b = (_a = item.querySelector(".li-bottom .tag")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.match(/\b(19|20)\d{2}\b/)) == null ? void 0 : _c[0]) || "";
          },
          getType: () => location.pathname.startsWith("/hits/mv") ? "movie" : "tv",
          getCover: (item) => item.querySelector(".cover"),
          getDoubanId: () => ""
        },
        dotSize: "medium",
        observe: false
      },
{
        name: "detail",
        match: () => true,
getItems: () => {
          const el = document.querySelector(".main-meta picture img");
          if (!el) return [];
          const ratingSection = document.querySelector(".ratings-section");
          return ratingSection ? [ratingSection] : [];
        },
        itemConfig: {
          getTitle: () => {
            var _a;
            return ((_a = document.querySelector(".main-meta picture img")) == null ? void 0 : _a.getAttribute("alt")) || "";
          },
          getYear: () => {
            var _a, _b;
            return ((_b = (_a = document.querySelector(".main-ui-meta .year")) == null ? void 0 : _a.textContent) == null ? void 0 : _b.trim().replace(/[()]/g, "")) || "";
          },
          getType: () => location.pathname.startsWith("/mv") ? "movie" : "tv",
          getCover: () => document.querySelector(".main-meta .img"),
          getDoubanId: () => {
            var _a, _b;
            return new URL(((_b = (_a = document.querySelector(".ratings-section")) == null ? void 0 : _a.querySelector("a")) == null ? void 0 : _b.href) || "").pathname.split("/").filter(Boolean)[1];
          }
        },
        dotSize: "medium",
        observe: false
      }
    ]
  };
  const RESOLUTION_RE = /(?:3840x2160|1920x1080|1280x720|2160[pP]|1080[pP]|720[pP]|4[kK])/i;
  const CODEC_KEYWORDS = [
    "HEVC-10bit",
    "HEVC 10bit",
    "AVC 8bit",
    "AVC-8bit",
    "HEVC",
    "AVC",
    "H\\.?265",
    "H\\.?264",
    "x265",
    "x264",
    "AV1",
    "10bit",
    "10-bit",
    "8bit",
    "8-bit"
  ];
  const CODEC_RE = new RegExp(`(?:${CODEC_KEYWORDS.join("|")})`, "gi");
  const AUDIO_KEYWORDS = ["AACx3", "AACx2", "AAC", "FLAC", "OPUS", "DTS", "AC3", "TrueHD", "Atmos"];
  const AUDIO_RE = new RegExp(`(?:${AUDIO_KEYWORDS.join("|")})`, "gi");
  const SOURCE_KEYWORDS = [
    "WEB-DL",
    "WebRip",
    "Web-Rip",
    "BDRip",
    "BD-Rip",
    "BDRIP",
    "Baha",
    "B-Global",
    "IQIYI",
    "Bilibili",
    "TVRip",
    "Remux",
    "BD",
    "DVD"
  ];
  const SOURCE_RE = new RegExp(`(?:${SOURCE_KEYWORDS.join("|")})`, "gi");
  const FORMAT_KEYWORDS = ["MKV", "MP4", "AVI"];
  const FORMAT_RE = new RegExp(`\\b(?:${FORMAT_KEYWORDS.join("|")})\\b`, "gi");
  const SUBTITLE_KEYWORDS_BLOCK = [
    "简繁日内封字幕",
    "简繁内封字幕",
    "简繁日内封",
    "繁簡日內封",
    "简繁内封",
    "繁简日内封",
    "繁简内封",
    "简体内嵌",
    "繁体内嵌",
    "简体内封",
    "繁体内封",
    "简日内嵌",
    "繁日内嵌",
    "简日双语",
    "繁日雙語",
    "简日内封",
    "繁日内封",
    "粵日雙語",
    "粵日國三語",
    "内封繁体中文字幕",
    "内封繁體中文字幕",
    "外挂繁體中文",
    "外挂简中字幕",
    "外掛繁體中文",
    "简中字幕",
    "繁中字幕",
    "CHS",
    "CHT",
    "BIG5",
    "GB"
  ];
  const SUBTITLE_BLOCK_RE = new RegExp(`(?:${SUBTITLE_KEYWORDS_BLOCK.map(escapeRegex).join("|")})`, "gi");
  const SEASON_RE = /(?:第([0-9一二三四五六七八九十百]+)[季期部]|[Ss](?:eason\s*)?(\d+))/;
  const EPISODE_RE = /(?:\s-\s*(\d{2,3})-(\d{2,3})(?:\s*(?:Fin|END|完))?\b|\s-\s*(\d+(?:v\d)?)\b|\b(\d{2,3})-(\d{2,3})(?:\s*(?:Fin|END|完))?\b)/i;
  const KNOWN_GROUP_PREFIXES = [
    "LoliHouse",
    "ANi",
    "VCB-Studio",
    "SweetSub",
    "GMTeam",
    "GM-Team",
    "桜都字幕组",
    "樱都字幕组",
    "幻樱字幕组",
    "幻櫻字幕組",
    "百冬练习组",
    "百冬練習組",
    "绿茶字幕组",
    "綠茶字幕組",
    "萝莉社活动室",
    "六四位元字幕組",
    "沸班亚马制作组",
    "jibaketa",
    "整理搬运"
  ];
  function escapeRegex(str) {
    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }
  function parseDmhyTitle(raw) {
    const result = {
      title: "",
      group: "",
      resolution: "",
      codec: "",
      audio: "",
      source: "",
      subtitle: "",
      format: "",
      episode: "",
      season: ""
    };
    let text = raw.trim();
    text = text.replace(/[\u200B\u200C\u200D\uFEFF]/g, "");
    text = extractGroup(text, result);
    if (text.includes("★")) {
      return parseStarFormat(text, result);
    }
    if (result.group === "整理搬运") {
      return parseCollectionFormat(text, result);
    }
    text = text.replace(/[（(]检索用[：:].*?[）)]/g, "");
    const { naked, tags } = extractBracketedBlocks(text);
    for (const tag of tags) {
      classifyTagBlock(tag, result);
    }
    extractInlineTech(naked, result);
    let title = cleanTitle(naked, result);
    if (!title && tags.length > 0) {
      title = findTitleFromTags(tags);
    }
    result.title = title;
    return result;
  }
  function extractGroup(text, result) {
    const groupMatch = text.match(/^(?:\[|【)([^\]】]+)(?:\]|】)/);
    if (groupMatch) {
      const candidate = groupMatch[1].trim();
      if (isGroupName(candidate)) {
        result.group = candidate;
        text = text.slice(groupMatch[0].length).trim();
      }
    }
    return text;
  }
  function isGroupName(str) {
    if (KNOWN_GROUP_PREFIXES.some((g) => str.includes(g))) return true;
    if (str.includes("&")) return true;
    if (/^[\w\-\.]+$/.test(str) && str.length <= 30) return true;
    if (/(?:字幕|制作|压制|壓制|合成|練習|练习|搬运|搬運|活动室)/.test(str)) return true;
    if (/[\u4e00-\u9fa5]/.test(str) && /[a-zA-Z]/.test(str) && str.length <= 20) return true;
    return false;
  }
  function parseStarFormat(text, result) {
    const parts = text.split("★").map((p2) => p2.trim()).filter(Boolean);
    if (parts.length >= 2) {
      let titleIdx = 0;
      if (!result.group && isGroupName(parts[0])) {
        result.group = parts[0];
        titleIdx = 1;
      }
      if (titleIdx < parts.length) {
        result.title = extractChineseTitle(parts[titleIdx]);
      }
      for (let i = titleIdx + 1; i < parts.length; i++) {
        classifyTagBlock(parts[i], result);
      }
    }
    if (!result.title && parts.length > 0) {
      result.title = parts[0];
    }
    return result;
  }
  function parseCollectionFormat(text, result) {
    const colonIdx = text.indexOf("：");
    let titlePart = colonIdx > 0 ? text.substring(0, colonIdx) : text;
    const parenIdx = titlePart.search(/[（(]/);
    if (parenIdx > 0) {
      titlePart = titlePart.substring(0, parenIdx);
    }
    titlePart = titlePart.replace(/[／\/]/g, "/");
    if (titlePart.includes("/")) {
      const parts = titlePart.split("/").map((p2) => p2.trim());
      const cnPart = parts.find((p2) => /[\u4e00-\u9fa5]/.test(p2) && p2.length > 1);
      titlePart = cnPart || parts[0];
    }
    result.title = titlePart.trim();
    if (colonIdx > 0) {
      const desc = text.substring(colonIdx + 1);
      if (/华日|日语|粤语/.test(desc)) {
        const audioMatch = desc.match(/(华日|日语|粤语|华日英)[音轨,;，；\s]/);
        if (audioMatch) result.audio = audioMatch[1];
      }
      if (/字幕/.test(desc)) {
        const subMatch = desc.match(/(外挂简中字幕|外挂简中|外掛繁體中文|内封简中字幕|外挂简中,\s*英文字幕)/);
        if (subMatch) result.subtitle = subMatch[1];
      }
    }
    return result;
  }
  function findTitleFromTags(tags, result) {
    const isTechOrMeta = (tag) => {
      var _a;
      if (RESOLUTION_RE.test(tag) && ((_a = tag.match(RESOLUTION_RE)) == null ? void 0 : _a[0]) === tag) return true;
      if (/^(?:MP4|MKV|AVI)$/i.test(tag)) return true;
      if (/^\d{1,3}(?:v\d)?$/.test(tag)) return true;
      if (/^\d{2,3}-\d{2,3}/.test(tag)) return true;
      if (/^[Ss]\d{1,2}$/.test(tag)) return true;
      if (/^(?:19|20)\d{2}$/.test(tag)) return true;
      const upperTag = tag.toUpperCase();
      if ([
        "HEVC",
        "AVC",
        "X264",
        "X265",
        "AV1",
        "AAC",
        "FLAC",
        "OPUS",
        "WEBRIP",
        "BDRIP",
        "WEB-DL",
        "BD",
        "GB",
        "BIG5"
      ].includes(upperTag)) return true;
      if (/^[\w\s\-.]+$/i.test(tag) && RESOLUTION_RE.test(tag)) return true;
      if (/^\d+月新番$/.test(tag)) return true;
      if (SUBTITLE_BLOCK_RE.test(tag)) {
        SUBTITLE_BLOCK_RE.lastIndex = 0;
        return true;
      }
      if (/^(?:国漫|動畫|动画|日漫)$/.test(tag)) return true;
      if (/检索用/.test(tag)) return true;
      return false;
    };
    const scoreTag = (tag) => {
      let score = 0;
      const cnChars = (tag.match(/[\u4e00-\u9fa5]/g) || []).length;
      if (cnChars > 0) score += cnChars * 3;
      if (tag.length >= 2 && tag.length <= 40) score += tag.length;
      if (tag.includes("/") || tag.includes("_")) score += 5;
      if (/^[\w\s\-.']+$/.test(tag) && !/[\u4e00-\u9fa5]/.test(tag)) score -= 10;
      if (isTechOrMeta(tag)) score -= 100;
      return score;
    };
    let bestTag = "";
    let bestScore = -Infinity;
    for (const tag of tags) {
      const score = scoreTag(tag);
      if (score > bestScore) {
        bestScore = score;
        bestTag = tag;
      }
    }
    if (bestTag) {
      return extractChineseTitle(bestTag);
    }
    return "";
  }
  function extractBracketedBlocks(text) {
    const tags = [];
    const blockRegex = /(?:\[([^\]]+)\]|【([^】]+)】|（([^）]+)）)/g;
    let match;
    while ((match = blockRegex.exec(text)) !== null) {
      const content = (match[1] || match[2] || match[3]).trim();
      if (content) tags.push(content);
    }
    const naked = text.replace(/(?:\[[^\]]+\]|【[^】]+】|（[^）]+）)/g, " ").trim();
    return { naked, tags };
  }
  function classifyTagBlock(tag, result) {
    tag.toUpperCase();
    if (!result.resolution && RESOLUTION_RE.test(tag)) {
      const m = tag.match(RESOLUTION_RE);
      if (m) result.resolution = m[0];
    }
    if (SUBTITLE_BLOCK_RE.test(tag)) {
      const matches = tag.match(SUBTITLE_BLOCK_RE);
      if (matches) {
        result.subtitle = result.subtitle ? result.subtitle + " " + matches.join(" ") : matches.join(" ");
      }
      return;
    }
    if (/^(?:MP4|MKV|AVI)$/i.test(tag)) {
      result.format = tag.toUpperCase();
      return;
    }
    const epRangeMatch = tag.match(/^(\d{2,3}-\d{2,3})/);
    if (epRangeMatch && !result.episode) {
      result.episode = epRangeMatch[1];
      return;
    }
    if (/^\d{1,3}(?:v\d)?$/.test(tag) && !result.episode) {
      result.episode = tag;
      return;
    }
    if (/^[Ss]\d{1,2}$/.test(tag)) {
      result.season = tag;
      return;
    }
    if (SOURCE_RE.test(tag)) {
      const m = tag.match(SOURCE_RE);
      if (m && !result.source) result.source = m[0];
      SOURCE_RE.lastIndex = 0;
    }
    if (CODEC_RE.test(tag)) {
      const m = tag.match(CODEC_RE);
      if (m) {
        const codecs = [...new Set(m.map((c) => normalizeCodec(c)))];
        result.codec = result.codec ? result.codec + " " + codecs.join(" ") : codecs.join(" ");
      }
      CODEC_RE.lastIndex = 0;
    }
    if (AUDIO_RE.test(tag)) {
      const m = tag.match(AUDIO_RE);
      if (m && !result.audio) result.audio = m.join(" ");
      AUDIO_RE.lastIndex = 0;
    }
    if (FORMAT_RE.test(tag)) {
      const m = tag.match(FORMAT_RE);
      if (m && !result.format) result.format = m[0].toUpperCase();
      FORMAT_RE.lastIndex = 0;
    }
  }
  function extractInlineTech(text, result) {
    if (!result.resolution) {
      const m = text.match(RESOLUTION_RE);
      if (m) result.resolution = m[0];
    }
    if (!result.source) {
      const m = text.match(SOURCE_RE);
      if (m) result.source = m[0];
      SOURCE_RE.lastIndex = 0;
    }
    if (!result.codec) {
      const m = text.match(CODEC_RE);
      if (m) {
        result.codec = [...new Set(m.map((c) => normalizeCodec(c)))].join(" ");
      }
      CODEC_RE.lastIndex = 0;
    }
    if (!result.audio) {
      const m = text.match(AUDIO_RE);
      if (m) result.audio = m.join(" ");
      AUDIO_RE.lastIndex = 0;
    }
    if (!result.format) {
      const m = text.match(FORMAT_RE);
      if (m) result.format = m[0].toUpperCase();
      FORMAT_RE.lastIndex = 0;
    }
    if (!result.season) {
      const m = text.match(SEASON_RE);
      if (m) {
        result.season = m[0].trim();
      }
    }
    if (!result.episode) {
      const m = text.match(EPISODE_RE);
      if (m) {
        if (m[1] && m[2]) result.episode = `${m[1]}-${m[2]}`;
        else if (m[3]) result.episode = m[3];
        else if (m[4] && m[5]) result.episode = `${m[4]}-${m[5]}`;
      }
    }
  }
  function normalizeCodec(codec) {
    const c = codec.replace(/[\s-]/g, "").toUpperCase();
    if (c === "H265" || c === "H.265") return "HEVC";
    if (c === "H264" || c === "H.264") return "AVC";
    if (c === "HEVC10BIT") return "HEVC 10bit";
    if (c === "AVC8BIT") return "AVC 8bit";
    return codec;
  }
  function cleanTitle(naked, result) {
    let title = naked;
    title = title.replace(RESOLUTION_RE, " ");
    title = title.replace(SOURCE_RE, " ");
    SOURCE_RE.lastIndex = 0;
    title = title.replace(CODEC_RE, " ");
    CODEC_RE.lastIndex = 0;
    title = title.replace(AUDIO_RE, " ");
    AUDIO_RE.lastIndex = 0;
    title = title.replace(FORMAT_RE, " ");
    FORMAT_RE.lastIndex = 0;
    title = title.replace(SUBTITLE_BLOCK_RE, " ");
    SUBTITLE_BLOCK_RE.lastIndex = 0;
    title = title.replace(/\s+-\s+\d+(?:v\d)?(?:\s|$)/g, " ");
    title = title.replace(/\s+-\s+\d{2,3}-\d{2,3}(?:\s+(?:Fin|END|完))?\s*/gi, " ");
    if (result.season) {
      title = title.replace(SEASON_RE, " ");
    }
    title = title.replace(/\b(?:Fin|END|完)\b/gi, " ");
    title = title.replace(/\b(19|20)\d{2}\b/g, " ");
    title = title.replace(/\b\d{2,3}-\d{2,3}\b/g, " ");
    title = title.replace(/\bv\d\b/gi, " ");
    title = title.replace(/\d+月新番/, " ");
    title = title.replace(/[（(]检索用[：:].*?[）)]/g, " ");
    title = extractChineseTitle(title);
    return title;
  }
  function extractChineseTitle(text) {
    let title = text.trim();
    title = title.replace(/[／_]/g, "/");
    if (title.includes("/")) {
      const parts = title.split("/").map((p2) => p2.trim()).filter((p2) => p2.length > 0);
      const cnPart = parts.find((p2) => /[\u4e00-\u9fa5]/.test(p2) && p2.length > 1);
      if (cnPart) {
        title = cnPart;
      } else {
        title = parts[0] || title;
      }
    }
    title = title.replace(/[【】\[\]（）()★]/g, " ");
    title = title.replace(/^[\s\-–—:：.·,，]+/, "");
    title = title.replace(/[\s\-–—:：.·,，]+$/, "");
    title = title.replace(/\s+/g, " ").trim();
    return title;
  }
  class BangumiService extends ApiClient {
    constructor() {
      super("Bangumi");
    }
    async search(query) {
      const apiKey = CONFIG.bangumi.apiKey;
      if (!apiKey) {
        return {
          data: null,
          meta: { error: "Token not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const cacheKey = this.buildCacheKey("search", query);
      const config = CONFIG.bangumi;
      return this.request({
        requestFn: async () => {
          const url = `${config.baseUrl}/v0/search/subjects`;
          const response = await GM.xmlHttpRequest({
            method: "POST",
            url,
            responseType: "json",
            headers: {
              "Authorization": `Bearer ${apiKey}`,
              "Content-Type": "application/json"
            },
            data: JSON.stringify({
              keyword: query,
              filter: { type: [2] }
})
          });
          if (response.status === 200) {
            const data = typeof response.response === "string" ? JSON.parse(response.response) : response.response;
            if (data && data.data && data.data.length > 0) {
              return data.data[0];
            }
          } else {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
          }
          return null;
        },
        cacheKey,
        cacheTTL: 1440,
        useCache: true,
        useQueue: true
      });
    }
    determineTTL(data, defaultTTL) {
      return data ? defaultTTL : 60;
    }
  }
  const bangumiService = new BangumiService();
  const dmhyConfig = {
    name: "DMHY",
    match: (url) => {
      try {
        const u = new URL(url);
        return u.hostname.includes("dmhy.org") && (u.pathname === "/" || u.pathname.startsWith("/topics"));
      } catch {
        return false;
      }
    },
    globalStyles: `
    /* Hide original tag spans */
    table#topic_list tr td span.tag { display: none !important; }

    /* Tag badges */
    .us-dmhy-tag {
      display: inline-block;
      padding: 1px 6px;
      border-radius: 4px;
      font-size: 11px;
      font-weight: 500;
      margin-left: 4px;
      white-space: nowrap;
      vertical-align: middle;
      line-height: 1.6;
    }
    .us-dmhy-tag-group    { background: #fff8e1; color: #f57f17; }
    .us-dmhy-tag-res      { background: #e3f2fd; color: #1565c0; }
    .us-dmhy-tag-codec    { background: #f3e5f5; color: #6a1b9a; }
    .us-dmhy-tag-audio    { background: #fce4ec; color: #c62828; }
    .us-dmhy-tag-source   { background: #e8f5e9; color: #2e7d32; }
    .us-dmhy-tag-subtitle { background: #e0f7fa; color: #00695c; }
    .us-dmhy-tag-format   { background: #e0e0e0; color: #424242; }
    .us-dmhy-tag-bangumi  { background: #e8f5e9; color: #2e7d32; cursor: pointer; text-decoration: none; }
    .us-dmhy-tag-bangumi:hover { opacity: 0.8; }
    .us-dmhy-tag-episode  { background: #ede7f6; color: #4527a0; }
    .us-dmhy-tag-season   { background: #fce4ec; color: #880e4f; }

    /* Inline DOT for DMHY (no cover images) */
    .us-dmhy-dot-wrapper {
      display: inline-block;
      width: 14px;
      height: 14px;
      margin-right: 4px;
      vertical-align: middle;
      position: relative;
    }
  `,
    pages: [
      {
        name: "topic_list",
        match: () => true,
        handler: () => processTopicList()
      }
    ]
  };
  const TAG_DEFS = [
    { key: "season", cssClass: "us-dmhy-tag-season" },
    { key: "episode", cssClass: "us-dmhy-tag-episode" },
    { key: "group", cssClass: "us-dmhy-tag-group" },
    { key: "resolution", cssClass: "us-dmhy-tag-res" },
    { key: "codec", cssClass: "us-dmhy-tag-codec" },
    { key: "audio", cssClass: "us-dmhy-tag-audio" },
    { key: "source", cssClass: "us-dmhy-tag-source" },
    { key: "subtitle", cssClass: "us-dmhy-tag-subtitle" },
    { key: "format", cssClass: "us-dmhy-tag-format" }
  ];
  function processTopicList() {
    const links = document.querySelectorAll("#topic_list td.title a");
    links.forEach((link) => {
      var _a, _b, _c;
      const anchor = link;
      const href = anchor.getAttribute("href") || "";
      if (!href.includes("/topics/view/")) return;
      const rawTitle = ((_a = anchor.textContent) == null ? void 0 : _a.trim()) || "";
      if (!rawTitle) return;
      const parsed = parseDmhyTitle(rawTitle);
      if (!parsed.title) return;
      anchor.textContent = parsed.title;
      anchor.title = rawTitle;
      const tagContainer = document.createElement("span");
      tagContainer.style.whiteSpace = "nowrap";
      for (const def2 of TAG_DEFS) {
        const value = parsed[def2.key];
        if (value) {
          tagContainer.appendChild(createTagBadge(value, def2.cssClass));
        }
      }
      (_b = anchor.parentNode) == null ? void 0 : _b.insertBefore(tagContainer, anchor.nextSibling);
      const dotWrapper = document.createElement("div");
      dotWrapper.className = "us-dmhy-dot-wrapper";
      (_c = anchor.parentNode) == null ? void 0 : _c.insertBefore(dotWrapper, anchor);
      const dot = uiController.mountDot(dotWrapper, "mini");
      processAnimeItem(parsed.title, dot, tagContainer);
    });
  }
  async function processAnimeItem(title, dot, tagContainer) {
    try {
      if (configService.validate("emby")) {
        const embyResult = await embyService.searchByName(title);
        const items = embyResult.data || [];
        const matchedItems = items.filter((item) => isNameMatch(title, item.Name));
        if (matchedItems.length > 0) {
          const item = matchedItems[0];
          dot.setAttribute("status", "found");
          dot.setAttribute("title", `Emby: ${item.Name}`);
          uiController.bindInfoCard(dot, {
            tmdbId: null,
            embyItem: item,
            embyItems: matchedItems.length > 1 ? matchedItems : void 0,
            status: "found",
            statusMessage: `Found: ${item.Name}`,
            title,
            mediaType: "tv",
            searchQueries: [title]
          });
          return;
        }
      }
      if (configService.validate("bangumi")) {
        const bangumiResult = await bangumiService.search(title);
        const subject = bangumiResult.data;
        if (subject) {
          dot.setAttribute("status", "not-found");
          dot.setAttribute("title", `BGM: ${subject.name_cn || subject.name}`);
          const bangumiLink = document.createElement("a");
          bangumiLink.className = "us-dmhy-tag us-dmhy-tag-bangumi";
          bangumiLink.textContent = `BGM:${subject.id}`;
          bangumiLink.href = `https://bgm.tv/subject/${subject.id}`;
          bangumiLink.target = "_blank";
          bangumiLink.rel = "noopener noreferrer";
          bangumiLink.title = subject.name_cn || subject.name;
          bangumiLink.addEventListener("click", (e) => e.stopPropagation());
          tagContainer.appendChild(bangumiLink);
          return;
        }
      }
      dot.setAttribute("status", "not-found");
      dot.setAttribute("title", "Not found");
    } catch (error) {
      dot.setAttribute("status", "error");
      dot.setAttribute("title", `Error: ${error}`);
    }
  }
  function isNameMatch(searchTitle, embyName) {
    const normalize = (s) => s.toLowerCase().replace(/[\s\-–—:：·・、,，.。!！?？]/g, "").replace(/[（()）\[\]【】]/g, "");
    const a = normalize(searchTitle);
    const b = normalize(embyName);
    if (a === b) return true;
    if (a.includes(b) || b.includes(a)) return true;
    const shorter = a.length <= b.length ? a : b;
    const longer = a.length > b.length ? a : b;
    if (shorter.length >= 2 && longer.includes(shorter)) return true;
    if (/[\u4e00-\u9fa5]/.test(a) && /[\u4e00-\u9fa5]/.test(b)) {
      const charsA = new Set(a);
      let overlap = 0;
      for (const c of b) {
        if (charsA.has(c)) overlap++;
      }
      const ratio = overlap / Math.max(a.length, b.length);
      if (ratio >= 0.6) return true;
    }
    return false;
  }
  function createTagBadge(text, cssClass) {
    const span = document.createElement("span");
    span.className = `us-dmhy-tag ${cssClass}`;
    span.textContent = text;
    return span;
  }
  const _hoisted_1$5 = ["title"];
  const _sfc_main$5 = defineComponent({
    __name: "StatusDot.ce",
    props: {
      status: { type: String },
      title: { type: String },
      size: { type: String }
    },
    emits: ["dotClick"],
    setup(__props, { emit: __emit }) {
      useCssVars((_ctx) => ({
        "c80a992e": padding.value
      }));
      const props = __props;
      const emit2 = __emit;
      const statusClass = computed(() => {
        switch (props.status) {
          case "loading":
            return "dot-loading";
          case "found":
            return "found";
          case "not-found":
            return "not-found";
          case "error":
            return "error";
          default:
            return "dot-loading";
        }
      });
      const dotTitle = computed(() => {
        if (props.title) return props.title;
        switch (props.status) {
          case "loading":
            return "Checking...";
          case "found":
            return "Found in Emby";
          case "not-found":
            return "Not found";
          case "error":
            return "Error";
          default:
            return "";
        }
      });
      const padding = computed(() => {
        if (props.size === "small") return "4px";
        if (props.size === "large") return "8px";
        if (props.size === "mini") return "0";
        return "6px";
      });
      return (_ctx, _cache) => {
        return openBlock(), createElementBlock("div", {
          class: normalizeClass([statusClass.value, "us-dot"]),
          title: dotTitle.value,
          onClick: _cache[0] || (_cache[0] = ($event) => emit2("dotClick"))
        }, null, 10, _hoisted_1$5);
      };
    }
  });
  const _style_0$5 = ":host{width:100%;height:100%;display:block;padding:var(--c80a992e);box-sizing:border-box}.us-dot{border-radius:50%;cursor:pointer;box-shadow:0 0 8px #00000080;border:2px solid white;transition:transform .2s ease,opacity .2s ease;display:flex;align-items:center;justify-content:center;font-size:0;width:100%;height:100%;box-sizing:border-box}.us-dot:hover{transform:scale(1.15)}.us-dot.dot-loading{background-color:#01b4e4;animation:us-pulse 1.5s infinite;opacity:.8;border-color:#fffc}.us-dot.found{background-color:#52b54b;box-shadow:0 0 10px #52b54bcc}.us-dot.not-found,.us-dot.error{background-color:#9e9e9e;opacity:.7}@keyframes us-pulse{0%{transform:scale(.95);opacity:.7}50%{transform:scale(1.05);opacity:1}to{transform:scale(.95);opacity:.7}}";
  const _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
      target[key] = val;
    }
    return target;
  };
  const StatusDotCE = _export_sfc(_sfc_main$5, [["styles", [_style_0$5]]]);
  const _hoisted_1$4 = { class: "us-emby-section" };
  const _hoisted_2$4 = {
    key: 0,
    class: "us-emby-switcher"
  };
  const _hoisted_3$4 = ["value"];
  const _hoisted_4$4 = ["value"];
  const _hoisted_5$4 = { class: "us-emby-detail-row" };
  const _hoisted_6$3 = { class: "us-emby-poster" };
  const _hoisted_7$3 = ["src"];
  const _hoisted_8$3 = { class: "us-emby-info" };
  const _hoisted_9$3 = { class: "us-emby-name" };
  const _hoisted_10$3 = { class: "us-emby-year" };
  const _hoisted_11$3 = { class: "us-emby-tags" };
  const _hoisted_12$3 = { class: "us-emby-type-badge" };
  const _hoisted_13$3 = {
    key: 0,
    class: "us-emby-rating"
  };
  const _hoisted_14$3 = {
    key: 0,
    class: "us-season-badges"
  };
  const _hoisted_15$3 = {
    key: 1,
    class: "us-series-count"
  };
  const _hoisted_16$2 = { class: "us-emby-path" };
  const _hoisted_17$2 = { class: "us-path-value" };
  const _hoisted_18$2 = {
    key: 2,
    class: "us-tech-info"
  };
  const _hoisted_19$2 = {
    key: 3,
    class: "us-stream-info"
  };
  const _hoisted_20$2 = {
    key: 4,
    class: "us-stream-info"
  };
  const _hoisted_21$1 = { class: "us-emby-action" };
  const _hoisted_22$1 = ["href"];
  const _sfc_main$4 = defineComponent({
    __name: "EmbyCard.ce",
    props: {
      item: { type: Object },
      items: { type: Array }
    },
    setup(__props) {
      const props = __props;
      const selectedIndex = ref(0);
      const current = computed(() => {
        var _a;
        if ((_a = props.items) == null ? void 0 : _a.length) {
          return props.items[selectedIndex.value] || props.items[0];
        }
        return props.item;
      });
      const year = computed(() => {
        var _a;
        return ((_a = current.value) == null ? void 0 : _a.ProductionYear) || "";
      });
      const rating = computed(() => {
        if (!current.value) return "";
        return current.value.CommunityRating ? current.value.CommunityRating.toFixed(1) : current.value.OfficialRating || "";
      });
      const path = computed(() => {
        var _a, _b;
        if (!current.value) return "";
        return current.value.Path || ((_b = (_a = current.value.MediaSources) == null ? void 0 : _a[0]) == null ? void 0 : _b.Path) || "Path Unknown";
      });
      const imgUrl = computed(() => {
        if (!current.value) return "";
        return `${CONFIG.emby.server}/emby/Items/${current.value.Id}/Images/Primary?maxHeight=300&maxWidth=200&quality=90`;
      });
      const webUrl = computed(() => {
        if (!current.value) return "";
        return `${CONFIG.emby.server}/web/index.html#!/item?id=${current.value.Id}&serverId=${current.value.ServerId || ""}`;
      });
      const techInfo = computed(() => {
        var _a, _b;
        if (!((_b = (_a = current.value) == null ? void 0 : _a.MediaSources) == null ? void 0 : _b.length)) return [];
        const source = current.value.MediaSources[0];
        const items = [];
        const sizeBytes = source.Size || 0;
        items.push((sizeBytes / (1024 * 1024 * 1024)).toFixed(2) + " GB");
        if (source.Container) items.push(source.Container.toUpperCase());
        if (source.MediaStreams) {
          const video = source.MediaStreams.find((s) => s.Type === "Video");
          if (video) {
            if (video.Width && video.Height) items.push(`${video.Width}x${video.Height}`);
            if (video.Codec) items.push(video.Codec.toUpperCase());
            if (video.BitRate) items.push((video.BitRate / 1e6).toFixed(1) + " Mbps");
            if (video.BitDepth) items.push(`${video.BitDepth}bit`);
          }
        }
        return items;
      });
      const audioInfo = computed(() => {
        var _a, _b, _c;
        if (!((_c = (_b = (_a = current.value) == null ? void 0 : _a.MediaSources) == null ? void 0 : _b[0]) == null ? void 0 : _c.MediaStreams)) return "";
        const audios = current.value.MediaSources[0].MediaStreams.filter((s) => s.Type === "Audio");
        if (!audios.length) return "";
        return "🔊 " + audios.map((a) => {
          const lang = (a.Language || "und").toUpperCase();
          const codec = (a.Codec || "").toUpperCase();
          const channels = a.Channels ? a.Channels === 6 ? "5.1" : a.Channels === 8 ? "7.1" : "2.0" : "";
          return `${lang} ${codec} ${channels}`.trim();
        }).join(" / ");
      });
      const subtitleInfo = computed(() => {
        var _a, _b, _c;
        if (!((_c = (_b = (_a = current.value) == null ? void 0 : _a.MediaSources) == null ? void 0 : _b[0]) == null ? void 0 : _c.MediaStreams)) return "";
        const subs = current.value.MediaSources[0].MediaStreams.filter((s) => s.Type === "Subtitle");
        if (!subs.length) return "";
        return "💬 " + subs.map((s) => {
          const lang = (s.Language || "und").toUpperCase();
          const codec = (s.Codec || "").toUpperCase();
          const forced = s.IsForced ? "[Forced]" : "";
          return `${lang} ${codec}${forced}`.trim();
        }).join(" / ");
      });
      return (_ctx, _cache) => {
        var _a;
        return openBlock(), createElementBlock("div", _hoisted_1$4, [
          __props.items && __props.items.length > 1 ? (openBlock(), createElementBlock("div", _hoisted_2$4, [
            createBaseVNode("select", {
              class: "us-emby-select",
              value: selectedIndex.value,
              onChange: _cache[0] || (_cache[0] = ($event) => selectedIndex.value = Number($event.target.value))
            }, [
              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (it, idx) => {
                return openBlock(), createElementBlock("option", {
                  key: it.Id,
                  value: idx
                }, toDisplayString(it.Name) + " (" + toDisplayString(it.ProductionYear || "") + ") - " + toDisplayString(it.Type), 9, _hoisted_4$4);
              }), 128))
            ], 40, _hoisted_3$4)
          ])) : createCommentVNode("", true),
          createBaseVNode("div", _hoisted_5$4, [
            createBaseVNode("div", _hoisted_6$3, [
              createBaseVNode("img", {
                src: imgUrl.value,
                onError: _cache[1] || (_cache[1] = ($event) => $event.target.style.display = "none")
              }, null, 40, _hoisted_7$3)
            ]),
            createBaseVNode("div", _hoisted_8$3, [
              createBaseVNode("div", _hoisted_9$3, [
                createTextVNode(toDisplayString(current.value.Name) + " ", 1),
                createBaseVNode("span", _hoisted_10$3, "(" + toDisplayString(year.value) + ")", 1)
              ]),
              createBaseVNode("div", _hoisted_11$3, [
                createBaseVNode("span", _hoisted_12$3, toDisplayString(current.value.Type), 1),
                rating.value ? (openBlock(), createElementBlock("span", _hoisted_13$3, "★ " + toDisplayString(rating.value), 1)) : createCommentVNode("", true)
              ]),
              current.value.Type === "Series" && ((_a = current.value.Seasons) == null ? void 0 : _a.length) ? (openBlock(), createElementBlock("div", _hoisted_14$3, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(current.value.Seasons, (s) => {
                  return openBlock(), createElementBlock("span", {
                    key: s.Id,
                    class: "us-season-badge"
                  }, toDisplayString(s.Name.replace("Season", "S").replace("Specials", "SP")) + ": " + toDisplayString(s.ChildCount || s.RecursiveItemCount || 0) + "集 ", 1);
                }), 128))
              ])) : current.value.Type === "Series" ? (openBlock(), createElementBlock("div", _hoisted_15$3, toDisplayString(current.value.ChildCount || 0) + " Seasons / " + toDisplayString(current.value.RecursiveItemCount || 0) + " Episodes ", 1)) : createCommentVNode("", true),
              createBaseVNode("div", _hoisted_16$2, [
                _cache[2] || (_cache[2] = createBaseVNode("strong", null, "Path:", -1)),
                _cache[3] || (_cache[3] = createTextVNode()),
                createBaseVNode("span", _hoisted_17$2, toDisplayString(path.value), 1)
              ]),
              techInfo.value.length ? (openBlock(), createElementBlock("div", _hoisted_18$2, toDisplayString(techInfo.value.join(" • ")), 1)) : createCommentVNode("", true),
              audioInfo.value ? (openBlock(), createElementBlock("div", _hoisted_19$2, toDisplayString(audioInfo.value), 1)) : createCommentVNode("", true),
              subtitleInfo.value ? (openBlock(), createElementBlock("div", _hoisted_20$2, toDisplayString(subtitleInfo.value), 1)) : createCommentVNode("", true),
              createBaseVNode("div", _hoisted_21$1, [
                createBaseVNode("a", {
                  href: webUrl.value,
                  target: "_blank",
                  class: "us-btn us-btn-primary"
                }, "▶ Play on Emby", 8, _hoisted_22$1)
              ])
            ])
          ])
        ]);
      };
    }
  });
  const _style_0$4 = ".us-emby-section{padding:20px;border-bottom:1px solid #eee;background:#fdfdfd}.us-emby-switcher{margin-bottom:12px}.us-emby-select{width:100%;padding:6px 10px;border:1px solid #ccc;border-radius:6px;font-size:13px;color:#333;background:#fff;cursor:pointer}.us-emby-detail-row{display:flex}.us-emby-poster{flex-shrink:0;width:100px;margin-right:20px}.us-emby-poster img{width:100%;border-radius:6px;box-shadow:0 2px 8px #0000001a}.us-emby-info{flex:1}.us-emby-name{font-size:18px;font-weight:700;color:#333;margin-bottom:4px}.us-emby-year{font-weight:400;color:#999;font-size:14px}.us-emby-tags{font-size:13px;color:#666;margin-bottom:8px}.us-emby-type-badge{background:#eee;padding:2px 6px;border-radius:4px;margin-right:6px}.us-emby-rating{color:#f5c518;font-weight:700}.us-season-badges{margin-top:6px;display:flex;flex-wrap:wrap;gap:4px}.us-season-badge{background:#e8f5e9;color:#2e7d32;padding:2px 6px;border-radius:4px;font-size:11px;border:1px solid #c8e6c9}.us-series-count{margin-top:5px;color:#52b54b;font-weight:700}.us-emby-path{font-size:12px;color:#555;margin-top:8px;line-height:1.4}.us-path-value{font-family:monospace;background:#f1f1f1;padding:2px 4px;border-radius:3px;word-break:break-all}.us-tech-info{font-size:12px;color:#999;margin-top:6px}.us-stream-info{font-size:11px;color:#777;margin-top:6px;line-height:1.4}.us-emby-action{margin-top:12px}.us-btn{display:inline-block;padding:4px 8px;border-radius:6px;text-decoration:none;font-size:14px;font-weight:500;cursor:pointer;border:none;transition:background .2s}.us-btn-primary{background:#52b54b;color:#fff}.us-btn-primary:hover{background:#43943d}";
  const EmbyCard = _export_sfc(_sfc_main$4, [["styles", [_style_0$4]]]);
  const _hoisted_1$3 = { class: "us-tmdb-section" };
  const _hoisted_2$3 = {
    key: 0,
    class: "us-tmdb-switcher"
  };
  const _hoisted_3$3 = ["value"];
  const _hoisted_4$3 = ["value"];
  const _hoisted_5$3 = { class: "us-tmdb-detail" };
  const _hoisted_6$2 = { class: "us-tmdb-poster" };
  const _hoisted_7$2 = ["src"];
  const _hoisted_8$2 = {
    key: 1,
    class: "us-tmdb-no-poster"
  };
  const _hoisted_9$2 = { class: "us-tmdb-info" };
  const _hoisted_10$2 = { class: "us-tmdb-title" };
  const _hoisted_11$2 = { class: "us-tmdb-meta" };
  const _hoisted_12$2 = { class: "us-tmdb-year-badge" };
  const _hoisted_13$2 = { class: "us-tmdb-type-badge" };
  const _hoisted_14$2 = { class: "us-tmdb-id-badge" };
  const _hoisted_15$2 = { class: "us-tmdb-overview" };
  const _hoisted_16$1 = { class: "us-tmdb-links" };
  const _hoisted_17$1 = ["href"];
  const _hoisted_18$1 = {
    key: 1,
    class: "us-tmdb-pagination"
  };
  const _hoisted_19$1 = {
    key: 1,
    class: "us-tmdb-empty"
  };
  const _hoisted_20$1 = { class: "us-tmdb-empty-title" };
  const _sfc_main$3 = defineComponent({
    __name: "TmdbCard.ce",
    props: {
      results: { type: Array },
      title: { type: String }
    },
    setup(__props) {
      const props = __props;
      const selectedIndex = ref(0);
      const current = computed(() => {
        var _a;
        if (!((_a = props.results) == null ? void 0 : _a.length)) return null;
        return props.results[selectedIndex.value] || props.results[0];
      });
      const posterUrl = computed(() => {
        var _a;
        if (!((_a = current.value) == null ? void 0 : _a.posterPath)) return "";
        return `https://image.tmdb.org/t/p/w300${current.value.posterPath}`;
      });
      return (_ctx, _cache) => {
        return openBlock(), createElementBlock("div", _hoisted_1$3, [
          _cache[3] || (_cache[3] = createBaseVNode("div", { class: "us-tmdb-header" }, [
            createBaseVNode("span", null, "🎬 影片信息"),
            createBaseVNode("span", { class: "us-tmdb-not-found-badge" }, "Not in Emby")
          ], -1)),
          current.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
            __props.results.length > 1 ? (openBlock(), createElementBlock("div", _hoisted_2$3, [
              createBaseVNode("select", {
                class: "us-tmdb-select",
                value: selectedIndex.value,
                onChange: _cache[0] || (_cache[0] = ($event) => selectedIndex.value = Number($event.target.value))
              }, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(__props.results, (item, idx) => {
                  return openBlock(), createElementBlock("option", {
                    key: item.id,
                    value: idx
                  }, toDisplayString(item.title) + " (" + toDisplayString(item.year) + ") ", 9, _hoisted_4$3);
                }), 128))
              ], 40, _hoisted_3$3)
            ])) : createCommentVNode("", true),
            createBaseVNode("div", _hoisted_5$3, [
              createBaseVNode("div", _hoisted_6$2, [
                posterUrl.value ? (openBlock(), createElementBlock("img", {
                  key: 0,
                  src: posterUrl.value,
                  onError: _cache[1] || (_cache[1] = ($event) => $event.target.style.display = "none")
                }, null, 40, _hoisted_7$2)) : (openBlock(), createElementBlock("div", _hoisted_8$2, "No Poster"))
              ]),
              createBaseVNode("div", _hoisted_9$2, [
                createBaseVNode("div", _hoisted_10$2, toDisplayString(current.value.title), 1),
                createBaseVNode("div", _hoisted_11$2, [
                  createBaseVNode("span", _hoisted_12$2, toDisplayString(current.value.year), 1),
                  createBaseVNode("span", _hoisted_13$2, toDisplayString(current.value.mediaType === "tv" ? "TV" : "Movie"), 1),
                  createBaseVNode("span", _hoisted_14$2, "TMDB: " + toDisplayString(current.value.id), 1)
                ]),
                createBaseVNode("div", _hoisted_15$2, toDisplayString(current.value.overview || "暂无简介"), 1),
                createBaseVNode("div", _hoisted_16$1, [
                  createBaseVNode("a", {
                    href: `https://www.themoviedb.org/${current.value.mediaType}/${current.value.id}`,
                    target: "_blank",
                    class: "us-btn us-btn-tmdb"
                  }, " Open on TMDB ↗ ", 8, _hoisted_17$1)
                ])
              ])
            ]),
            __props.results.length > 1 ? (openBlock(), createElementBlock("div", _hoisted_18$1, toDisplayString(selectedIndex.value + 1) + " / " + toDisplayString(__props.results.length) + " 个匹配结果 ", 1)) : createCommentVNode("", true)
          ], 64)) : (openBlock(), createElementBlock("div", _hoisted_19$1, [
            createBaseVNode("div", _hoisted_20$1, toDisplayString(__props.title || "Unknown"), 1),
            _cache[2] || (_cache[2] = createBaseVNode("div", { class: "us-tmdb-empty-text" }, "TMDB 未找到匹配影片", -1))
          ]))
        ]);
      };
    }
  });
  const _style_0$3 = ".us-tmdb-section{padding:20px;border-bottom:1px solid #eee;background:linear-gradient(135deg,#01b4e40a,#00d2ff0a)}.us-tmdb-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:15px;font-weight:700;color:#333}.us-tmdb-not-found-badge{background:#fff3e0;color:#e65100;padding:2px 10px;border-radius:10px;font-size:11px;font-weight:600}.us-tmdb-switcher{margin-bottom:12px}.us-tmdb-select{width:100%;padding:4px 8px;border:1px solid #ccc;border-radius:6px;font-size:12px;color:#333;background:#fff;cursor:pointer}.us-tmdb-detail{display:flex;gap:15px}.us-tmdb-poster{flex-shrink:0;width:110px}.us-tmdb-poster img{width:100%;border-radius:8px;box-shadow:0 3px 10px #00000026}.us-tmdb-no-poster{width:100%;height:160px;background:#f0f0f0;border-radius:8px;display:flex;align-items:center;justify-content:center;color:#999;font-size:12px}.us-tmdb-info{flex:1;min-width:0}.us-tmdb-title{font-size:17px;font-weight:700;color:#333;margin-bottom:6px}.us-tmdb-meta{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:10px}.us-tmdb-year-badge{background:#e3f2fd;color:#1565c0;padding:2px 8px;border-radius:4px;font-size:11px}.us-tmdb-type-badge{background:#fce4ec;color:#c62828;padding:2px 8px;border-radius:4px;font-size:11px}.us-tmdb-id-badge{background:#e8f5e9;color:#2e7d32;padding:2px 8px;border-radius:4px;font-size:11px;font-family:monospace}.us-tmdb-overview{font-size:13px;color:#555;line-height:1.5;max-height:100px;overflow-y:auto;margin-bottom:10px}.us-tmdb-links{margin-top:8px}.us-tmdb-pagination{text-align:center;font-size:11px;color:#999;margin-top:12px;padding-top:8px;border-top:1px dashed #eee}.us-tmdb-empty{text-align:center;padding:20px 0}.us-tmdb-empty-title{font-size:18px;font-weight:700;color:#333;margin-bottom:8px}.us-tmdb-empty-text{font-size:13px;color:#999}.us-btn{display:inline-block;padding:4px 8px;border-radius:6px;text-decoration:none;font-size:14px;font-weight:500;cursor:pointer;border:none;transition:background .2s}.us-btn-tmdb{background:linear-gradient(135deg,#01b4e4,#00d2ff);color:#fff;padding:6px 14px;font-size:12px}.us-btn-tmdb:hover{opacity:.9}";
  const TmdbCard = _export_sfc(_sfc_main$3, [["styles", [_style_0$3]]]);
  class NullbrService extends ApiClient {
    constructor() {
      super("Nullbr");
    }
    isConfigured() {
      return !!(CONFIG.nullbr.appId && CONFIG.nullbr.apiKey);
    }
    async get115Resources(tmdbId, mediaType) {
      if (!this.isConfigured()) {
        return {
          data: [],
          meta: { error: "Nullbr API not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      const cacheKey = this.buildCacheKey("115", mediaType, tmdbId);
      const url = `${CONFIG.nullbr.baseUrl}/${mediaType}/${tmdbId}/115`;
      return this.request({
        requestFn: async () => {
          const response = await GM.xmlHttpRequest({
            method: "GET",
            url,
            responseType: "json",
            headers: this.getHeaders()
          });
          if (response.status === 200) {
            const data = JSON.parse(response.responseText);
            return data["115"] || [];
          } else if (response.status === 404) {
            return [];
          } else {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
          }
        },
        cacheKey,
        cacheTTL: CONFIG.nullbr.cacheTTL,
        useCache: true,
        useQueue: true
      });
    }
    async getMagnetResources(tmdbId, mediaType, seasonNumber) {
      if (!this.isConfigured()) {
        return {
          data: [],
          meta: { error: "Nullbr API not configured", source: this.name, timestamp: ( new Date()).toISOString() }
        };
      }
      let url;
      let cacheKey;
      if (mediaType === "movie") {
        url = `${CONFIG.nullbr.baseUrl}/movie/${tmdbId}/magnet`;
        cacheKey = this.buildCacheKey("magnet", "movie", tmdbId);
      } else {
        const season = seasonNumber || 1;
        url = `${CONFIG.nullbr.baseUrl}/tv/${tmdbId}/season/${season}/magnet`;
        cacheKey = this.buildCacheKey("magnet", "tv", tmdbId, season);
      }
      return this.request({
        requestFn: async () => {
          const response = await GM.xmlHttpRequest({ url, headers: this.getHeaders() });
          if (response.status === 200) {
            const data = JSON.parse(response.responseText);
            return data.magnet || [];
          } else if (response.status === 404) {
            return [];
          } else {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
          }
        },
        cacheKey,
        cacheTTL: CONFIG.nullbr.cacheTTL,
        useCache: true,
        useQueue: true
      });
    }
    async getAllResources(tmdbId, mediaType) {
      const enable115 = CONFIG.nullbr.enable115 !== false;
      const enableMagnet = CONFIG.nullbr.enableMagnet === true;
      if (!enable115 && !enableMagnet) {
        return { items115: [], magnets: [], hasData: false };
      }
      const promises = [
        enable115 ? this.get115Resources(tmdbId, mediaType) : Promise.resolve({ data: [], meta: { source: this.name, timestamp: ( new Date()).toISOString() } }),
        enableMagnet ? this.getMagnetResources(tmdbId, mediaType) : Promise.resolve({ data: [], meta: { source: this.name, timestamp: ( new Date()).toISOString() } })
      ];
      const [res115, resMagnet] = await Promise.all(promises);
      const items115 = res115.data || [];
      const magnets = resMagnet.data || [];
      return {
        items115,
        magnets,
        hasData: items115.length > 0 || magnets.length > 0
      };
    }
    determineTTL(data, defaultTTL) {
      if (data && (Array.isArray(data) ? data.length > 0 : Object.keys(data).length > 0)) {
        return defaultTTL;
      }
      return 1440;
    }
    getHeaders() {
      return {
        "X-APP-ID": CONFIG.nullbr.appId || "",
        "X-API-KEY": CONFIG.nullbr.apiKey || "",
        "User-Agent": CONFIG.nullbr.userAgent || ""
      };
    }
  }
  const nullbrService = new NullbrService();
  const _hoisted_1$2 = {
    key: 0,
    class: "us-nullbr-section"
  };
  const _hoisted_2$2 = {
    key: 0,
    class: "us-nullbr-loading"
  };
  const _hoisted_3$2 = {
    key: 1,
    class: "us-nullbr-empty"
  };
  const _hoisted_4$2 = {
    key: 2,
    class: "us-nullbr-empty"
  };
  const _hoisted_5$2 = { key: 3 };
  const _hoisted_6$1 = {
    key: 0,
    style: { "margin-bottom": "12px" }
  };
  const _hoisted_7$1 = { class: "us-section-label" };
  const _hoisted_8$1 = { class: "us-resource-list" };
  const _hoisted_9$1 = { class: "us-resource-info" };
  const _hoisted_10$1 = ["title"];
  const _hoisted_11$1 = { class: "us-resource-meta" };
  const _hoisted_12$1 = {
    key: 0,
    class: "us-resource-tag"
  };
  const _hoisted_13$1 = {
    key: 1,
    class: "us-resource-tag"
  };
  const _hoisted_14$1 = {
    key: 2,
    class: "us-resource-tag"
  };
  const _hoisted_15$1 = { class: "us-resource-actions" };
  const _hoisted_16 = ["href"];
  const _hoisted_17 = { key: 1 };
  const _hoisted_18 = { class: "us-section-label" };
  const _hoisted_19 = { class: "us-resource-list" };
  const _hoisted_20 = { class: "us-resource-info" };
  const _hoisted_21 = ["title"];
  const _hoisted_22 = { class: "us-resource-meta" };
  const _hoisted_23 = {
    key: 0,
    class: "us-resource-tag"
  };
  const _hoisted_24 = {
    key: 1,
    class: "us-resource-tag"
  };
  const _hoisted_25 = {
    key: 2,
    class: "us-resource-tag zh-sub"
  };
  const _hoisted_26 = { class: "us-resource-actions" };
  const _hoisted_27 = ["href"];
  const _hoisted_28 = ["onClick"];
  const _hoisted_29 = {
    key: 1,
    class: "us-actions"
  };
  const _hoisted_30 = {
    key: 0,
    class: "us-status-text"
  };
  const _hoisted_31 = { class: "us-actions-links" };
  const _hoisted_32 = ["href"];
  const _hoisted_33 = ["href"];
  const _hoisted_34 = ["href"];
  const _sfc_main$2 = defineComponent({
    __name: "ResourceCard.ce",
    props: {
      tmdbInfo: { type: [Object, null] },
      searchQueries: { type: Array }
    },
    setup(__props) {
      const props = __props;
      const nullbrLoading = ref(true);
      const nullbrItems115 = ref([]);
      const nullbrMagnets = ref([]);
      const nullbrError = ref(false);
      const uniqueQueries = computed(() => {
        if (!props.searchQueries) return [];
        return [...new Set(props.searchQueries.filter((q) => q == null ? void 0 : q.trim()))];
      });
      async function copyMagnet(magnet, event) {
        const btn = event.target;
        try {
          await navigator.clipboard.writeText(magnet);
          btn.textContent = "已复制";
          setTimeout(() => {
            btn.textContent = "复制";
          }, 1500);
        } catch {
          GM_setClipboard(magnet);
          btn.textContent = "已复制";
          setTimeout(() => {
            btn.textContent = "复制";
          }, 1500);
        }
      }
      async function loadNullbrResources() {
        if (!props.tmdbInfo) {
          nullbrLoading.value = false;
          return;
        }
        try {
          const resources = await nullbrService.getAllResources(props.tmdbInfo.id, props.tmdbInfo.mediaType);
          nullbrItems115.value = resources.items115;
          nullbrMagnets.value = resources.magnets;
        } catch {
          nullbrError.value = true;
        } finally {
          nullbrLoading.value = false;
        }
      }
      loadNullbrResources();
      return (_ctx, _cache) => {
        return openBlock(), createElementBlock(Fragment, null, [
          __props.tmdbInfo ? (openBlock(), createElementBlock("div", _hoisted_1$2, [
            _cache[0] || (_cache[0] = createBaseVNode("div", { class: "us-nullbr-header" }, [
              createBaseVNode("span", null, "🔗 网盘 & 磁力资源"),
              createBaseVNode("span", { class: "us-nullbr-badge" }, "Nullbr")
            ], -1)),
            nullbrLoading.value ? (openBlock(), createElementBlock("div", _hoisted_2$2, "正在搜索资源...")) : nullbrError.value ? (openBlock(), createElementBlock("div", _hoisted_3$2, "加载资源失败")) : !nullbrItems115.value.length && !nullbrMagnets.value.length ? (openBlock(), createElementBlock("div", _hoisted_4$2, " 暂无可用资源 ")) : (openBlock(), createElementBlock("div", _hoisted_5$2, [
              nullbrItems115.value.length ? (openBlock(), createElementBlock("div", _hoisted_6$1, [
                createBaseVNode("div", _hoisted_7$1, "📁 115 网盘分享 (" + toDisplayString(nullbrItems115.value.length) + ")", 1),
                createBaseVNode("div", _hoisted_8$1, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(nullbrItems115.value.slice(0, 5), (item) => {
                    return openBlock(), createElementBlock("div", {
                      key: item.share_link,
                      class: "us-resource-item"
                    }, [
                      createBaseVNode("div", _hoisted_9$1, [
                        createBaseVNode("div", {
                          class: "us-resource-title",
                          title: item.title
                        }, toDisplayString(item.title), 9, _hoisted_10$1),
                        createBaseVNode("div", _hoisted_11$1, [
                          createBaseVNode("span", null, toDisplayString(item.size), 1),
                          item.resolution ? (openBlock(), createElementBlock("span", _hoisted_12$1, toDisplayString(item.resolution), 1)) : createCommentVNode("", true),
                          item.quality ? (openBlock(), createElementBlock("span", _hoisted_13$1, toDisplayString(item.quality), 1)) : createCommentVNode("", true),
                          item.season_list ? (openBlock(), createElementBlock("span", _hoisted_14$1, toDisplayString(item.season_list.join(", ")), 1)) : createCommentVNode("", true)
                        ])
                      ]),
                      createBaseVNode("div", _hoisted_15$1, [
                        createBaseVNode("a", {
                          href: item.share_link,
                          target: "_blank",
                          class: "us-resource-btn primary"
                        }, "打开链接", 8, _hoisted_16)
                      ])
                    ]);
                  }), 128))
                ])
              ])) : createCommentVNode("", true),
              nullbrMagnets.value.length ? (openBlock(), createElementBlock("div", _hoisted_17, [
                createBaseVNode("div", _hoisted_18, "🧲 磁力链接 (" + toDisplayString(nullbrMagnets.value.length) + ")", 1),
                createBaseVNode("div", _hoisted_19, [
                  (openBlock(true), createElementBlock(Fragment, null, renderList(nullbrMagnets.value.slice(0, 5), (item) => {
                    return openBlock(), createElementBlock("div", {
                      key: item.magnet,
                      class: "us-resource-item"
                    }, [
                      createBaseVNode("div", _hoisted_20, [
                        createBaseVNode("div", {
                          class: "us-resource-title",
                          title: item.name
                        }, toDisplayString(item.name), 9, _hoisted_21),
                        createBaseVNode("div", _hoisted_22, [
                          createBaseVNode("span", null, toDisplayString(item.size), 1),
                          item.resolution ? (openBlock(), createElementBlock("span", _hoisted_23, toDisplayString(item.resolution), 1)) : createCommentVNode("", true),
                          item.source ? (openBlock(), createElementBlock("span", _hoisted_24, toDisplayString(item.source), 1)) : createCommentVNode("", true),
                          item.zh_sub ? (openBlock(), createElementBlock("span", _hoisted_25, "中字")) : createCommentVNode("", true)
                        ])
                      ]),
                      createBaseVNode("div", _hoisted_26, [
                        createBaseVNode("a", {
                          href: item.magnet,
                          class: "us-resource-btn primary",
                          style: { "text-decoration": "none" }
                        }, "打开", 8, _hoisted_27),
                        createBaseVNode("button", {
                          class: "us-resource-btn secondary",
                          onClick: ($event) => copyMagnet(item.magnet, $event)
                        }, "复制", 8, _hoisted_28)
                      ])
                    ]);
                  }), 128))
                ])
              ])) : createCommentVNode("", true)
            ]))
          ])) : createCommentVNode("", true),
          uniqueQueries.value.length ? (openBlock(), createElementBlock("div", _hoisted_29, [
            !__props.tmdbInfo ? (openBlock(), createElementBlock("div", _hoisted_30, "Not Found in Library")) : createCommentVNode("", true),
            createBaseVNode("div", _hoisted_31, [
              uniqueQueries.value[0] ? (openBlock(), createElementBlock("a", {
                key: 0,
                href: `https://www.gyg.si/s/1---1/${encodeURIComponent(uniqueQueries.value[0])}`,
                target: "_blank",
                class: "us-btn us-btn-search"
              }, "Search GYG", 8, _hoisted_32)) : createCommentVNode("", true),
              uniqueQueries.value[0] ? (openBlock(), createElementBlock("a", {
                key: 1,
                href: `https://bt4gprx.com/search?orderby=size&p=1&q=${encodeURIComponent(uniqueQueries.value[0])}`,
                target: "_blank",
                class: "us-btn us-btn-search"
              }, "Search BT4G", 8, _hoisted_33)) : createCommentVNode("", true),
              uniqueQueries.value[0] ? (openBlock(), createElementBlock("a", {
                key: 2,
                href: `https://dmhy.org/topics/list?keyword=${encodeURIComponent(uniqueQueries.value[0])}&sort_id=2&team_id=0&order=date-desc`,
                target: "_blank",
                class: "us-btn us-btn-search"
              }, "DMHY 搜全集", 8, _hoisted_34)) : createCommentVNode("", true)
            ])
          ])) : createCommentVNode("", true)
        ], 64);
      };
    }
  });
  const _style_0$2 = ".us-nullbr-section{padding:15px 20px;border-bottom:1px solid #eee;background:linear-gradient(135deg,#667eea0a,#764ba20a)}.us-nullbr-header{display:flex;align-items:center;gap:8px;margin-bottom:12px;font-weight:700;color:#333}.us-nullbr-badge{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;padding:2px 8px;border-radius:10px;font-size:11px}.us-nullbr-loading{text-align:center;color:#999;padding:20px}.us-nullbr-empty{text-align:center;color:#999;padding:15px;font-size:13px}.us-section-label{font-size:12px;font-weight:700;color:#666;margin-bottom:8px}.us-resource-list{display:flex;flex-direction:column;gap:8px;max-height:200px;overflow-y:auto}.us-resource-item{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;background:#fff;border-radius:6px;border:1px solid #e0e0e0;font-size:12px;transition:all .2s}.us-resource-item:hover{border-color:#667eea;box-shadow:0 2px 6px #667eea26}.us-resource-info{flex:1;min-width:0}.us-resource-title{font-weight:500;color:#333;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:280px}.us-resource-meta{display:flex;gap:8px;margin-top:3px;color:#888;font-size:11px}.us-resource-tag{background:#f0f0f0;padding:1px 5px;border-radius:3px}.us-resource-tag.zh-sub{background:#e8f5e9;color:#388e3c}.us-resource-actions{display:flex;gap:6px}.us-resource-btn{padding:4px 10px;border-radius:4px;border:none;cursor:pointer;font-size:11px;transition:all .2s;text-decoration:none}.us-resource-btn.primary{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff}.us-resource-btn.primary:hover{opacity:.9}.us-resource-btn.secondary{background:#f5f5f5;color:#666}.us-resource-btn.secondary:hover{background:#e0e0e0}.us-actions{padding:20px;border-bottom:1px solid #eee;text-align:center}.us-status-text{font-size:16px;font-weight:700;margin-bottom:15px;color:#9e9e9e}.us-actions-links{display:flex;gap:10px;flex-wrap:wrap}.us-btn{display:inline-block;padding:4px 8px;border-radius:6px;text-decoration:none;font-size:14px;font-weight:500;cursor:pointer;border:none;transition:background .2s}.us-btn-search{background:#eef9fd;color:#01b4e4;border:1px solid #b3e5fc}.us-btn-search:hover{background:#e1f5fe;color:#008dba}";
  const ResourceCard = _export_sfc(_sfc_main$2, [["styles", [_style_0$2]]]);
  const _hoisted_1$1 = { class: "us-modal" };
  const _hoisted_2$1 = { class: "us-modal-header" };
  const _hoisted_3$1 = { class: "us-modal-title" };
  const _hoisted_4$1 = { class: "us-modal-body" };
  const _hoisted_5$1 = { class: "us-modal-footer" };
  const _sfc_main$1 = defineComponent({
    __name: "InfoCard.ce",
    props: {
      title: { type: String },
      embyItem: { type: [Object, null] },
      embyItems: { type: Array },
      searchQueries: { type: Array },
      tmdbInfo: { type: Object },
      tmdbResults: { type: Array },
      visible: { type: Boolean }
    },
    emits: ["close"],
    setup(__props, { emit: __emit }) {
      const props = __props;
      const emit2 = __emit;
      const hasEmby = computed(() => {
        var _a;
        return !!(((_a = props.embyItems) == null ? void 0 : _a.length) || props.embyItem);
      });
      const firstEmbyItem = computed(() => {
        var _a;
        return ((_a = props.embyItems) == null ? void 0 : _a[0]) || props.embyItem || null;
      });
      const effectiveTmdbInfo = computed(() => {
        var _a;
        if (props.tmdbInfo) return props.tmdbInfo;
        if ((_a = props.tmdbResults) == null ? void 0 : _a.length) {
          const first = props.tmdbResults[0];
          return { id: first.id, mediaType: first.mediaType };
        }
        const emby = firstEmbyItem.value;
        if (emby) {
          const providerIds = emby.ProviderIds;
          const tmdbId = (providerIds == null ? void 0 : providerIds.Tmdb) || (providerIds == null ? void 0 : providerIds.tmdb);
          if (tmdbId) {
            const mediaType = emby.Type === "Series" ? "tv" : "movie";
            return { id: Number(tmdbId), mediaType };
          }
        }
        return null;
      });
      function onOverlayClick(e) {
        if (e.target.classList.contains("us-modal-overlay")) {
          emit2("close");
        }
      }
      return (_ctx, _cache) => {
        return __props.visible ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: "us-modal-overlay",
          onClick: onOverlayClick
        }, [
          createBaseVNode("div", _hoisted_1$1, [
            createBaseVNode("div", _hoisted_2$1, [
              createBaseVNode("div", _hoisted_3$1, toDisplayString(__props.title), 1),
              createBaseVNode("div", {
                class: "us-modal-close",
                onClick: _cache[0] || (_cache[0] = ($event) => emit2("close"))
              }, "×")
            ]),
            createBaseVNode("div", _hoisted_4$1, [
              firstEmbyItem.value ? (openBlock(), createBlock(EmbyCard, {
                key: 0,
                item: firstEmbyItem.value,
                items: __props.embyItems
              }, null, 8, ["item", "items"])) : createCommentVNode("", true),
              !hasEmby.value ? (openBlock(), createBlock(TmdbCard, {
                key: 1,
                results: __props.tmdbResults || [],
                title: __props.title
              }, null, 8, ["results", "title"])) : createCommentVNode("", true),
              createVNode(ResourceCard, {
                "tmdb-info": effectiveTmdbInfo.value,
                "search-queries": __props.searchQueries
              }, null, 8, ["tmdb-info", "search-queries"])
            ]),
            createBaseVNode("div", _hoisted_5$1, [
              createBaseVNode("button", {
                class: "us-btn us-btn-outline",
                onClick: _cache[1] || (_cache[1] = ($event) => emit2("close"))
              }, "Close")
            ])
          ])
        ])) : createCommentVNode("", true);
      };
    }
  });
  const _style_0$1 = ":host{position:fixed;top:0;left:0;width:100%;height:100%;z-index:10000;pointer-events:none}:host([visible]){pointer-events:auto}*{box-sizing:border-box}.us-modal-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:#0009;z-index:10000;display:flex;justify-content:center;align-items:center;-webkit-backdrop-filter:blur(2px);backdrop-filter:blur(2px);pointer-events:auto}.us-modal{background:#fff;width:500px;max-width:90%;max-height:85vh;border-radius:12px;display:flex;flex-direction:column;box-shadow:0 10px 25px #0000004d;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;overflow:hidden}.us-modal-header{padding:15px 20px;border-bottom:1px solid #eee;display:flex;justify-content:space-between;align-items:center;background:#f8f9fa}.us-modal-title{font-weight:700;font-size:16px;color:#333}.us-modal-close{cursor:pointer;font-size:20px;color:#999;line-height:1}.us-modal-close:hover{color:#333}.us-modal-body{flex:1;overflow-y:auto;padding:0}.us-modal-footer{padding:15px;background:#f8f9fa;text-align:right;border-top:1px solid #eee}.us-btn{display:inline-block;padding:4px 8px;border-radius:6px;text-decoration:none;font-size:14px;font-weight:500;cursor:pointer;border:none;transition:background .2s}.us-btn-outline{background:#fff;color:#333;border:1px solid #ddd}.us-btn-outline:hover{background:#f5f5f5}";
  const InfoCardCE = _export_sfc(_sfc_main$1, [["styles", [_style_0$1]]]);
  const _hoisted_1 = { class: "us-settings-modal" };
  const _hoisted_2 = { class: "us-settings-row" };
  const _hoisted_3 = { class: "us-settings-row" };
  const _hoisted_4 = { class: "us-settings-row" };
  const _hoisted_5 = { class: "us-settings-row" };
  const _hoisted_6 = { class: "us-settings-row" };
  const _hoisted_7 = { class: "us-checkbox-group" };
  const _hoisted_8 = { class: "us-checkbox-label" };
  const _hoisted_9 = { class: "us-checkbox-label" };
  const _hoisted_10 = { class: "us-settings-actions" };
  const _hoisted_11 = { class: "us-cache-info" };
  const _hoisted_12 = {
    key: 0,
    class: "us-cache-stats"
  };
  const _hoisted_13 = { class: "us-cache-key" };
  const _hoisted_14 = {
    key: 0,
    class: "us-cache-more"
  };
  const _hoisted_15 = { class: "us-settings-actions" };
  const _sfc_main = defineComponent({
    __name: "Settings.ce",
    props: {
      visible: { type: Boolean },
      mode: { type: String }
    },
    emits: ["close"],
    setup(__props, { emit: __emit }) {
      const emit2 = __emit;
      const tmdbApiKey = ref("");
      const embyServer = ref("");
      const embyApiKey = ref("");
      const bangumiToken = ref("");
      const nullbrEnable115 = ref(true);
      const nullbrEnableMagnet = ref(false);
      const saved = ref(false);
      const cacheKeys = ref([]);
      const cacheCount = computed(() => cacheKeys.value.length);
      onMounted(() => {
        tmdbApiKey.value = CONFIG.tmdb.apiKey || "";
        embyServer.value = CONFIG.emby.server || "";
        embyApiKey.value = CONFIG.emby.apiKey || "";
        bangumiToken.value = CONFIG.bangumi.apiKey || "";
        nullbrEnable115.value = CONFIG.nullbr.enable115 !== false;
        nullbrEnableMagnet.value = CONFIG.nullbr.enableMagnet === true;
        refreshCacheKeys();
      });
      function refreshCacheKeys() {
        cacheKeys.value = cache.listKeys();
      }
      function saveSettings() {
        configService.update("tmdb", { apiKey: tmdbApiKey.value });
        configService.update("emby", { server: embyServer.value, apiKey: embyApiKey.value });
        configService.update("bangumi", { apiKey: bangumiToken.value });
        configService.update("nullbr", { enable115: nullbrEnable115.value, enableMagnet: nullbrEnableMagnet.value });
        saved.value = true;
        setTimeout(() => {
          saved.value = false;
        }, 2e3);
      }
      function clearCache(filter) {
        if (filter) {
          cache.clear([filter]);
        } else {
          cache.clear();
        }
        refreshCacheKeys();
      }
      function onOverlayClick(e) {
        if (e.target.classList.contains("us-settings-overlay")) {
          emit2("close");
        }
      }
      return (_ctx, _cache) => {
        return __props.visible ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: "us-settings-overlay",
          onClick: onOverlayClick
        }, [
          createBaseVNode("div", _hoisted_1, [
            __props.mode === "settings" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
              _cache[18] || (_cache[18] = createBaseVNode("h3", { class: "us-settings-title" }, "脚本设置 / Settings", -1)),
              createBaseVNode("div", _hoisted_2, [
                _cache[11] || (_cache[11] = createBaseVNode("label", { class: "us-settings-label" }, "TMDB API Key", -1)),
                withDirectives(createBaseVNode("input", {
                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => tmdbApiKey.value = $event),
                  class: "us-settings-input",
                  type: "text",
                  placeholder: "Enter TMDB API Key"
                }, null, 512), [
                  [vModelText, tmdbApiKey.value]
                ])
              ]),
              createBaseVNode("div", _hoisted_3, [
                _cache[12] || (_cache[12] = createBaseVNode("label", { class: "us-settings-label" }, "Emby Server URL", -1)),
                withDirectives(createBaseVNode("input", {
                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => embyServer.value = $event),
                  class: "us-settings-input",
                  type: "text",
                  placeholder: "http://your-emby-server:8096"
                }, null, 512), [
                  [vModelText, embyServer.value]
                ])
              ]),
              createBaseVNode("div", _hoisted_4, [
                _cache[13] || (_cache[13] = createBaseVNode("label", { class: "us-settings-label" }, "Emby API Key", -1)),
                withDirectives(createBaseVNode("input", {
                  "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => embyApiKey.value = $event),
                  class: "us-settings-input",
                  type: "text",
                  placeholder: "Enter Emby API Key"
                }, null, 512), [
                  [vModelText, embyApiKey.value]
                ])
              ]),
              createBaseVNode("div", _hoisted_5, [
                _cache[14] || (_cache[14] = createBaseVNode("label", { class: "us-settings-label" }, "Bangumi Token", -1)),
                withDirectives(createBaseVNode("input", {
                  "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => bangumiToken.value = $event),
                  class: "us-settings-input",
                  type: "text",
                  placeholder: "Enter Bangumi Token"
                }, null, 512), [
                  [vModelText, bangumiToken.value]
                ])
              ]),
              createBaseVNode("div", _hoisted_6, [
                _cache[17] || (_cache[17] = createBaseVNode("label", { class: "us-settings-label" }, "Nullbr 资源搜索 / Resource Search", -1)),
                createBaseVNode("div", _hoisted_7, [
                  createBaseVNode("label", _hoisted_8, [
                    withDirectives(createBaseVNode("input", {
                      "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => nullbrEnable115.value = $event),
                      type: "checkbox",
                      class: "us-checkbox"
                    }, null, 512), [
                      [vModelCheckbox, nullbrEnable115.value]
                    ]),
                    _cache[15] || (_cache[15] = createBaseVNode("span", null, "115 网盘资源搜索", -1))
                  ]),
                  createBaseVNode("label", _hoisted_9, [
                    withDirectives(createBaseVNode("input", {
                      "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => nullbrEnableMagnet.value = $event),
                      type: "checkbox",
                      class: "us-checkbox"
                    }, null, 512), [
                      [vModelCheckbox, nullbrEnableMagnet.value]
                    ]),
                    _cache[16] || (_cache[16] = createBaseVNode("span", null, "磁链资源搜索", -1))
                  ])
                ])
              ]),
              createBaseVNode("div", _hoisted_10, [
                createBaseVNode("button", {
                  class: "us-button us-button-secondary",
                  onClick: _cache[6] || (_cache[6] = ($event) => emit2("close"))
                }, "取消 / Cancel"),
                createBaseVNode("button", {
                  class: "us-button us-button-primary",
                  onClick: saveSettings
                }, toDisplayString(saved.value ? "✓ 已保存" : "保存 / Save"), 1)
              ])
            ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
              _cache[19] || (_cache[19] = createBaseVNode("h3", { class: "us-settings-title" }, "缓存管理 / Cache", -1)),
              createBaseVNode("div", _hoisted_11, [
                createBaseVNode("span", null, "当前缓存数量: " + toDisplayString(cacheCount.value), 1)
              ]),
              cacheCount.value > 0 ? (openBlock(), createElementBlock("div", _hoisted_12, [
                (openBlock(true), createElementBlock(Fragment, null, renderList(cacheKeys.value.slice(0, 20), (key) => {
                  return openBlock(), createElementBlock("div", {
                    class: "us-cache-stat-row",
                    key
                  }, [
                    createBaseVNode("span", _hoisted_13, toDisplayString(key), 1)
                  ]);
                }), 128)),
                cacheKeys.value.length > 20 ? (openBlock(), createElementBlock("div", _hoisted_14, " ... and " + toDisplayString(cacheKeys.value.length - 20) + " more ", 1)) : createCommentVNode("", true)
              ])) : createCommentVNode("", true),
              createBaseVNode("div", _hoisted_15, [
                createBaseVNode("button", {
                  class: "us-button us-button-secondary",
                  onClick: _cache[7] || (_cache[7] = ($event) => emit2("close"))
                }, "关闭 / Close"),
                createBaseVNode("button", {
                  class: "us-button us-button-danger",
                  onClick: _cache[8] || (_cache[8] = ($event) => clearCache("tmdb"))
                }, "清除 TMDB"),
                createBaseVNode("button", {
                  class: "us-button us-button-danger",
                  onClick: _cache[9] || (_cache[9] = ($event) => clearCache("emby"))
                }, "清除 Emby"),
                createBaseVNode("button", {
                  class: "us-button us-button-danger",
                  onClick: _cache[10] || (_cache[10] = ($event) => clearCache())
                }, "清除全部")
              ])
            ], 64))
          ])
        ])) : createCommentVNode("", true);
      };
    }
  });
  const _style_0 = ":host{position:fixed;top:0;left:0;width:100%;height:100%;z-index:9999;pointer-events:none}:host([visible]){pointer-events:auto}*{box-sizing:border-box}.us-settings-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:#00000080;z-index:9999;display:flex;justify-content:center;align-items:center;pointer-events:auto}.us-settings-modal{background:#fff;padding:20px;border-radius:8px;width:400px;max-width:90%;box-shadow:0 4px 12px #00000026;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif}.us-settings-title{margin-top:0;margin-bottom:20px;font-size:18px;color:#333}.us-settings-row{margin-bottom:15px}.us-settings-label{display:block;font-weight:700;margin-bottom:5px;color:#333;font-size:13px}.us-settings-input{width:100%;padding:8px;border:1px solid #ccc;border-radius:4px;box-sizing:border-box;font-size:13px;font-family:inherit}.us-settings-input:focus{outline:none;border-color:#01b4e4;box-shadow:0 0 0 2px #01b4e433}.us-settings-actions{display:flex;justify-content:flex-end;gap:10px;margin-top:20px}.us-button{padding:8px 16px;border-radius:4px;cursor:pointer;border:none;font-weight:700;font-size:13px;transition:opacity .2s}.us-button:hover{opacity:.85}.us-button-primary{background:#01b4e4;color:#fff}.us-button-secondary{background:#eee;color:#333}.us-button-danger{background:#dc3545;color:#fff}.us-cache-info{font-size:14px;color:#666;margin-bottom:12px;padding:10px;background:#f8f9fa;border-radius:4px}.us-cache-stats{max-height:200px;overflow-y:auto;border:1px solid #eee;border-radius:4px;margin-bottom:12px}.us-cache-stat-row{padding:6px 10px;border-bottom:1px solid #f0f0f0;font-size:12px}.us-cache-stat-row:last-child{border-bottom:none}.us-cache-key{font-family:monospace;color:#555;word-break:break-all}.us-cache-more{padding:8px 10px;color:#999;font-size:12px;text-align:center}.us-checkbox-group{display:flex;flex-direction:column;gap:8px}.us-checkbox-label{display:flex;align-items:center;gap:8px;font-size:13px;color:#333;cursor:pointer;-webkit-user-select:none;user-select:none}.us-checkbox{width:16px;height:16px;cursor:pointer;accent-color:#01b4e4}";
  const SettingsCE = _export_sfc(_sfc_main, [["styles", [_style_0]]]);
  const StatusDotElement = defineCustomElement(StatusDotCE);
  const InfoCardElement = defineCustomElement(InfoCardCE);
  const SettingsElement = defineCustomElement(SettingsCE);
  customElements.define("us-status-dot", StatusDotElement);
  customElements.define("us-info-card", InfoCardElement);
  customElements.define("us-settings", SettingsElement);
  GM.addStyle(`
  .tmdb-wrapper { animation: fadeIn 0.5s ease; display: flex; flex-direction: column; gap: 10px; }
  .gyg-card { display: flex; flex-direction: column; padding: 10px; background: white; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 1px 4px rgba(0,0,0,0.05); transition: all 0.2s; }
  .tmdb-header-row { display: flex; justify-content: space-between; align-items: center; cursor: pointer; }
  .tmdb-source { font-size: 12px; color: #888; font-weight: bold; }
  .tmdb-score { font-size: 20px; font-weight: bold; color: #01b4e4; }
  .tmdb-copy-area { margin-top: 8px; padding-top: 8px; border-top: 1px dashed #ddd; font-size: 13px; color: #555; cursor: copy; position: relative; transition: color 0.2s; display: flex; align-items: center; justify-content: space-between; }
  .tmdb-copy-area:hover { color: #01b4e4; }
  .emby-card { display: flex; flex-direction: row; justify-content: space-between; align-items: center; cursor: pointer; }
  .emby-card:hover { background: rgba(0,0,0,0.02); }
  .emby-label { font-size: 13px; font-weight: bold; color: #333; }
  .emby-badge { padding: 2px 8px; border-radius: 4px; color: white; font-weight: bold; font-size: 11px; }
  .emby-yes { background-color: #52B54B; }
  .emby-no { background-color: #999; }
  .emby-loading { background-color: #ddd; color: #666; }
  .douban-aside-box { margin-bottom: 30px; }
  @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
`);
  const configs = [
    doubanConfig,
    gygConfig,
    dmhyConfig
  ];
  (function() {
    GM_registerMenuCommand("设置 / Settings", () => {
      showSettings("settings");
    });
    GM_registerMenuCommand("清除缓存 / Clear Cache", () => {
      showSettings("cache");
    });
    const url = location.href;
    for (const config of configs) {
      if (config.match(url)) {
        adapterEngine.run(config);
        break;
      }
    }
  })();
  function showSettings(mode) {
    const existing = document.querySelector("us-settings");
    if (existing) existing.remove();
    const settings = document.createElement("us-settings");
    settings.setAttribute("visible", "true");
    settings.setAttribute("mode", mode);
    settings.addEventListener("close", () => {
      settings.remove();
    });
    document.body.appendChild(settings);
  }

})();