vitepress___@vue_devtools-api.js - bsc - Comprehensive codebase and cou...

vitepress___@vue_devtools-api.js (117872B)
      1 // node_modules/@vue/devtools-shared/dist/index.js
      2 var __create = Object.create;
      3 var __defProp = Object.defineProperty;
      4 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
      5 var __getOwnPropNames = Object.getOwnPropertyNames;
      6 var __getProtoOf = Object.getPrototypeOf;
      7 var __hasOwnProp = Object.prototype.hasOwnProperty;
      8 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
      9 var __copyProps = (to, from, except, desc) => {
     10   if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
     11     key = keys[i];
     12     if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
     13       get: ((k) => from[k]).bind(null, key),
     14       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     15     });
     16   }
     17   return to;
     18 };
     19 var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", {
     20   value: mod,
     21   enumerable: true
     22 }) : target2, mod));
     23 var isBrowser = typeof navigator !== "undefined";
     24 var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
     25 var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
     26 var isInIframe = isBrowser && target.self !== target.top;
     27 var isInElectron = typeof navigator !== "undefined" && navigator.userAgent?.toLowerCase().includes("electron");
     28 var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
     29 var import_rfdc = __toESM(__commonJSMin(((exports, module) => {
     30   module.exports = rfdc;
     31   function copyBuffer(cur) {
     32     if (cur instanceof Buffer) return Buffer.from(cur);
     33     return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
     34   }
     35   function rfdc(opts) {
     36     opts = opts || {};
     37     if (opts.circles) return rfdcCircles(opts);
     38     const constructorHandlers = /* @__PURE__ */ new Map();
     39     constructorHandlers.set(Date, (o) => new Date(o));
     40     constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
     41     constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
     42     if (opts.constructorHandlers) for (const handler2 of opts.constructorHandlers) constructorHandlers.set(handler2[0], handler2[1]);
     43     let handler = null;
     44     return opts.proto ? cloneProto : clone;
     45     function cloneArray(a, fn) {
     46       const keys = Object.keys(a);
     47       const a2 = new Array(keys.length);
     48       for (let i = 0; i < keys.length; i++) {
     49         const k = keys[i];
     50         const cur = a[k];
     51         if (typeof cur !== "object" || cur === null) a2[k] = cur;
     52         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
     53         else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
     54         else a2[k] = fn(cur);
     55       }
     56       return a2;
     57     }
     58     function clone(o) {
     59       if (typeof o !== "object" || o === null) return o;
     60       if (Array.isArray(o)) return cloneArray(o, clone);
     61       if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
     62       const o2 = {};
     63       for (const k in o) {
     64         if (Object.hasOwnProperty.call(o, k) === false) continue;
     65         const cur = o[k];
     66         if (typeof cur !== "object" || cur === null) o2[k] = cur;
     67         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
     68         else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
     69         else o2[k] = clone(cur);
     70       }
     71       return o2;
     72     }
     73     function cloneProto(o) {
     74       if (typeof o !== "object" || o === null) return o;
     75       if (Array.isArray(o)) return cloneArray(o, cloneProto);
     76       if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
     77       const o2 = {};
     78       for (const k in o) {
     79         const cur = o[k];
     80         if (typeof cur !== "object" || cur === null) o2[k] = cur;
     81         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
     82         else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
     83         else o2[k] = cloneProto(cur);
     84       }
     85       return o2;
     86     }
     87   }
     88   function rfdcCircles(opts) {
     89     const refs = [];
     90     const refsNew = [];
     91     const constructorHandlers = /* @__PURE__ */ new Map();
     92     constructorHandlers.set(Date, (o) => new Date(o));
     93     constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
     94     constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
     95     if (opts.constructorHandlers) for (const handler2 of opts.constructorHandlers) constructorHandlers.set(handler2[0], handler2[1]);
     96     let handler = null;
     97     return opts.proto ? cloneProto : clone;
     98     function cloneArray(a, fn) {
     99       const keys = Object.keys(a);
    100       const a2 = new Array(keys.length);
    101       for (let i = 0; i < keys.length; i++) {
    102         const k = keys[i];
    103         const cur = a[k];
    104         if (typeof cur !== "object" || cur === null) a2[k] = cur;
    105         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
    106         else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
    107         else {
    108           const index = refs.indexOf(cur);
    109           if (index !== -1) a2[k] = refsNew[index];
    110           else a2[k] = fn(cur);
    111         }
    112       }
    113       return a2;
    114     }
    115     function clone(o) {
    116       if (typeof o !== "object" || o === null) return o;
    117       if (Array.isArray(o)) return cloneArray(o, clone);
    118       if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
    119       const o2 = {};
    120       refs.push(o);
    121       refsNew.push(o2);
    122       for (const k in o) {
    123         if (Object.hasOwnProperty.call(o, k) === false) continue;
    124         const cur = o[k];
    125         if (typeof cur !== "object" || cur === null) o2[k] = cur;
    126         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
    127         else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
    128         else {
    129           const i = refs.indexOf(cur);
    130           if (i !== -1) o2[k] = refsNew[i];
    131           else o2[k] = clone(cur);
    132         }
    133       }
    134       refs.pop();
    135       refsNew.pop();
    136       return o2;
    137     }
    138     function cloneProto(o) {
    139       if (typeof o !== "object" || o === null) return o;
    140       if (Array.isArray(o)) return cloneArray(o, cloneProto);
    141       if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
    142       const o2 = {};
    143       refs.push(o);
    144       refsNew.push(o2);
    145       for (const k in o) {
    146         const cur = o[k];
    147         if (typeof cur !== "object" || cur === null) o2[k] = cur;
    148         else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
    149         else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
    150         else {
    151           const i = refs.indexOf(cur);
    152           if (i !== -1) o2[k] = refsNew[i];
    153           else o2[k] = cloneProto(cur);
    154         }
    155       }
    156       refs.pop();
    157       refsNew.pop();
    158       return o2;
    159     }
    160   }
    161 }))(), 1);
    162 var classifyRE = /(?:^|[-_/])(\w)/g;
    163 function toUpper(_, c) {
    164   return c ? c.toUpperCase() : "";
    165 }
    166 function classify(str) {
    167   return str && `${str}`.replace(classifyRE, toUpper);
    168 }
    169 function basename(filename, ext) {
    170   let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
    171   if (normalizedFilename.endsWith(`index${ext}`)) normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
    172   const lastSlashIndex = normalizedFilename.lastIndexOf("/");
    173   const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
    174   if (ext) {
    175     const extIndex = baseNameWithExt.lastIndexOf(ext);
    176     return baseNameWithExt.substring(0, extIndex);
    177   }
    178   return "";
    179 }
    180 var HTTP_URL_RE = /^https?:\/\//;
    181 function isUrlString(str) {
    182   return str.startsWith("/") || HTTP_URL_RE.test(str);
    183 }
    184 var deepClone = (0, import_rfdc.default)({ circles: true });
    185 
    186 // node_modules/perfect-debounce/dist/index.mjs
    187 var DEBOUNCE_DEFAULTS = { trailing: true };
    188 function debounce(fn, wait = 25, options = {}) {
    189   options = {
    190     ...DEBOUNCE_DEFAULTS,
    191     ...options
    192   };
    193   if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
    194   let leadingValue;
    195   let timeout;
    196   let resolveList = [];
    197   let currentPromise;
    198   let trailingArgs;
    199   const applyFn = (_this, args) => {
    200     currentPromise = _applyPromised(fn, _this, args);
    201     currentPromise.finally(() => {
    202       currentPromise = null;
    203       if (options.trailing && trailingArgs && !timeout) {
    204         const promise = applyFn(_this, trailingArgs);
    205         trailingArgs = null;
    206         return promise;
    207       }
    208     });
    209     return currentPromise;
    210   };
    211   const debounced = function(...args) {
    212     if (options.trailing) trailingArgs = args;
    213     if (currentPromise) return currentPromise;
    214     return new Promise((resolve) => {
    215       const shouldCallNow = !timeout && options.leading;
    216       clearTimeout(timeout);
    217       timeout = setTimeout(() => {
    218         timeout = null;
    219         const promise = options.leading ? leadingValue : applyFn(this, args);
    220         trailingArgs = null;
    221         for (const _resolve of resolveList) _resolve(promise);
    222         resolveList = [];
    223       }, wait);
    224       if (shouldCallNow) {
    225         leadingValue = applyFn(this, args);
    226         resolve(leadingValue);
    227       } else resolveList.push(resolve);
    228     });
    229   };
    230   const _clearTimeout = (timer) => {
    231     if (timer) {
    232       clearTimeout(timer);
    233       timeout = null;
    234     }
    235   };
    236   debounced.isPending = () => !!timeout;
    237   debounced.cancel = () => {
    238     _clearTimeout(timeout);
    239     resolveList = [];
    240     trailingArgs = null;
    241   };
    242   debounced.flush = () => {
    243     _clearTimeout(timeout);
    244     if (!trailingArgs || currentPromise) return;
    245     const args = trailingArgs;
    246     trailingArgs = null;
    247     return applyFn(this, args);
    248   };
    249   return debounced;
    250 }
    251 async function _applyPromised(fn, _this, args) {
    252   return await fn.apply(_this, args);
    253 }
    254 
    255 // node_modules/hookable/dist/index.mjs
    256 function flatHooks(configHooks, hooks2 = {}, parentName) {
    257   for (const key in configHooks) {
    258     const subHook = configHooks[key];
    259     const name = parentName ? `${parentName}:${key}` : key;
    260     if (typeof subHook === "object" && subHook !== null) {
    261       flatHooks(subHook, hooks2, name);
    262     } else if (typeof subHook === "function") {
    263       hooks2[name] = subHook;
    264     }
    265   }
    266   return hooks2;
    267 }
    268 var defaultTask = { run: (function_) => function_() };
    269 var _createTask = () => defaultTask;
    270 var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
    271 function serialTaskCaller(hooks2, args) {
    272   const name = args.shift();
    273   const task = createTask(name);
    274   return hooks2.reduce(
    275     (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
    276     Promise.resolve()
    277   );
    278 }
    279 function parallelTaskCaller(hooks2, args) {
    280   const name = args.shift();
    281   const task = createTask(name);
    282   return Promise.all(hooks2.map((hook2) => task.run(() => hook2(...args))));
    283 }
    284 function callEachWith(callbacks, arg0) {
    285   for (const callback of [...callbacks]) {
    286     callback(arg0);
    287   }
    288 }
    289 var Hookable = class {
    290   constructor() {
    291     this._hooks = {};
    292     this._before = void 0;
    293     this._after = void 0;
    294     this._deprecatedMessages = void 0;
    295     this._deprecatedHooks = {};
    296     this.hook = this.hook.bind(this);
    297     this.callHook = this.callHook.bind(this);
    298     this.callHookWith = this.callHookWith.bind(this);
    299   }
    300   hook(name, function_, options = {}) {
    301     if (!name || typeof function_ !== "function") {
    302       return () => {
    303       };
    304     }
    305     const originalName = name;
    306     let dep;
    307     while (this._deprecatedHooks[name]) {
    308       dep = this._deprecatedHooks[name];
    309       name = dep.to;
    310     }
    311     if (dep && !options.allowDeprecated) {
    312       let message = dep.message;
    313       if (!message) {
    314         message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
    315       }
    316       if (!this._deprecatedMessages) {
    317         this._deprecatedMessages = /* @__PURE__ */ new Set();
    318       }
    319       if (!this._deprecatedMessages.has(message)) {
    320         console.warn(message);
    321         this._deprecatedMessages.add(message);
    322       }
    323     }
    324     if (!function_.name) {
    325       try {
    326         Object.defineProperty(function_, "name", {
    327           get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
    328           configurable: true
    329         });
    330       } catch {
    331       }
    332     }
    333     this._hooks[name] = this._hooks[name] || [];
    334     this._hooks[name].push(function_);
    335     return () => {
    336       if (function_) {
    337         this.removeHook(name, function_);
    338         function_ = void 0;
    339       }
    340     };
    341   }
    342   hookOnce(name, function_) {
    343     let _unreg;
    344     let _function = (...arguments_) => {
    345       if (typeof _unreg === "function") {
    346         _unreg();
    347       }
    348       _unreg = void 0;
    349       _function = void 0;
    350       return function_(...arguments_);
    351     };
    352     _unreg = this.hook(name, _function);
    353     return _unreg;
    354   }
    355   removeHook(name, function_) {
    356     if (this._hooks[name]) {
    357       const index = this._hooks[name].indexOf(function_);
    358       if (index !== -1) {
    359         this._hooks[name].splice(index, 1);
    360       }
    361       if (this._hooks[name].length === 0) {
    362         delete this._hooks[name];
    363       }
    364     }
    365   }
    366   deprecateHook(name, deprecated) {
    367     this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
    368     const _hooks = this._hooks[name] || [];
    369     delete this._hooks[name];
    370     for (const hook2 of _hooks) {
    371       this.hook(name, hook2);
    372     }
    373   }
    374   deprecateHooks(deprecatedHooks) {
    375     Object.assign(this._deprecatedHooks, deprecatedHooks);
    376     for (const name in deprecatedHooks) {
    377       this.deprecateHook(name, deprecatedHooks[name]);
    378     }
    379   }
    380   addHooks(configHooks) {
    381     const hooks2 = flatHooks(configHooks);
    382     const removeFns = Object.keys(hooks2).map(
    383       (key) => this.hook(key, hooks2[key])
    384     );
    385     return () => {
    386       for (const unreg of removeFns.splice(0, removeFns.length)) {
    387         unreg();
    388       }
    389     };
    390   }
    391   removeHooks(configHooks) {
    392     const hooks2 = flatHooks(configHooks);
    393     for (const key in hooks2) {
    394       this.removeHook(key, hooks2[key]);
    395     }
    396   }
    397   removeAllHooks() {
    398     for (const key in this._hooks) {
    399       delete this._hooks[key];
    400     }
    401   }
    402   callHook(name, ...arguments_) {
    403     arguments_.unshift(name);
    404     return this.callHookWith(serialTaskCaller, name, ...arguments_);
    405   }
    406   callHookParallel(name, ...arguments_) {
    407     arguments_.unshift(name);
    408     return this.callHookWith(parallelTaskCaller, name, ...arguments_);
    409   }
    410   callHookWith(caller, name, ...arguments_) {
    411     const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
    412     if (this._before) {
    413       callEachWith(this._before, event);
    414     }
    415     const result = caller(
    416       name in this._hooks ? [...this._hooks[name]] : [],
    417       arguments_
    418     );
    419     if (result instanceof Promise) {
    420       return result.finally(() => {
    421         if (this._after && event) {
    422           callEachWith(this._after, event);
    423         }
    424       });
    425     }
    426     if (this._after && event) {
    427       callEachWith(this._after, event);
    428     }
    429     return result;
    430   }
    431   beforeEach(function_) {
    432     this._before = this._before || [];
    433     this._before.push(function_);
    434     return () => {
    435       if (this._before !== void 0) {
    436         const index = this._before.indexOf(function_);
    437         if (index !== -1) {
    438           this._before.splice(index, 1);
    439         }
    440       }
    441     };
    442   }
    443   afterEach(function_) {
    444     this._after = this._after || [];
    445     this._after.push(function_);
    446     return () => {
    447       if (this._after !== void 0) {
    448         const index = this._after.indexOf(function_);
    449         if (index !== -1) {
    450           this._after.splice(index, 1);
    451         }
    452       }
    453     };
    454   }
    455 };
    456 function createHooks() {
    457   return new Hookable();
    458 }
    459 
    460 // node_modules/birpc/dist/index.mjs
    461 var { clearTimeout: clearTimeout2, setTimeout: setTimeout2 } = globalThis;
    462 var random = Math.random.bind(Math);
    463 
    464 // node_modules/@vue/devtools-kit/dist/index.js
    465 var __create2 = Object.create;
    466 var __defProp2 = Object.defineProperty;
    467 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    468 var __getOwnPropNames2 = Object.getOwnPropertyNames;
    469 var __getProtoOf2 = Object.getPrototypeOf;
    470 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    471 var __commonJSMin2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
    472 var __copyProps2 = (to, from, except, desc) => {
    473   if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
    474     key = keys[i];
    475     if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
    476       get: ((k) => from[k]).bind(null, key),
    477       enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
    478     });
    479   }
    480   return to;
    481 };
    482 var __toESM2 = (mod, isNodeMode, target2) => (target2 = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target2, "default", {
    483   value: mod,
    484   enumerable: true
    485 }) : target2, mod));
    486 function getComponentTypeName(options) {
    487   if (typeof options === "function") return options.displayName || options.name || options.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ || "";
    488   const name = options.name || options._componentTag || options.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ || options.__name;
    489   if (name === "index" && options.__file?.endsWith("index.vue")) return "";
    490   return name;
    491 }
    492 function getComponentFileName(options) {
    493   const file = options.__file;
    494   if (file) return classify(basename(file, ".vue"));
    495 }
    496 function saveComponentGussedName(instance, name) {
    497   instance.type.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ = name;
    498   return name;
    499 }
    500 function getAppRecord(instance) {
    501   if (instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__) return instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
    502   else if (instance.root) return instance.appContext.app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
    503 }
    504 function isFragment(instance) {
    505   const subTreeType = instance.subTree?.type;
    506   const appRecord = getAppRecord(instance);
    507   if (appRecord) return appRecord?.types?.Fragment === subTreeType;
    508   return false;
    509 }
    510 function getInstanceName(instance) {
    511   const name = getComponentTypeName(instance?.type || {});
    512   if (name) return name;
    513   if (instance?.root === instance) return "Root";
    514   for (const key in instance.parent?.type?.components) if (instance.parent.type.components[key] === instance?.type) return saveComponentGussedName(instance, key);
    515   for (const key in instance.appContext?.components) if (instance.appContext.components[key] === instance?.type) return saveComponentGussedName(instance, key);
    516   const fileName = getComponentFileName(instance?.type || {});
    517   if (fileName) return fileName;
    518   return "Anonymous Component";
    519 }
    520 function getUniqueComponentId(instance) {
    521   return `${instance?.appContext?.app?.__VUE_DEVTOOLS_NEXT_APP_RECORD_ID__ ?? 0}:${instance === instance?.root ? "root" : instance.uid}`;
    522 }
    523 function getComponentInstance(appRecord, instanceId) {
    524   instanceId = instanceId || `${appRecord.id}:root`;
    525   return appRecord.instanceMap.get(instanceId) || appRecord.instanceMap.get(":root");
    526 }
    527 function createRect() {
    528   const rect = {
    529     top: 0,
    530     bottom: 0,
    531     left: 0,
    532     right: 0,
    533     get width() {
    534       return rect.right - rect.left;
    535     },
    536     get height() {
    537       return rect.bottom - rect.top;
    538     }
    539   };
    540   return rect;
    541 }
    542 var range;
    543 function getTextRect(node) {
    544   if (!range) range = document.createRange();
    545   range.selectNode(node);
    546   return range.getBoundingClientRect();
    547 }
    548 function getFragmentRect(vnode) {
    549   const rect = createRect();
    550   if (!vnode.children) return rect;
    551   for (let i = 0, l = vnode.children.length; i < l; i++) {
    552     const childVnode = vnode.children[i];
    553     let childRect;
    554     if (childVnode.component) childRect = getComponentBoundingRect(childVnode.component);
    555     else if (childVnode.el) {
    556       const el = childVnode.el;
    557       if (el.nodeType === 1 || el.getBoundingClientRect) childRect = el.getBoundingClientRect();
    558       else if (el.nodeType === 3 && el.data.trim()) childRect = getTextRect(el);
    559     }
    560     if (childRect) mergeRects(rect, childRect);
    561   }
    562   return rect;
    563 }
    564 function mergeRects(a, b) {
    565   if (!a.top || b.top < a.top) a.top = b.top;
    566   if (!a.bottom || b.bottom > a.bottom) a.bottom = b.bottom;
    567   if (!a.left || b.left < a.left) a.left = b.left;
    568   if (!a.right || b.right > a.right) a.right = b.right;
    569   return a;
    570 }
    571 var DEFAULT_RECT = {
    572   top: 0,
    573   left: 0,
    574   right: 0,
    575   bottom: 0,
    576   width: 0,
    577   height: 0
    578 };
    579 function getComponentBoundingRect(instance) {
    580   const el = instance.subTree.el;
    581   if (typeof window === "undefined") return DEFAULT_RECT;
    582   if (isFragment(instance)) return getFragmentRect(instance.subTree);
    583   else if (el?.nodeType === 1) return el?.getBoundingClientRect();
    584   else if (instance.subTree.component) return getComponentBoundingRect(instance.subTree.component);
    585   else return DEFAULT_RECT;
    586 }
    587 function getRootElementsFromComponentInstance(instance) {
    588   if (isFragment(instance)) return getFragmentRootElements(instance.subTree);
    589   if (!instance.subTree) return [];
    590   return [instance.subTree.el];
    591 }
    592 function getFragmentRootElements(vnode) {
    593   if (!vnode.children) return [];
    594   const list = [];
    595   vnode.children.forEach((childVnode) => {
    596     if (childVnode.component) list.push(...getRootElementsFromComponentInstance(childVnode.component));
    597     else if (childVnode?.el) list.push(childVnode.el);
    598   });
    599   return list;
    600 }
    601 var CONTAINER_ELEMENT_ID = "__vue-devtools-component-inspector__";
    602 var CARD_ELEMENT_ID = "__vue-devtools-component-inspector__card__";
    603 var COMPONENT_NAME_ELEMENT_ID = "__vue-devtools-component-inspector__name__";
    604 var INDICATOR_ELEMENT_ID = "__vue-devtools-component-inspector__indicator__";
    605 var containerStyles = {
    606   display: "block",
    607   zIndex: 2147483640,
    608   position: "fixed",
    609   backgroundColor: "#42b88325",
    610   border: "1px solid #42b88350",
    611   borderRadius: "5px",
    612   transition: "all 0.1s ease-in",
    613   pointerEvents: "none"
    614 };
    615 var cardStyles = {
    616   fontFamily: "Arial, Helvetica, sans-serif",
    617   padding: "5px 8px",
    618   borderRadius: "4px",
    619   textAlign: "left",
    620   position: "absolute",
    621   left: 0,
    622   color: "#e9e9e9",
    623   fontSize: "14px",
    624   fontWeight: 600,
    625   lineHeight: "24px",
    626   backgroundColor: "#42b883",
    627   boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)"
    628 };
    629 var indicatorStyles = {
    630   display: "inline-block",
    631   fontWeight: 400,
    632   fontStyle: "normal",
    633   fontSize: "12px",
    634   opacity: 0.7
    635 };
    636 function getContainerElement() {
    637   return document.getElementById(CONTAINER_ELEMENT_ID);
    638 }
    639 function getCardElement() {
    640   return document.getElementById(CARD_ELEMENT_ID);
    641 }
    642 function getIndicatorElement() {
    643   return document.getElementById(INDICATOR_ELEMENT_ID);
    644 }
    645 function getNameElement() {
    646   return document.getElementById(COMPONENT_NAME_ELEMENT_ID);
    647 }
    648 function getStyles(bounds) {
    649   return {
    650     left: `${Math.round(bounds.left * 100) / 100}px`,
    651     top: `${Math.round(bounds.top * 100) / 100}px`,
    652     width: `${Math.round(bounds.width * 100) / 100}px`,
    653     height: `${Math.round(bounds.height * 100) / 100}px`
    654   };
    655 }
    656 function create(options) {
    657   const containerEl = document.createElement("div");
    658   containerEl.id = options.elementId ?? CONTAINER_ELEMENT_ID;
    659   Object.assign(containerEl.style, {
    660     ...containerStyles,
    661     ...getStyles(options.bounds),
    662     ...options.style
    663   });
    664   const cardEl = document.createElement("span");
    665   cardEl.id = CARD_ELEMENT_ID;
    666   Object.assign(cardEl.style, {
    667     ...cardStyles,
    668     top: options.bounds.top < 35 ? 0 : "-35px"
    669   });
    670   const nameEl = document.createElement("span");
    671   nameEl.id = COMPONENT_NAME_ELEMENT_ID;
    672   nameEl.innerHTML = `&lt;${options.name}&gt;&nbsp;&nbsp;`;
    673   const indicatorEl = document.createElement("i");
    674   indicatorEl.id = INDICATOR_ELEMENT_ID;
    675   indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
    676   Object.assign(indicatorEl.style, indicatorStyles);
    677   cardEl.appendChild(nameEl);
    678   cardEl.appendChild(indicatorEl);
    679   containerEl.appendChild(cardEl);
    680   document.body.appendChild(containerEl);
    681   return containerEl;
    682 }
    683 function update(options) {
    684   const containerEl = getContainerElement();
    685   const cardEl = getCardElement();
    686   const nameEl = getNameElement();
    687   const indicatorEl = getIndicatorElement();
    688   if (containerEl) {
    689     Object.assign(containerEl.style, {
    690       ...containerStyles,
    691       ...getStyles(options.bounds)
    692     });
    693     Object.assign(cardEl.style, { top: options.bounds.top < 35 ? 0 : "-35px" });
    694     nameEl.innerHTML = `&lt;${options.name}&gt;&nbsp;&nbsp;`;
    695     indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
    696   }
    697 }
    698 function highlight(instance) {
    699   const bounds = getComponentBoundingRect(instance);
    700   if (!bounds.width && !bounds.height) return;
    701   const name = getInstanceName(instance);
    702   getContainerElement() ? update({
    703     bounds,
    704     name
    705   }) : create({
    706     bounds,
    707     name
    708   });
    709 }
    710 function unhighlight() {
    711   const el = getContainerElement();
    712   if (el) el.style.display = "none";
    713 }
    714 var inspectInstance = null;
    715 function inspectFn(e) {
    716   const target2 = e.target;
    717   if (target2) {
    718     const instance = target2.__vueParentComponent;
    719     if (instance) {
    720       inspectInstance = instance;
    721       if (instance.vnode.el) {
    722         const bounds = getComponentBoundingRect(instance);
    723         const name = getInstanceName(instance);
    724         getContainerElement() ? update({
    725           bounds,
    726           name
    727         }) : create({
    728           bounds,
    729           name
    730         });
    731       }
    732     }
    733   }
    734 }
    735 function selectComponentFn(e, cb) {
    736   e.preventDefault();
    737   e.stopPropagation();
    738   if (inspectInstance) cb(getUniqueComponentId(inspectInstance));
    739 }
    740 var inspectComponentHighLighterSelectFn = null;
    741 function cancelInspectComponentHighLighter() {
    742   unhighlight();
    743   window.removeEventListener("mouseover", inspectFn);
    744   window.removeEventListener("click", inspectComponentHighLighterSelectFn, true);
    745   inspectComponentHighLighterSelectFn = null;
    746 }
    747 function inspectComponentHighLighter() {
    748   window.addEventListener("mouseover", inspectFn);
    749   return new Promise((resolve) => {
    750     function onSelect(e) {
    751       e.preventDefault();
    752       e.stopPropagation();
    753       selectComponentFn(e, (id) => {
    754         window.removeEventListener("click", onSelect, true);
    755         inspectComponentHighLighterSelectFn = null;
    756         window.removeEventListener("mouseover", inspectFn);
    757         const el = getContainerElement();
    758         if (el) el.style.display = "none";
    759         resolve(JSON.stringify({ id }));
    760       });
    761     }
    762     inspectComponentHighLighterSelectFn = onSelect;
    763     window.addEventListener("click", onSelect, true);
    764   });
    765 }
    766 function scrollToComponent(options) {
    767   const instance = getComponentInstance(activeAppRecord.value, options.id);
    768   if (instance) {
    769     const [el] = getRootElementsFromComponentInstance(instance);
    770     if (typeof el.scrollIntoView === "function") el.scrollIntoView({ behavior: "smooth" });
    771     else {
    772       const bounds = getComponentBoundingRect(instance);
    773       const scrollTarget = document.createElement("div");
    774       const styles = {
    775         ...getStyles(bounds),
    776         position: "absolute"
    777       };
    778       Object.assign(scrollTarget.style, styles);
    779       document.body.appendChild(scrollTarget);
    780       scrollTarget.scrollIntoView({ behavior: "smooth" });
    781       setTimeout(() => {
    782         document.body.removeChild(scrollTarget);
    783       }, 2e3);
    784     }
    785     setTimeout(() => {
    786       const bounds = getComponentBoundingRect(instance);
    787       if (bounds.width || bounds.height) {
    788         const name = getInstanceName(instance);
    789         const el2 = getContainerElement();
    790         el2 ? update({
    791           ...options,
    792           name,
    793           bounds
    794         }) : create({
    795           ...options,
    796           name,
    797           bounds
    798         });
    799         setTimeout(() => {
    800           if (el2) el2.style.display = "none";
    801         }, 1500);
    802       }
    803     }, 1200);
    804   }
    805 }
    806 target.__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__ ??= true;
    807 function waitForInspectorInit(cb) {
    808   let total = 0;
    809   const timer = setInterval(() => {
    810     if (target.__VUE_INSPECTOR__) {
    811       clearInterval(timer);
    812       total += 30;
    813       cb();
    814     }
    815     if (total >= 5e3) clearInterval(timer);
    816   }, 30);
    817 }
    818 function setupInspector() {
    819   const inspector = target.__VUE_INSPECTOR__;
    820   const _openInEditor = inspector.openInEditor;
    821   inspector.openInEditor = async (...params) => {
    822     inspector.disable();
    823     _openInEditor(...params);
    824   };
    825 }
    826 function getComponentInspector() {
    827   return new Promise((resolve) => {
    828     function setup() {
    829       setupInspector();
    830       resolve(target.__VUE_INSPECTOR__);
    831     }
    832     if (!target.__VUE_INSPECTOR__) waitForInspectorInit(() => {
    833       setup();
    834     });
    835     else setup();
    836   });
    837 }
    838 var ReactiveFlags = (function(ReactiveFlags2) {
    839   ReactiveFlags2["SKIP"] = "__v_skip";
    840   ReactiveFlags2["IS_REACTIVE"] = "__v_isReactive";
    841   ReactiveFlags2["IS_READONLY"] = "__v_isReadonly";
    842   ReactiveFlags2["IS_SHALLOW"] = "__v_isShallow";
    843   ReactiveFlags2["RAW"] = "__v_raw";
    844   return ReactiveFlags2;
    845 })({});
    846 function isReadonly(value) {
    847   return !!(value && value[ReactiveFlags.IS_READONLY]);
    848 }
    849 function isReactive$1(value) {
    850   if (isReadonly(value)) return isReactive$1(value[ReactiveFlags.RAW]);
    851   return !!(value && value[ReactiveFlags.IS_REACTIVE]);
    852 }
    853 function isRef$1(r) {
    854   return !!(r && r.__v_isRef === true);
    855 }
    856 function toRaw$1(observed) {
    857   const raw = observed && observed[ReactiveFlags.RAW];
    858   return raw ? toRaw$1(raw) : observed;
    859 }
    860 var StateEditor = class {
    861   constructor() {
    862     this.refEditor = new RefStateEditor();
    863   }
    864   set(object, path, value, cb) {
    865     const sections = Array.isArray(path) ? path : path.split(".");
    866     while (sections.length > 1) {
    867       const section = sections.shift();
    868       if (object instanceof Map) object = object.get(section);
    869       else if (object instanceof Set) object = Array.from(object.values())[section];
    870       else object = object[section];
    871       if (this.refEditor.isRef(object)) object = this.refEditor.get(object);
    872     }
    873     const field = sections[0];
    874     const item = this.refEditor.get(object)[field];
    875     if (cb) cb(object, field, value);
    876     else if (this.refEditor.isRef(item)) this.refEditor.set(item, value);
    877     else object[field] = value;
    878   }
    879   get(object, path) {
    880     const sections = Array.isArray(path) ? path : path.split(".");
    881     for (let i = 0; i < sections.length; i++) {
    882       if (object instanceof Map) object = object.get(sections[i]);
    883       else object = object[sections[i]];
    884       if (this.refEditor.isRef(object)) object = this.refEditor.get(object);
    885       if (!object) return void 0;
    886     }
    887     return object;
    888   }
    889   has(object, path, parent = false) {
    890     if (typeof object === "undefined") return false;
    891     const sections = Array.isArray(path) ? path.slice() : path.split(".");
    892     const size = !parent ? 1 : 2;
    893     while (object && sections.length > size) {
    894       const section = sections.shift();
    895       object = object[section];
    896       if (this.refEditor.isRef(object)) object = this.refEditor.get(object);
    897     }
    898     return object != null && Object.prototype.hasOwnProperty.call(object, sections[0]);
    899   }
    900   createDefaultSetCallback(state) {
    901     return (object, field, value) => {
    902       if (state.remove || state.newKey) if (Array.isArray(object)) object.splice(field, 1);
    903       else if (toRaw$1(object) instanceof Map) object.delete(field);
    904       else if (toRaw$1(object) instanceof Set) object.delete(Array.from(object.values())[field]);
    905       else Reflect.deleteProperty(object, field);
    906       if (!state.remove) {
    907         const target2 = object[state.newKey || field];
    908         if (this.refEditor.isRef(target2)) this.refEditor.set(target2, value);
    909         else if (toRaw$1(object) instanceof Map) object.set(state.newKey || field, value);
    910         else if (toRaw$1(object) instanceof Set) object.add(value);
    911         else object[state.newKey || field] = value;
    912       }
    913     };
    914   }
    915 };
    916 var RefStateEditor = class {
    917   set(ref, value) {
    918     if (isRef$1(ref)) ref.value = value;
    919     else {
    920       if (ref instanceof Set && Array.isArray(value)) {
    921         ref.clear();
    922         value.forEach((v) => ref.add(v));
    923         return;
    924       }
    925       const currentKeys = Object.keys(value);
    926       if (ref instanceof Map) {
    927         const previousKeysSet2 = new Set(ref.keys());
    928         currentKeys.forEach((key) => {
    929           ref.set(key, Reflect.get(value, key));
    930           previousKeysSet2.delete(key);
    931         });
    932         previousKeysSet2.forEach((key) => ref.delete(key));
    933         return;
    934       }
    935       const previousKeysSet = new Set(Object.keys(ref));
    936       currentKeys.forEach((key) => {
    937         Reflect.set(ref, key, Reflect.get(value, key));
    938         previousKeysSet.delete(key);
    939       });
    940       previousKeysSet.forEach((key) => Reflect.deleteProperty(ref, key));
    941     }
    942   }
    943   get(ref) {
    944     return isRef$1(ref) ? ref.value : ref;
    945   }
    946   isRef(ref) {
    947     return isRef$1(ref) || isReactive$1(ref);
    948   }
    949 };
    950 var stateEditor = new StateEditor();
    951 var TIMELINE_LAYERS_STATE_STORAGE_ID = "__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS_STATE__";
    952 function getTimelineLayersStateFromStorage() {
    953   if (typeof window === "undefined" || !isBrowser || typeof localStorage === "undefined" || localStorage === null) return {
    954     recordingState: false,
    955     mouseEventEnabled: false,
    956     keyboardEventEnabled: false,
    957     componentEventEnabled: false,
    958     performanceEventEnabled: false,
    959     selected: ""
    960   };
    961   const state = typeof localStorage.getItem !== "undefined" ? localStorage.getItem(TIMELINE_LAYERS_STATE_STORAGE_ID) : null;
    962   return state ? JSON.parse(state) : {
    963     recordingState: false,
    964     mouseEventEnabled: false,
    965     keyboardEventEnabled: false,
    966     componentEventEnabled: false,
    967     performanceEventEnabled: false,
    968     selected: ""
    969   };
    970 }
    971 target.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS ??= [];
    972 var devtoolsTimelineLayers = new Proxy(target.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS, { get(target2, prop, receiver) {
    973   return Reflect.get(target2, prop, receiver);
    974 } });
    975 function addTimelineLayer(options, descriptor) {
    976   devtoolsState.timelineLayersState[descriptor.id] = false;
    977   devtoolsTimelineLayers.push({
    978     ...options,
    979     descriptorId: descriptor.id,
    980     appRecord: getAppRecord(descriptor.app)
    981   });
    982 }
    983 target.__VUE_DEVTOOLS_KIT_INSPECTOR__ ??= [];
    984 var devtoolsInspector = new Proxy(target.__VUE_DEVTOOLS_KIT_INSPECTOR__, { get(target2, prop, receiver) {
    985   return Reflect.get(target2, prop, receiver);
    986 } });
    987 var callInspectorUpdatedHook = debounce(() => {
    988   devtoolsContext.hooks.callHook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, getActiveInspectors());
    989 });
    990 function addInspector(inspector, descriptor) {
    991   devtoolsInspector.push({
    992     options: inspector,
    993     descriptor,
    994     treeFilterPlaceholder: inspector.treeFilterPlaceholder ?? "Search tree...",
    995     stateFilterPlaceholder: inspector.stateFilterPlaceholder ?? "Search state...",
    996     treeFilter: "",
    997     selectedNodeId: "",
    998     appRecord: getAppRecord(descriptor.app)
    999   });
   1000   callInspectorUpdatedHook();
   1001 }
   1002 function getActiveInspectors() {
   1003   return devtoolsInspector.filter((inspector) => inspector.descriptor.app === activeAppRecord.value.app).filter((inspector) => inspector.descriptor.id !== "components").map((inspector) => {
   1004     const descriptor = inspector.descriptor;
   1005     const options = inspector.options;
   1006     return {
   1007       id: options.id,
   1008       label: options.label,
   1009       logo: descriptor.logo,
   1010       icon: `custom-ic-baseline-${options?.icon?.replace(/_/g, "-")}`,
   1011       packageName: descriptor.packageName,
   1012       homepage: descriptor.homepage,
   1013       pluginId: descriptor.id
   1014     };
   1015   });
   1016 }
   1017 function getInspector(id, app) {
   1018   return devtoolsInspector.find((inspector) => inspector.options.id === id && (app ? inspector.descriptor.app === app : true));
   1019 }
   1020 var DevToolsV6PluginAPIHookKeys = (function(DevToolsV6PluginAPIHookKeys2) {
   1021   DevToolsV6PluginAPIHookKeys2["VISIT_COMPONENT_TREE"] = "visitComponentTree";
   1022   DevToolsV6PluginAPIHookKeys2["INSPECT_COMPONENT"] = "inspectComponent";
   1023   DevToolsV6PluginAPIHookKeys2["EDIT_COMPONENT_STATE"] = "editComponentState";
   1024   DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_TREE"] = "getInspectorTree";
   1025   DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_STATE"] = "getInspectorState";
   1026   DevToolsV6PluginAPIHookKeys2["EDIT_INSPECTOR_STATE"] = "editInspectorState";
   1027   DevToolsV6PluginAPIHookKeys2["INSPECT_TIMELINE_EVENT"] = "inspectTimelineEvent";
   1028   DevToolsV6PluginAPIHookKeys2["TIMELINE_CLEARED"] = "timelineCleared";
   1029   DevToolsV6PluginAPIHookKeys2["SET_PLUGIN_SETTINGS"] = "setPluginSettings";
   1030   return DevToolsV6PluginAPIHookKeys2;
   1031 })({});
   1032 var DevToolsContextHookKeys = (function(DevToolsContextHookKeys2) {
   1033   DevToolsContextHookKeys2["ADD_INSPECTOR"] = "addInspector";
   1034   DevToolsContextHookKeys2["SEND_INSPECTOR_TREE"] = "sendInspectorTree";
   1035   DevToolsContextHookKeys2["SEND_INSPECTOR_STATE"] = "sendInspectorState";
   1036   DevToolsContextHookKeys2["CUSTOM_INSPECTOR_SELECT_NODE"] = "customInspectorSelectNode";
   1037   DevToolsContextHookKeys2["TIMELINE_LAYER_ADDED"] = "timelineLayerAdded";
   1038   DevToolsContextHookKeys2["TIMELINE_EVENT_ADDED"] = "timelineEventAdded";
   1039   DevToolsContextHookKeys2["GET_COMPONENT_INSTANCES"] = "getComponentInstances";
   1040   DevToolsContextHookKeys2["GET_COMPONENT_BOUNDS"] = "getComponentBounds";
   1041   DevToolsContextHookKeys2["GET_COMPONENT_NAME"] = "getComponentName";
   1042   DevToolsContextHookKeys2["COMPONENT_HIGHLIGHT"] = "componentHighlight";
   1043   DevToolsContextHookKeys2["COMPONENT_UNHIGHLIGHT"] = "componentUnhighlight";
   1044   return DevToolsContextHookKeys2;
   1045 })({});
   1046 var DevToolsMessagingHookKeys = (function(DevToolsMessagingHookKeys2) {
   1047   DevToolsMessagingHookKeys2["SEND_INSPECTOR_TREE_TO_CLIENT"] = "sendInspectorTreeToClient";
   1048   DevToolsMessagingHookKeys2["SEND_INSPECTOR_STATE_TO_CLIENT"] = "sendInspectorStateToClient";
   1049   DevToolsMessagingHookKeys2["SEND_TIMELINE_EVENT_TO_CLIENT"] = "sendTimelineEventToClient";
   1050   DevToolsMessagingHookKeys2["SEND_INSPECTOR_TO_CLIENT"] = "sendInspectorToClient";
   1051   DevToolsMessagingHookKeys2["SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT"] = "sendActiveAppUpdatedToClient";
   1052   DevToolsMessagingHookKeys2["DEVTOOLS_STATE_UPDATED"] = "devtoolsStateUpdated";
   1053   DevToolsMessagingHookKeys2["DEVTOOLS_CONNECTED_UPDATED"] = "devtoolsConnectedUpdated";
   1054   DevToolsMessagingHookKeys2["ROUTER_INFO_UPDATED"] = "routerInfoUpdated";
   1055   return DevToolsMessagingHookKeys2;
   1056 })({});
   1057 function createDevToolsCtxHooks() {
   1058   const hooks2 = createHooks();
   1059   hooks2.hook(DevToolsContextHookKeys.ADD_INSPECTOR, ({ inspector, plugin }) => {
   1060     addInspector(inspector, plugin.descriptor);
   1061   });
   1062   const debounceSendInspectorTree = debounce(async ({ inspectorId, plugin }) => {
   1063     if (!inspectorId || !plugin?.descriptor?.app || devtoolsState.highPerfModeEnabled) return;
   1064     const inspector = getInspector(inspectorId, plugin.descriptor.app);
   1065     const _payload = {
   1066       app: plugin.descriptor.app,
   1067       inspectorId,
   1068       filter: inspector?.treeFilter || "",
   1069       rootNodes: []
   1070     };
   1071     await new Promise((resolve) => {
   1072       hooks2.callHookWith(async (callbacks) => {
   1073         await Promise.all(callbacks.map((cb) => cb(_payload)));
   1074         resolve();
   1075       }, DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE);
   1076     });
   1077     hooks2.callHookWith(async (callbacks) => {
   1078       await Promise.all(callbacks.map((cb) => cb({
   1079         inspectorId,
   1080         rootNodes: _payload.rootNodes
   1081       })));
   1082     }, DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT);
   1083   }, 120);
   1084   hooks2.hook(DevToolsContextHookKeys.SEND_INSPECTOR_TREE, debounceSendInspectorTree);
   1085   const debounceSendInspectorState = debounce(async ({ inspectorId, plugin }) => {
   1086     if (!inspectorId || !plugin?.descriptor?.app || devtoolsState.highPerfModeEnabled) return;
   1087     const inspector = getInspector(inspectorId, plugin.descriptor.app);
   1088     const _payload = {
   1089       app: plugin.descriptor.app,
   1090       inspectorId,
   1091       nodeId: inspector?.selectedNodeId || "",
   1092       state: null
   1093     };
   1094     const ctx = { currentTab: `custom-inspector:${inspectorId}` };
   1095     if (_payload.nodeId) await new Promise((resolve) => {
   1096       hooks2.callHookWith(async (callbacks) => {
   1097         await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
   1098         resolve();
   1099       }, DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE);
   1100     });
   1101     hooks2.callHookWith(async (callbacks) => {
   1102       await Promise.all(callbacks.map((cb) => cb({
   1103         inspectorId,
   1104         nodeId: _payload.nodeId,
   1105         state: _payload.state
   1106       })));
   1107     }, DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT);
   1108   }, 120);
   1109   hooks2.hook(DevToolsContextHookKeys.SEND_INSPECTOR_STATE, debounceSendInspectorState);
   1110   hooks2.hook(DevToolsContextHookKeys.CUSTOM_INSPECTOR_SELECT_NODE, ({ inspectorId, nodeId, plugin }) => {
   1111     const inspector = getInspector(inspectorId, plugin.descriptor.app);
   1112     if (!inspector) return;
   1113     inspector.selectedNodeId = nodeId;
   1114   });
   1115   hooks2.hook(DevToolsContextHookKeys.TIMELINE_LAYER_ADDED, ({ options, plugin }) => {
   1116     addTimelineLayer(options, plugin.descriptor);
   1117   });
   1118   hooks2.hook(DevToolsContextHookKeys.TIMELINE_EVENT_ADDED, ({ options, plugin }) => {
   1119     if (devtoolsState.highPerfModeEnabled || !devtoolsState.timelineLayersState?.[plugin.descriptor.id] && ![
   1120       "performance",
   1121       "component-event",
   1122       "keyboard",
   1123       "mouse"
   1124     ].includes(options.layerId)) return;
   1125     hooks2.callHookWith(async (callbacks) => {
   1126       await Promise.all(callbacks.map((cb) => cb(options)));
   1127     }, DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT);
   1128   });
   1129   hooks2.hook(DevToolsContextHookKeys.GET_COMPONENT_INSTANCES, async ({ app }) => {
   1130     const appRecord = app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
   1131     if (!appRecord) return null;
   1132     const appId = appRecord.id.toString();
   1133     return [...appRecord.instanceMap].filter(([key]) => key.split(":")[0] === appId).map(([, instance]) => instance);
   1134   });
   1135   hooks2.hook(DevToolsContextHookKeys.GET_COMPONENT_BOUNDS, async ({ instance }) => {
   1136     return getComponentBoundingRect(instance);
   1137   });
   1138   hooks2.hook(DevToolsContextHookKeys.GET_COMPONENT_NAME, ({ instance }) => {
   1139     return getInstanceName(instance);
   1140   });
   1141   hooks2.hook(DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, ({ uid }) => {
   1142     const instance = activeAppRecord.value.instanceMap.get(uid);
   1143     if (instance) highlight(instance);
   1144   });
   1145   hooks2.hook(DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT, () => {
   1146     unhighlight();
   1147   });
   1148   return hooks2;
   1149 }
   1150 target.__VUE_DEVTOOLS_KIT_APP_RECORDS__ ??= [];
   1151 target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ ??= {};
   1152 target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ ??= "";
   1153 target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__ ??= [];
   1154 target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__ ??= [];
   1155 var STATE_KEY = "__VUE_DEVTOOLS_KIT_GLOBAL_STATE__";
   1156 function initStateFactory() {
   1157   return {
   1158     connected: false,
   1159     clientConnected: false,
   1160     vitePluginDetected: true,
   1161     appRecords: [],
   1162     activeAppRecordId: "",
   1163     tabs: [],
   1164     commands: [],
   1165     highPerfModeEnabled: true,
   1166     devtoolsClientDetected: {},
   1167     perfUniqueGroupId: 0,
   1168     timelineLayersState: getTimelineLayersStateFromStorage()
   1169   };
   1170 }
   1171 target[STATE_KEY] ??= initStateFactory();
   1172 var callStateUpdatedHook = debounce((state) => {
   1173   devtoolsContext.hooks.callHook(DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, { state });
   1174 });
   1175 var callConnectedUpdatedHook = debounce((state, oldState) => {
   1176   devtoolsContext.hooks.callHook(DevToolsMessagingHookKeys.DEVTOOLS_CONNECTED_UPDATED, {
   1177     state,
   1178     oldState
   1179   });
   1180 });
   1181 var devtoolsAppRecords = new Proxy(target.__VUE_DEVTOOLS_KIT_APP_RECORDS__, { get(_target, prop, receiver) {
   1182   if (prop === "value") return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__;
   1183   return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__[prop];
   1184 } });
   1185 var activeAppRecord = new Proxy(target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__, { get(_target, prop, receiver) {
   1186   if (prop === "value") return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__;
   1187   else if (prop === "id") return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__;
   1188   return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__[prop];
   1189 } });
   1190 function updateAllStates() {
   1191   callStateUpdatedHook({
   1192     ...target[STATE_KEY],
   1193     appRecords: devtoolsAppRecords.value,
   1194     activeAppRecordId: activeAppRecord.id,
   1195     tabs: target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__,
   1196     commands: target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__
   1197   });
   1198 }
   1199 function setActiveAppRecord(app) {
   1200   target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = app;
   1201   updateAllStates();
   1202 }
   1203 function setActiveAppRecordId(id) {
   1204   target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = id;
   1205   updateAllStates();
   1206 }
   1207 var devtoolsState = new Proxy(target[STATE_KEY], {
   1208   get(target$3, property) {
   1209     if (property === "appRecords") return devtoolsAppRecords;
   1210     else if (property === "activeAppRecordId") return activeAppRecord.id;
   1211     else if (property === "tabs") return target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
   1212     else if (property === "commands") return target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
   1213     return target[STATE_KEY][property];
   1214   },
   1215   deleteProperty(target2, property) {
   1216     delete target2[property];
   1217     return true;
   1218   },
   1219   set(target$4, property, value) {
   1220     target$4[property] = value;
   1221     target[STATE_KEY][property] = value;
   1222     return true;
   1223   }
   1224 });
   1225 function onDevToolsConnected(fn) {
   1226   return new Promise((resolve) => {
   1227     if (devtoolsState.connected) {
   1228       fn();
   1229       resolve();
   1230     }
   1231     devtoolsContext.hooks.hook(DevToolsMessagingHookKeys.DEVTOOLS_CONNECTED_UPDATED, ({ state }) => {
   1232       if (state.connected) {
   1233         fn();
   1234         resolve();
   1235       }
   1236     });
   1237   });
   1238 }
   1239 var resolveIcon = (icon) => {
   1240   if (!icon) return;
   1241   if (icon.startsWith("baseline-")) return `custom-ic-${icon}`;
   1242   if (icon.startsWith("i-") || isUrlString(icon)) return icon;
   1243   return `custom-ic-baseline-${icon}`;
   1244 };
   1245 function addCustomTab(tab) {
   1246   const tabs = target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
   1247   if (tabs.some((t) => t.name === tab.name)) return;
   1248   tabs.push({
   1249     ...tab,
   1250     icon: resolveIcon(tab.icon)
   1251   });
   1252   updateAllStates();
   1253 }
   1254 function addCustomCommand(action) {
   1255   const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
   1256   if (commands.some((t) => t.id === action.id)) return;
   1257   commands.push({
   1258     ...action,
   1259     icon: resolveIcon(action.icon),
   1260     children: action.children ? action.children.map((child) => ({
   1261       ...child,
   1262       icon: resolveIcon(child.icon)
   1263     })) : void 0
   1264   });
   1265   updateAllStates();
   1266 }
   1267 function removeCustomCommand(actionId) {
   1268   const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
   1269   const index = commands.findIndex((t) => t.id === actionId);
   1270   if (index === -1) return;
   1271   commands.splice(index, 1);
   1272   updateAllStates();
   1273 }
   1274 function openInEditor(options = {}) {
   1275   const { file, host, baseUrl = window.location.origin, line = 0, column = 0 } = options;
   1276   if (file) {
   1277     if (host === "chrome-extension") {
   1278       const fileName = file.replace(/\\/g, "\\\\");
   1279       const _baseUrl = window.VUE_DEVTOOLS_CONFIG?.openInEditorHost ?? "/";
   1280       fetch(`${_baseUrl}__open-in-editor?file=${encodeURI(file)}`).then((response) => {
   1281         if (!response.ok) {
   1282           const msg = `Opening component ${fileName} failed`;
   1283           console.log(`%c${msg}`, "color:red");
   1284         }
   1285       });
   1286     } else if (devtoolsState.vitePluginDetected) {
   1287       const _baseUrl = target.__VUE_DEVTOOLS_OPEN_IN_EDITOR_BASE_URL__ ?? baseUrl;
   1288       target.__VUE_INSPECTOR__.openInEditor(_baseUrl, file, line, column);
   1289     }
   1290   }
   1291 }
   1292 target.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__ ??= [];
   1293 var devtoolsPluginBuffer = new Proxy(target.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__, { get(target2, prop, receiver) {
   1294   return Reflect.get(target2, prop, receiver);
   1295 } });
   1296 function _getSettings(settings) {
   1297   const _settings = {};
   1298   Object.keys(settings).forEach((key) => {
   1299     _settings[key] = settings[key].defaultValue;
   1300   });
   1301   return _settings;
   1302 }
   1303 function getPluginLocalKey(pluginId) {
   1304   return `__VUE_DEVTOOLS_NEXT_PLUGIN_SETTINGS__${pluginId}__`;
   1305 }
   1306 function getPluginSettingsOptions(pluginId) {
   1307   return (devtoolsPluginBuffer.find((item) => item[0].id === pluginId && !!item[0]?.settings)?.[0] ?? null)?.settings ?? null;
   1308 }
   1309 function getPluginSettings(pluginId, fallbackValue) {
   1310   const localKey = getPluginLocalKey(pluginId);
   1311   if (localKey) {
   1312     const localSettings = localStorage.getItem(localKey);
   1313     if (localSettings) return JSON.parse(localSettings);
   1314   }
   1315   if (pluginId) return _getSettings((devtoolsPluginBuffer.find((item) => item[0].id === pluginId)?.[0] ?? null)?.settings ?? {});
   1316   return _getSettings(fallbackValue);
   1317 }
   1318 function initPluginSettings(pluginId, settings) {
   1319   const localKey = getPluginLocalKey(pluginId);
   1320   if (!localStorage.getItem(localKey)) localStorage.setItem(localKey, JSON.stringify(_getSettings(settings)));
   1321 }
   1322 function setPluginSettings(pluginId, key, value) {
   1323   const localKey = getPluginLocalKey(pluginId);
   1324   const localSettings = localStorage.getItem(localKey);
   1325   const parsedLocalSettings = JSON.parse(localSettings || "{}");
   1326   const updated = {
   1327     ...parsedLocalSettings,
   1328     [key]: value
   1329   };
   1330   localStorage.setItem(localKey, JSON.stringify(updated));
   1331   devtoolsContext.hooks.callHookWith((callbacks) => {
   1332     callbacks.forEach((cb) => cb({
   1333       pluginId,
   1334       key,
   1335       oldValue: parsedLocalSettings[key],
   1336       newValue: value,
   1337       settings: updated
   1338     }));
   1339   }, DevToolsV6PluginAPIHookKeys.SET_PLUGIN_SETTINGS);
   1340 }
   1341 var DevToolsHooks = (function(DevToolsHooks2) {
   1342   DevToolsHooks2["APP_INIT"] = "app:init";
   1343   DevToolsHooks2["APP_UNMOUNT"] = "app:unmount";
   1344   DevToolsHooks2["COMPONENT_UPDATED"] = "component:updated";
   1345   DevToolsHooks2["COMPONENT_ADDED"] = "component:added";
   1346   DevToolsHooks2["COMPONENT_REMOVED"] = "component:removed";
   1347   DevToolsHooks2["COMPONENT_EMIT"] = "component:emit";
   1348   DevToolsHooks2["PERFORMANCE_START"] = "perf:start";
   1349   DevToolsHooks2["PERFORMANCE_END"] = "perf:end";
   1350   DevToolsHooks2["ADD_ROUTE"] = "router:add-route";
   1351   DevToolsHooks2["REMOVE_ROUTE"] = "router:remove-route";
   1352   DevToolsHooks2["RENDER_TRACKED"] = "render:tracked";
   1353   DevToolsHooks2["RENDER_TRIGGERED"] = "render:triggered";
   1354   DevToolsHooks2["APP_CONNECTED"] = "app:connected";
   1355   DevToolsHooks2["SETUP_DEVTOOLS_PLUGIN"] = "devtools-plugin:setup";
   1356   return DevToolsHooks2;
   1357 })({});
   1358 var devtoolsHooks = target.__VUE_DEVTOOLS_HOOK ??= createHooks();
   1359 var on = {
   1360   vueAppInit(fn) {
   1361     devtoolsHooks.hook(DevToolsHooks.APP_INIT, fn);
   1362   },
   1363   vueAppUnmount(fn) {
   1364     devtoolsHooks.hook(DevToolsHooks.APP_UNMOUNT, fn);
   1365   },
   1366   vueAppConnected(fn) {
   1367     devtoolsHooks.hook(DevToolsHooks.APP_CONNECTED, fn);
   1368   },
   1369   componentAdded(fn) {
   1370     return devtoolsHooks.hook(DevToolsHooks.COMPONENT_ADDED, fn);
   1371   },
   1372   componentEmit(fn) {
   1373     return devtoolsHooks.hook(DevToolsHooks.COMPONENT_EMIT, fn);
   1374   },
   1375   componentUpdated(fn) {
   1376     return devtoolsHooks.hook(DevToolsHooks.COMPONENT_UPDATED, fn);
   1377   },
   1378   componentRemoved(fn) {
   1379     return devtoolsHooks.hook(DevToolsHooks.COMPONENT_REMOVED, fn);
   1380   },
   1381   setupDevtoolsPlugin(fn) {
   1382     devtoolsHooks.hook(DevToolsHooks.SETUP_DEVTOOLS_PLUGIN, fn);
   1383   },
   1384   perfStart(fn) {
   1385     return devtoolsHooks.hook(DevToolsHooks.PERFORMANCE_START, fn);
   1386   },
   1387   perfEnd(fn) {
   1388     return devtoolsHooks.hook(DevToolsHooks.PERFORMANCE_END, fn);
   1389   }
   1390 };
   1391 var hook = {
   1392   on,
   1393   setupDevToolsPlugin(pluginDescriptor, setupFn) {
   1394     return devtoolsHooks.callHook(DevToolsHooks.SETUP_DEVTOOLS_PLUGIN, pluginDescriptor, setupFn);
   1395   }
   1396 };
   1397 var DevToolsV6PluginAPI = class {
   1398   constructor({ plugin, ctx }) {
   1399     this.hooks = ctx.hooks;
   1400     this.plugin = plugin;
   1401   }
   1402   get on() {
   1403     return {
   1404       visitComponentTree: (handler) => {
   1405         this.hooks.hook(DevToolsV6PluginAPIHookKeys.VISIT_COMPONENT_TREE, handler);
   1406       },
   1407       inspectComponent: (handler) => {
   1408         this.hooks.hook(DevToolsV6PluginAPIHookKeys.INSPECT_COMPONENT, handler);
   1409       },
   1410       editComponentState: (handler) => {
   1411         this.hooks.hook(DevToolsV6PluginAPIHookKeys.EDIT_COMPONENT_STATE, handler);
   1412       },
   1413       getInspectorTree: (handler) => {
   1414         this.hooks.hook(DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE, handler);
   1415       },
   1416       getInspectorState: (handler) => {
   1417         this.hooks.hook(DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE, handler);
   1418       },
   1419       editInspectorState: (handler) => {
   1420         this.hooks.hook(DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE, handler);
   1421       },
   1422       inspectTimelineEvent: (handler) => {
   1423         this.hooks.hook(DevToolsV6PluginAPIHookKeys.INSPECT_TIMELINE_EVENT, handler);
   1424       },
   1425       timelineCleared: (handler) => {
   1426         this.hooks.hook(DevToolsV6PluginAPIHookKeys.TIMELINE_CLEARED, handler);
   1427       },
   1428       setPluginSettings: (handler) => {
   1429         this.hooks.hook(DevToolsV6PluginAPIHookKeys.SET_PLUGIN_SETTINGS, handler);
   1430       }
   1431     };
   1432   }
   1433   notifyComponentUpdate(instance) {
   1434     if (devtoolsState.highPerfModeEnabled) return;
   1435     const inspector = getActiveInspectors().find((i) => i.packageName === this.plugin.descriptor.packageName);
   1436     if (inspector?.id) {
   1437       if (instance) {
   1438         const args = [
   1439           instance.appContext.app,
   1440           instance.uid,
   1441           instance.parent?.uid,
   1442           instance
   1443         ];
   1444         devtoolsHooks.callHook(DevToolsHooks.COMPONENT_UPDATED, ...args);
   1445       } else devtoolsHooks.callHook(DevToolsHooks.COMPONENT_UPDATED);
   1446       this.hooks.callHook(DevToolsContextHookKeys.SEND_INSPECTOR_STATE, {
   1447         inspectorId: inspector.id,
   1448         plugin: this.plugin
   1449       });
   1450     }
   1451   }
   1452   addInspector(options) {
   1453     this.hooks.callHook(DevToolsContextHookKeys.ADD_INSPECTOR, {
   1454       inspector: options,
   1455       plugin: this.plugin
   1456     });
   1457     if (this.plugin.descriptor.settings) initPluginSettings(options.id, this.plugin.descriptor.settings);
   1458   }
   1459   sendInspectorTree(inspectorId) {
   1460     if (devtoolsState.highPerfModeEnabled) return;
   1461     this.hooks.callHook(DevToolsContextHookKeys.SEND_INSPECTOR_TREE, {
   1462       inspectorId,
   1463       plugin: this.plugin
   1464     });
   1465   }
   1466   sendInspectorState(inspectorId) {
   1467     if (devtoolsState.highPerfModeEnabled) return;
   1468     this.hooks.callHook(DevToolsContextHookKeys.SEND_INSPECTOR_STATE, {
   1469       inspectorId,
   1470       plugin: this.plugin
   1471     });
   1472   }
   1473   selectInspectorNode(inspectorId, nodeId) {
   1474     this.hooks.callHook(DevToolsContextHookKeys.CUSTOM_INSPECTOR_SELECT_NODE, {
   1475       inspectorId,
   1476       nodeId,
   1477       plugin: this.plugin
   1478     });
   1479   }
   1480   visitComponentTree(payload) {
   1481     return this.hooks.callHook(DevToolsV6PluginAPIHookKeys.VISIT_COMPONENT_TREE, payload);
   1482   }
   1483   now() {
   1484     if (devtoolsState.highPerfModeEnabled) return 0;
   1485     return Date.now();
   1486   }
   1487   addTimelineLayer(options) {
   1488     this.hooks.callHook(DevToolsContextHookKeys.TIMELINE_LAYER_ADDED, {
   1489       options,
   1490       plugin: this.plugin
   1491     });
   1492   }
   1493   addTimelineEvent(options) {
   1494     if (devtoolsState.highPerfModeEnabled) return;
   1495     this.hooks.callHook(DevToolsContextHookKeys.TIMELINE_EVENT_ADDED, {
   1496       options,
   1497       plugin: this.plugin
   1498     });
   1499   }
   1500   getSettings(pluginId) {
   1501     return getPluginSettings(pluginId ?? this.plugin.descriptor.id, this.plugin.descriptor.settings);
   1502   }
   1503   getComponentInstances(app) {
   1504     return this.hooks.callHook(DevToolsContextHookKeys.GET_COMPONENT_INSTANCES, { app });
   1505   }
   1506   getComponentBounds(instance) {
   1507     return this.hooks.callHook(DevToolsContextHookKeys.GET_COMPONENT_BOUNDS, { instance });
   1508   }
   1509   getComponentName(instance) {
   1510     return this.hooks.callHook(DevToolsContextHookKeys.GET_COMPONENT_NAME, { instance });
   1511   }
   1512   highlightElement(instance) {
   1513     const uid = instance.__VUE_DEVTOOLS_NEXT_UID__;
   1514     return this.hooks.callHook(DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, { uid });
   1515   }
   1516   unhighlightElement() {
   1517     return this.hooks.callHook(DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT);
   1518   }
   1519 };
   1520 var DevToolsPluginAPI = DevToolsV6PluginAPI;
   1521 var UNDEFINED = "__vue_devtool_undefined__";
   1522 var INFINITY = "__vue_devtool_infinity__";
   1523 var NEGATIVE_INFINITY = "__vue_devtool_negative_infinity__";
   1524 var NAN = "__vue_devtool_nan__";
   1525 var tokenMap = {
   1526   [UNDEFINED]: "undefined",
   1527   [NAN]: "NaN",
   1528   [INFINITY]: "Infinity",
   1529   [NEGATIVE_INFINITY]: "-Infinity"
   1530 };
   1531 var reversedTokenMap = Object.entries(tokenMap).reduce((acc, [key, value]) => {
   1532   acc[value] = key;
   1533   return acc;
   1534 }, {});
   1535 target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__ ??= /* @__PURE__ */ new Set();
   1536 function setupDevToolsPlugin(pluginDescriptor, setupFn) {
   1537   return hook.setupDevToolsPlugin(pluginDescriptor, setupFn);
   1538 }
   1539 function callDevToolsPluginSetupFn(plugin, app) {
   1540   const [pluginDescriptor, setupFn] = plugin;
   1541   if (pluginDescriptor.app !== app) return;
   1542   const api = new DevToolsPluginAPI({
   1543     plugin: {
   1544       setupFn,
   1545       descriptor: pluginDescriptor
   1546     },
   1547     ctx: devtoolsContext
   1548   });
   1549   if (pluginDescriptor.packageName === "vuex") api.on.editInspectorState((payload) => {
   1550     api.sendInspectorState(payload.inspectorId);
   1551   });
   1552   setupFn(api);
   1553 }
   1554 function registerDevToolsPlugin(app, options) {
   1555   if (target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.has(app)) return;
   1556   if (devtoolsState.highPerfModeEnabled && !options?.inspectingComponent) return;
   1557   target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.add(app);
   1558   devtoolsPluginBuffer.forEach((plugin) => {
   1559     callDevToolsPluginSetupFn(plugin, app);
   1560   });
   1561 }
   1562 var ROUTER_KEY = "__VUE_DEVTOOLS_ROUTER__";
   1563 var ROUTER_INFO_KEY = "__VUE_DEVTOOLS_ROUTER_INFO__";
   1564 target[ROUTER_INFO_KEY] ??= {
   1565   currentRoute: null,
   1566   routes: []
   1567 };
   1568 target[ROUTER_KEY] ??= {};
   1569 var devtoolsRouterInfo = new Proxy(target[ROUTER_INFO_KEY], { get(target$1, property) {
   1570   return target[ROUTER_INFO_KEY][property];
   1571 } });
   1572 var devtoolsRouter = new Proxy(target[ROUTER_KEY], { get(target$2, property) {
   1573   if (property === "value") return target[ROUTER_KEY];
   1574 } });
   1575 function getRoutes(router) {
   1576   const routesMap = /* @__PURE__ */ new Map();
   1577   return (router?.getRoutes() || []).filter((i) => !routesMap.has(i.path) && routesMap.set(i.path, 1));
   1578 }
   1579 function filterRoutes(routes) {
   1580   return routes.map((item) => {
   1581     let { path, name, children, meta } = item;
   1582     if (children?.length) children = filterRoutes(children);
   1583     return {
   1584       path,
   1585       name,
   1586       children,
   1587       meta
   1588     };
   1589   });
   1590 }
   1591 function filterCurrentRoute(route) {
   1592   if (route) {
   1593     const { fullPath, hash, href, path, name, matched, params, query } = route;
   1594     return {
   1595       fullPath,
   1596       hash,
   1597       href,
   1598       path,
   1599       name,
   1600       params,
   1601       query,
   1602       matched: filterRoutes(matched)
   1603     };
   1604   }
   1605   return route;
   1606 }
   1607 function normalizeRouterInfo(appRecord, activeAppRecord2) {
   1608   function init() {
   1609     const router = appRecord.app?.config.globalProperties.$router;
   1610     const currentRoute = filterCurrentRoute(router?.currentRoute.value);
   1611     const routes = filterRoutes(getRoutes(router));
   1612     const c = console.warn;
   1613     console.warn = () => {
   1614     };
   1615     target[ROUTER_INFO_KEY] = {
   1616       currentRoute: currentRoute ? deepClone(currentRoute) : {},
   1617       routes: deepClone(routes)
   1618     };
   1619     target[ROUTER_KEY] = router;
   1620     console.warn = c;
   1621   }
   1622   init();
   1623   hook.on.componentUpdated(debounce(() => {
   1624     if (activeAppRecord2.value?.app !== appRecord.app) return;
   1625     init();
   1626     if (devtoolsState.highPerfModeEnabled) return;
   1627     devtoolsContext.hooks.callHook(DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, { state: target[ROUTER_INFO_KEY] });
   1628   }, 200));
   1629 }
   1630 function createDevToolsApi(hooks2) {
   1631   return {
   1632     async getInspectorTree(payload) {
   1633       const _payload = {
   1634         ...payload,
   1635         app: activeAppRecord.value.app,
   1636         rootNodes: []
   1637       };
   1638       await new Promise((resolve) => {
   1639         hooks2.callHookWith(async (callbacks) => {
   1640           await Promise.all(callbacks.map((cb) => cb(_payload)));
   1641           resolve();
   1642         }, DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_TREE);
   1643       });
   1644       return _payload.rootNodes;
   1645     },
   1646     async getInspectorState(payload) {
   1647       const _payload = {
   1648         ...payload,
   1649         app: activeAppRecord.value.app,
   1650         state: null
   1651       };
   1652       const ctx = { currentTab: `custom-inspector:${payload.inspectorId}` };
   1653       await new Promise((resolve) => {
   1654         hooks2.callHookWith(async (callbacks) => {
   1655           await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
   1656           resolve();
   1657         }, DevToolsV6PluginAPIHookKeys.GET_INSPECTOR_STATE);
   1658       });
   1659       return _payload.state;
   1660     },
   1661     editInspectorState(payload) {
   1662       const stateEditor2 = new StateEditor();
   1663       const _payload = {
   1664         ...payload,
   1665         app: activeAppRecord.value.app,
   1666         set: (obj, path = payload.path, value = payload.state.value, cb) => {
   1667           stateEditor2.set(obj, path, value, cb || stateEditor2.createDefaultSetCallback(payload.state));
   1668         }
   1669       };
   1670       hooks2.callHookWith((callbacks) => {
   1671         callbacks.forEach((cb) => cb(_payload));
   1672       }, DevToolsV6PluginAPIHookKeys.EDIT_INSPECTOR_STATE);
   1673     },
   1674     sendInspectorState(inspectorId) {
   1675       const inspector = getInspector(inspectorId);
   1676       hooks2.callHook(DevToolsContextHookKeys.SEND_INSPECTOR_STATE, {
   1677         inspectorId,
   1678         plugin: {
   1679           descriptor: inspector.descriptor,
   1680           setupFn: () => ({})
   1681         }
   1682       });
   1683     },
   1684     inspectComponentInspector() {
   1685       return inspectComponentHighLighter();
   1686     },
   1687     cancelInspectComponentInspector() {
   1688       return cancelInspectComponentHighLighter();
   1689     },
   1690     getComponentRenderCode(id) {
   1691       const instance = getComponentInstance(activeAppRecord.value, id);
   1692       if (instance) return !(typeof instance?.type === "function") ? instance.render.toString() : instance.type.toString();
   1693     },
   1694     scrollToComponent(id) {
   1695       return scrollToComponent({ id });
   1696     },
   1697     openInEditor,
   1698     getVueInspector: getComponentInspector,
   1699     toggleApp(id, options) {
   1700       const appRecord = devtoolsAppRecords.value.find((record) => record.id === id);
   1701       if (appRecord) {
   1702         setActiveAppRecordId(id);
   1703         setActiveAppRecord(appRecord);
   1704         normalizeRouterInfo(appRecord, activeAppRecord);
   1705         callInspectorUpdatedHook();
   1706         registerDevToolsPlugin(appRecord.app, options);
   1707       }
   1708     },
   1709     inspectDOM(instanceId) {
   1710       const instance = getComponentInstance(activeAppRecord.value, instanceId);
   1711       if (instance) {
   1712         const [el] = getRootElementsFromComponentInstance(instance);
   1713         if (el) target.__VUE_DEVTOOLS_INSPECT_DOM_TARGET__ = el;
   1714       }
   1715     },
   1716     updatePluginSettings(pluginId, key, value) {
   1717       setPluginSettings(pluginId, key, value);
   1718     },
   1719     getPluginSettings(pluginId) {
   1720       return {
   1721         options: getPluginSettingsOptions(pluginId),
   1722         values: getPluginSettings(pluginId)
   1723       };
   1724     }
   1725   };
   1726 }
   1727 target.__VUE_DEVTOOLS_ENV__ ??= { vitePluginDetected: false };
   1728 var hooks = createDevToolsCtxHooks();
   1729 target.__VUE_DEVTOOLS_KIT_CONTEXT__ ??= {
   1730   hooks,
   1731   get state() {
   1732     return {
   1733       ...devtoolsState,
   1734       activeAppRecordId: activeAppRecord.id,
   1735       activeAppRecord: activeAppRecord.value,
   1736       appRecords: devtoolsAppRecords.value
   1737     };
   1738   },
   1739   api: createDevToolsApi(hooks)
   1740 };
   1741 var devtoolsContext = target.__VUE_DEVTOOLS_KIT_CONTEXT__;
   1742 var require_speakingurl$1 = __commonJSMin2(((exports, module) => {
   1743   (function(root) {
   1744     "use strict";
   1745     var charMap = {
   1746       "À": "A",
   1747       "Á": "A",
   1748       "Â": "A",
   1749       "Ã": "A",
   1750       "Ä": "Ae",
   1751       "Å": "A",
   1752       "Æ": "AE",
   1753       "Ç": "C",
   1754       "È": "E",
   1755       "É": "E",
   1756       "Ê": "E",
   1757       "Ë": "E",
   1758       "Ì": "I",
   1759       "Í": "I",
   1760       "Î": "I",
   1761       "Ï": "I",
   1762       "Ð": "D",
   1763       "Ñ": "N",
   1764       "Ò": "O",
   1765       "Ó": "O",
   1766       "Ô": "O",
   1767       "Õ": "O",
   1768       "Ö": "Oe",
   1769       "Ő": "O",
   1770       "Ø": "O",
   1771       "Ù": "U",
   1772       "Ú": "U",
   1773       "Û": "U",
   1774       "Ü": "Ue",
   1775       "Ű": "U",
   1776       "Ý": "Y",
   1777       "Þ": "TH",
   1778       "ß": "ss",
   1779       "à": "a",
   1780       "á": "a",
   1781       "â": "a",
   1782       "ã": "a",
   1783       "ä": "ae",
   1784       "å": "a",
   1785       "æ": "ae",
   1786       "ç": "c",
   1787       "è": "e",
   1788       "é": "e",
   1789       "ê": "e",
   1790       "ë": "e",
   1791       "ì": "i",
   1792       "í": "i",
   1793       "î": "i",
   1794       "ï": "i",
   1795       "ð": "d",
   1796       "ñ": "n",
   1797       "ò": "o",
   1798       "ó": "o",
   1799       "ô": "o",
   1800       "õ": "o",
   1801       "ö": "oe",
   1802       "ő": "o",
   1803       "ø": "o",
   1804       "ù": "u",
   1805       "ú": "u",
   1806       "û": "u",
   1807       "ü": "ue",
   1808       "ű": "u",
   1809       "ý": "y",
   1810       "þ": "th",
   1811       "ÿ": "y",
   1812       "ẞ": "SS",
   1813       "ا": "a",
   1814       "أ": "a",
   1815       "إ": "i",
   1816       "آ": "aa",
   1817       "ؤ": "u",
   1818       "ئ": "e",
   1819       "ء": "a",
   1820       "ب": "b",
   1821       "ت": "t",
   1822       "ث": "th",
   1823       "ج": "j",
   1824       "ح": "h",
   1825       "خ": "kh",
   1826       "د": "d",
   1827       "ذ": "th",
   1828       "ر": "r",
   1829       "ز": "z",
   1830       "س": "s",
   1831       "ش": "sh",
   1832       "ص": "s",
   1833       "ض": "dh",
   1834       "ط": "t",
   1835       "ظ": "z",
   1836       "ع": "a",
   1837       "غ": "gh",
   1838       "ف": "f",
   1839       "ق": "q",
   1840       "ك": "k",
   1841       "ل": "l",
   1842       "م": "m",
   1843       "ن": "n",
   1844       "ه": "h",
   1845       "و": "w",
   1846       "ي": "y",
   1847       "ى": "a",
   1848       "ة": "h",
   1849       "ﻻ": "la",
   1850       "ﻷ": "laa",
   1851       "ﻹ": "lai",
   1852       "ﻵ": "laa",
   1853       "گ": "g",
   1854       "چ": "ch",
   1855       "پ": "p",
   1856       "ژ": "zh",
   1857       "ک": "k",
   1858       "ی": "y",
   1859       "َ": "a",
   1860       "ً": "an",
   1861       "ِ": "e",
   1862       "ٍ": "en",
   1863       "ُ": "u",
   1864       "ٌ": "on",
   1865       "ْ": "",
   1866       "٠": "0",
   1867       "١": "1",
   1868       "٢": "2",
   1869       "٣": "3",
   1870       "٤": "4",
   1871       "٥": "5",
   1872       "٦": "6",
   1873       "٧": "7",
   1874       "٨": "8",
   1875       "٩": "9",
   1876       "۰": "0",
   1877       "۱": "1",
   1878       "۲": "2",
   1879       "۳": "3",
   1880       "۴": "4",
   1881       "۵": "5",
   1882       "۶": "6",
   1883       "۷": "7",
   1884       "۸": "8",
   1885       "۹": "9",
   1886       "က": "k",
   1887       "ခ": "kh",
   1888       "ဂ": "g",
   1889       "ဃ": "ga",
   1890       "င": "ng",
   1891       "စ": "s",
   1892       "ဆ": "sa",
   1893       "ဇ": "z",
   1894       "စျ": "za",
   1895       "ည": "ny",
   1896       "ဋ": "t",
   1897       "ဌ": "ta",
   1898       "ဍ": "d",
   1899       "ဎ": "da",
   1900       "ဏ": "na",
   1901       "တ": "t",
   1902       "ထ": "ta",
   1903       "ဒ": "d",
   1904       "ဓ": "da",
   1905       "န": "n",
   1906       "ပ": "p",
   1907       "ဖ": "pa",
   1908       "ဗ": "b",
   1909       "ဘ": "ba",
   1910       "မ": "m",
   1911       "ယ": "y",
   1912       "ရ": "ya",
   1913       "လ": "l",
   1914       "ဝ": "w",
   1915       "သ": "th",
   1916       "ဟ": "h",
   1917       "ဠ": "la",
   1918       "အ": "a",
   1919       "ြ": "y",
   1920       "ျ": "ya",
   1921       "ွ": "w",
   1922       "ြွ": "yw",
   1923       "ျွ": "ywa",
   1924       "ှ": "h",
   1925       "ဧ": "e",
   1926       "၏": "-e",
   1927       "ဣ": "i",
   1928       "ဤ": "-i",
   1929       "ဉ": "u",
   1930       "ဦ": "-u",
   1931       "ဩ": "aw",
   1932       "သြော": "aw",
   1933       "ဪ": "aw",
   1934       "၀": "0",
   1935       "၁": "1",
   1936       "၂": "2",
   1937       "၃": "3",
   1938       "၄": "4",
   1939       "၅": "5",
   1940       "၆": "6",
   1941       "၇": "7",
   1942       "၈": "8",
   1943       "၉": "9",
   1944       "္": "",
   1945       "့": "",
   1946       "း": "",
   1947       "č": "c",
   1948       "ď": "d",
   1949       "ě": "e",
   1950       "ň": "n",
   1951       "ř": "r",
   1952       "š": "s",
   1953       "ť": "t",
   1954       "ů": "u",
   1955       "ž": "z",
   1956       "Č": "C",
   1957       "Ď": "D",
   1958       "Ě": "E",
   1959       "Ň": "N",
   1960       "Ř": "R",
   1961       "Š": "S",
   1962       "Ť": "T",
   1963       "Ů": "U",
   1964       "Ž": "Z",
   1965       "ހ": "h",
   1966       "ށ": "sh",
   1967       "ނ": "n",
   1968       "ރ": "r",
   1969       "ބ": "b",
   1970       "ޅ": "lh",
   1971       "ކ": "k",
   1972       "އ": "a",
   1973       "ވ": "v",
   1974       "މ": "m",
   1975       "ފ": "f",
   1976       "ދ": "dh",
   1977       "ތ": "th",
   1978       "ލ": "l",
   1979       "ގ": "g",
   1980       "ޏ": "gn",
   1981       "ސ": "s",
   1982       "ޑ": "d",
   1983       "ޒ": "z",
   1984       "ޓ": "t",
   1985       "ޔ": "y",
   1986       "ޕ": "p",
   1987       "ޖ": "j",
   1988       "ޗ": "ch",
   1989       "ޘ": "tt",
   1990       "ޙ": "hh",
   1991       "ޚ": "kh",
   1992       "ޛ": "th",
   1993       "ޜ": "z",
   1994       "ޝ": "sh",
   1995       "ޞ": "s",
   1996       "ޟ": "d",
   1997       "ޠ": "t",
   1998       "ޡ": "z",
   1999       "ޢ": "a",
   2000       "ޣ": "gh",
   2001       "ޤ": "q",
   2002       "ޥ": "w",
   2003       "ަ": "a",
   2004       "ާ": "aa",
   2005       "ި": "i",
   2006       "ީ": "ee",
   2007       "ު": "u",
   2008       "ޫ": "oo",
   2009       "ެ": "e",
   2010       "ޭ": "ey",
   2011       "ޮ": "o",
   2012       "ޯ": "oa",
   2013       "ް": "",
   2014       "ა": "a",
   2015       "ბ": "b",
   2016       "გ": "g",
   2017       "დ": "d",
   2018       "ე": "e",
   2019       "ვ": "v",
   2020       "ზ": "z",
   2021       "თ": "t",
   2022       "ი": "i",
   2023       "კ": "k",
   2024       "ლ": "l",
   2025       "მ": "m",
   2026       "ნ": "n",
   2027       "ო": "o",
   2028       "პ": "p",
   2029       "ჟ": "zh",
   2030       "რ": "r",
   2031       "ს": "s",
   2032       "ტ": "t",
   2033       "უ": "u",
   2034       "ფ": "p",
   2035       "ქ": "k",
   2036       "ღ": "gh",
   2037       "ყ": "q",
   2038       "შ": "sh",
   2039       "ჩ": "ch",
   2040       "ც": "ts",
   2041       "ძ": "dz",
   2042       "წ": "ts",
   2043       "ჭ": "ch",
   2044       "ხ": "kh",
   2045       "ჯ": "j",
   2046       "ჰ": "h",
   2047       "α": "a",
   2048       "β": "v",
   2049       "γ": "g",
   2050       "δ": "d",
   2051       "ε": "e",
   2052       "ζ": "z",
   2053       "η": "i",
   2054       "θ": "th",
   2055       "ι": "i",
   2056       "κ": "k",
   2057       "λ": "l",
   2058       "μ": "m",
   2059       "ν": "n",
   2060       "ξ": "ks",
   2061       "ο": "o",
   2062       "π": "p",
   2063       "ρ": "r",
   2064       "σ": "s",
   2065       "τ": "t",
   2066       "υ": "y",
   2067       "φ": "f",
   2068       "χ": "x",
   2069       "ψ": "ps",
   2070       "ω": "o",
   2071       "ά": "a",
   2072       "έ": "e",
   2073       "ί": "i",
   2074       "ό": "o",
   2075       "ύ": "y",
   2076       "ή": "i",
   2077       "ώ": "o",
   2078       "ς": "s",
   2079       "ϊ": "i",
   2080       "ΰ": "y",
   2081       "ϋ": "y",
   2082       "ΐ": "i",
   2083       "Α": "A",
   2084       "Β": "B",
   2085       "Γ": "G",
   2086       "Δ": "D",
   2087       "Ε": "E",
   2088       "Ζ": "Z",
   2089       "Η": "I",
   2090       "Θ": "TH",
   2091       "Ι": "I",
   2092       "Κ": "K",
   2093       "Λ": "L",
   2094       "Μ": "M",
   2095       "Ν": "N",
   2096       "Ξ": "KS",
   2097       "Ο": "O",
   2098       "Π": "P",
   2099       "Ρ": "R",
   2100       "Σ": "S",
   2101       "Τ": "T",
   2102       "Υ": "Y",
   2103       "Φ": "F",
   2104       "Χ": "X",
   2105       "Ψ": "PS",
   2106       "Ω": "O",
   2107       "Ά": "A",
   2108       "Έ": "E",
   2109       "Ί": "I",
   2110       "Ό": "O",
   2111       "Ύ": "Y",
   2112       "Ή": "I",
   2113       "Ώ": "O",
   2114       "Ϊ": "I",
   2115       "Ϋ": "Y",
   2116       "ā": "a",
   2117       "ē": "e",
   2118       "ģ": "g",
   2119       "ī": "i",
   2120       "ķ": "k",
   2121       "ļ": "l",
   2122       "ņ": "n",
   2123       "ū": "u",
   2124       "Ā": "A",
   2125       "Ē": "E",
   2126       "Ģ": "G",
   2127       "Ī": "I",
   2128       "Ķ": "k",
   2129       "Ļ": "L",
   2130       "Ņ": "N",
   2131       "Ū": "U",
   2132       "Ќ": "Kj",
   2133       "ќ": "kj",
   2134       "Љ": "Lj",
   2135       "љ": "lj",
   2136       "Њ": "Nj",
   2137       "њ": "nj",
   2138       "Тс": "Ts",
   2139       "тс": "ts",
   2140       "ą": "a",
   2141       "ć": "c",
   2142       "ę": "e",
   2143       "ł": "l",
   2144       "ń": "n",
   2145       "ś": "s",
   2146       "ź": "z",
   2147       "ż": "z",
   2148       "Ą": "A",
   2149       "Ć": "C",
   2150       "Ę": "E",
   2151       "Ł": "L",
   2152       "Ń": "N",
   2153       "Ś": "S",
   2154       "Ź": "Z",
   2155       "Ż": "Z",
   2156       "Є": "Ye",
   2157       "І": "I",
   2158       "Ї": "Yi",
   2159       "Ґ": "G",
   2160       "є": "ye",
   2161       "і": "i",
   2162       "ї": "yi",
   2163       "ґ": "g",
   2164       "ă": "a",
   2165       "Ă": "A",
   2166       "ș": "s",
   2167       "Ș": "S",
   2168       "ț": "t",
   2169       "Ț": "T",
   2170       "ţ": "t",
   2171       "Ţ": "T",
   2172       "а": "a",
   2173       "б": "b",
   2174       "в": "v",
   2175       "г": "g",
   2176       "д": "d",
   2177       "е": "e",
   2178       "ё": "yo",
   2179       "ж": "zh",
   2180       "з": "z",
   2181       "и": "i",
   2182       "й": "i",
   2183       "к": "k",
   2184       "л": "l",
   2185       "м": "m",
   2186       "н": "n",
   2187       "о": "o",
   2188       "п": "p",
   2189       "р": "r",
   2190       "с": "s",
   2191       "т": "t",
   2192       "у": "u",
   2193       "ф": "f",
   2194       "х": "kh",
   2195       "ц": "c",
   2196       "ч": "ch",
   2197       "ш": "sh",
   2198       "щ": "sh",
   2199       "ъ": "",
   2200       "ы": "y",
   2201       "ь": "",
   2202       "э": "e",
   2203       "ю": "yu",
   2204       "я": "ya",
   2205       "А": "A",
   2206       "Б": "B",
   2207       "В": "V",
   2208       "Г": "G",
   2209       "Д": "D",
   2210       "Е": "E",
   2211       "Ё": "Yo",
   2212       "Ж": "Zh",
   2213       "З": "Z",
   2214       "И": "I",
   2215       "Й": "I",
   2216       "К": "K",
   2217       "Л": "L",
   2218       "М": "M",
   2219       "Н": "N",
   2220       "О": "O",
   2221       "П": "P",
   2222       "Р": "R",
   2223       "С": "S",
   2224       "Т": "T",
   2225       "У": "U",
   2226       "Ф": "F",
   2227       "Х": "Kh",
   2228       "Ц": "C",
   2229       "Ч": "Ch",
   2230       "Ш": "Sh",
   2231       "Щ": "Sh",
   2232       "Ъ": "",
   2233       "Ы": "Y",
   2234       "Ь": "",
   2235       "Э": "E",
   2236       "Ю": "Yu",
   2237       "Я": "Ya",
   2238       "ђ": "dj",
   2239       "ј": "j",
   2240       "ћ": "c",
   2241       "џ": "dz",
   2242       "Ђ": "Dj",
   2243       "Ј": "j",
   2244       "Ћ": "C",
   2245       "Џ": "Dz",
   2246       "ľ": "l",
   2247       "ĺ": "l",
   2248       "ŕ": "r",
   2249       "Ľ": "L",
   2250       "Ĺ": "L",
   2251       "Ŕ": "R",
   2252       "ş": "s",
   2253       "Ş": "S",
   2254       "ı": "i",
   2255       "İ": "I",
   2256       "ğ": "g",
   2257       "Ğ": "G",
   2258       "ả": "a",
   2259       "Ả": "A",
   2260       "ẳ": "a",
   2261       "Ẳ": "A",
   2262       "ẩ": "a",
   2263       "Ẩ": "A",
   2264       "đ": "d",
   2265       "Đ": "D",
   2266       "ẹ": "e",
   2267       "Ẹ": "E",
   2268       "ẽ": "e",
   2269       "Ẽ": "E",
   2270       "ẻ": "e",
   2271       "Ẻ": "E",
   2272       "ế": "e",
   2273       "Ế": "E",
   2274       "ề": "e",
   2275       "Ề": "E",
   2276       "ệ": "e",
   2277       "Ệ": "E",
   2278       "ễ": "e",
   2279       "Ễ": "E",
   2280       "ể": "e",
   2281       "Ể": "E",
   2282       "ỏ": "o",
   2283       "ọ": "o",
   2284       "Ọ": "o",
   2285       "ố": "o",
   2286       "Ố": "O",
   2287       "ồ": "o",
   2288       "Ồ": "O",
   2289       "ổ": "o",
   2290       "Ổ": "O",
   2291       "ộ": "o",
   2292       "Ộ": "O",
   2293       "ỗ": "o",
   2294       "Ỗ": "O",
   2295       "ơ": "o",
   2296       "Ơ": "O",
   2297       "ớ": "o",
   2298       "Ớ": "O",
   2299       "ờ": "o",
   2300       "Ờ": "O",
   2301       "ợ": "o",
   2302       "Ợ": "O",
   2303       "ỡ": "o",
   2304       "Ỡ": "O",
   2305       "Ở": "o",
   2306       "ở": "o",
   2307       "ị": "i",
   2308       "Ị": "I",
   2309       "ĩ": "i",
   2310       "Ĩ": "I",
   2311       "ỉ": "i",
   2312       "Ỉ": "i",
   2313       "ủ": "u",
   2314       "Ủ": "U",
   2315       "ụ": "u",
   2316       "Ụ": "U",
   2317       "ũ": "u",
   2318       "Ũ": "U",
   2319       "ư": "u",
   2320       "Ư": "U",
   2321       "ứ": "u",
   2322       "Ứ": "U",
   2323       "ừ": "u",
   2324       "Ừ": "U",
   2325       "ự": "u",
   2326       "Ự": "U",
   2327       "ữ": "u",
   2328       "Ữ": "U",
   2329       "ử": "u",
   2330       "Ử": "ư",
   2331       "ỷ": "y",
   2332       "Ỷ": "y",
   2333       "ỳ": "y",
   2334       "Ỳ": "Y",
   2335       "ỵ": "y",
   2336       "Ỵ": "Y",
   2337       "ỹ": "y",
   2338       "Ỹ": "Y",
   2339       "ạ": "a",
   2340       "Ạ": "A",
   2341       "ấ": "a",
   2342       "Ấ": "A",
   2343       "ầ": "a",
   2344       "Ầ": "A",
   2345       "ậ": "a",
   2346       "Ậ": "A",
   2347       "ẫ": "a",
   2348       "Ẫ": "A",
   2349       "ắ": "a",
   2350       "Ắ": "A",
   2351       "ằ": "a",
   2352       "Ằ": "A",
   2353       "ặ": "a",
   2354       "Ặ": "A",
   2355       "ẵ": "a",
   2356       "Ẵ": "A",
   2357       "⓪": "0",
   2358       "①": "1",
   2359       "②": "2",
   2360       "③": "3",
   2361       "④": "4",
   2362       "⑤": "5",
   2363       "⑥": "6",
   2364       "⑦": "7",
   2365       "⑧": "8",
   2366       "⑨": "9",
   2367       "⑩": "10",
   2368       "⑪": "11",
   2369       "⑫": "12",
   2370       "⑬": "13",
   2371       "⑭": "14",
   2372       "⑮": "15",
   2373       "⑯": "16",
   2374       "⑰": "17",
   2375       "⑱": "18",
   2376       "⑲": "18",
   2377       "⑳": "18",
   2378       "⓵": "1",
   2379       "⓶": "2",
   2380       "⓷": "3",
   2381       "⓸": "4",
   2382       "⓹": "5",
   2383       "⓺": "6",
   2384       "⓻": "7",
   2385       "⓼": "8",
   2386       "⓽": "9",
   2387       "⓾": "10",
   2388       "⓿": "0",
   2389       "⓫": "11",
   2390       "⓬": "12",
   2391       "⓭": "13",
   2392       "⓮": "14",
   2393       "⓯": "15",
   2394       "⓰": "16",
   2395       "⓱": "17",
   2396       "⓲": "18",
   2397       "⓳": "19",
   2398       "⓴": "20",
   2399       "Ⓐ": "A",
   2400       "Ⓑ": "B",
   2401       "Ⓒ": "C",
   2402       "Ⓓ": "D",
   2403       "Ⓔ": "E",
   2404       "Ⓕ": "F",
   2405       "Ⓖ": "G",
   2406       "Ⓗ": "H",
   2407       "Ⓘ": "I",
   2408       "Ⓙ": "J",
   2409       "Ⓚ": "K",
   2410       "Ⓛ": "L",
   2411       "Ⓜ": "M",
   2412       "Ⓝ": "N",
   2413       "Ⓞ": "O",
   2414       "Ⓟ": "P",
   2415       "Ⓠ": "Q",
   2416       "Ⓡ": "R",
   2417       "Ⓢ": "S",
   2418       "Ⓣ": "T",
   2419       "Ⓤ": "U",
   2420       "Ⓥ": "V",
   2421       "Ⓦ": "W",
   2422       "Ⓧ": "X",
   2423       "Ⓨ": "Y",
   2424       "Ⓩ": "Z",
   2425       "ⓐ": "a",
   2426       "ⓑ": "b",
   2427       "ⓒ": "c",
   2428       "ⓓ": "d",
   2429       "ⓔ": "e",
   2430       "ⓕ": "f",
   2431       "ⓖ": "g",
   2432       "ⓗ": "h",
   2433       "ⓘ": "i",
   2434       "ⓙ": "j",
   2435       "ⓚ": "k",
   2436       "ⓛ": "l",
   2437       "ⓜ": "m",
   2438       "ⓝ": "n",
   2439       "ⓞ": "o",
   2440       "ⓟ": "p",
   2441       "ⓠ": "q",
   2442       "ⓡ": "r",
   2443       "ⓢ": "s",
   2444       "ⓣ": "t",
   2445       "ⓤ": "u",
   2446       "ⓦ": "v",
   2447       "ⓥ": "w",
   2448       "ⓧ": "x",
   2449       "ⓨ": "y",
   2450       "ⓩ": "z",
   2451       "“": '"',
   2452       "”": '"',
   2453       "‘": "'",
   2454       "’": "'",
   2455       "∂": "d",
   2456       "ƒ": "f",
   2457       "™": "(TM)",
   2458       "©": "(C)",
   2459       "œ": "oe",
   2460       "Œ": "OE",
   2461       "®": "(R)",
   2462       "†": "+",
   2463       "℠": "(SM)",
   2464       "…": "...",
   2465       "˚": "o",
   2466       "º": "o",
   2467       "ª": "a",
   2468       "•": "*",
   2469       "၊": ",",
   2470       "။": ".",
   2471       "$": "USD",
   2472       "€": "EUR",
   2473       "₢": "BRN",
   2474       "₣": "FRF",
   2475       "£": "GBP",
   2476       "₤": "ITL",
   2477       "₦": "NGN",
   2478       "₧": "ESP",
   2479       "₩": "KRW",
   2480       "₪": "ILS",
   2481       "₫": "VND",
   2482       "₭": "LAK",
   2483       "₮": "MNT",
   2484       "₯": "GRD",
   2485       "₱": "ARS",
   2486       "₲": "PYG",
   2487       "₳": "ARA",
   2488       "₴": "UAH",
   2489       "₵": "GHS",
   2490       "¢": "cent",
   2491       "¥": "CNY",
   2492       "元": "CNY",
   2493       "円": "YEN",
   2494       "﷼": "IRR",
   2495       "₠": "EWE",
   2496       "฿": "THB",
   2497       "₨": "INR",
   2498       "₹": "INR",
   2499       "₰": "PF",
   2500       "₺": "TRY",
   2501       "؋": "AFN",
   2502       "₼": "AZN",
   2503       "лв": "BGN",
   2504       "៛": "KHR",
   2505       "₡": "CRC",
   2506       "₸": "KZT",
   2507       "ден": "MKD",
   2508       "zł": "PLN",
   2509       "₽": "RUB",
   2510       "₾": "GEL"
   2511     };
   2512     var lookAheadCharArray = ["်", "ް"];
   2513     var diatricMap = {
   2514       "ာ": "a",
   2515       "ါ": "a",
   2516       "ေ": "e",
   2517       "ဲ": "e",
   2518       "ိ": "i",
   2519       "ီ": "i",
   2520       "ို": "o",
   2521       "ု": "u",
   2522       "ူ": "u",
   2523       "ေါင်": "aung",
   2524       "ော": "aw",
   2525       "ော်": "aw",
   2526       "ေါ": "aw",
   2527       "ေါ်": "aw",
   2528       "်": "်",
   2529       "က်": "et",
   2530       "ိုက်": "aik",
   2531       "ောက်": "auk",
   2532       "င်": "in",
   2533       "ိုင်": "aing",
   2534       "ောင်": "aung",
   2535       "စ်": "it",
   2536       "ည်": "i",
   2537       "တ်": "at",
   2538       "ိတ်": "eik",
   2539       "ုတ်": "ok",
   2540       "ွတ်": "ut",
   2541       "ေတ်": "it",
   2542       "ဒ်": "d",
   2543       "ိုဒ်": "ok",
   2544       "ုဒ်": "ait",
   2545       "န်": "an",
   2546       "ာန်": "an",
   2547       "ိန်": "ein",
   2548       "ုန်": "on",
   2549       "ွန်": "un",
   2550       "ပ်": "at",
   2551       "ိပ်": "eik",
   2552       "ုပ်": "ok",
   2553       "ွပ်": "ut",
   2554       "န်ုပ်": "nub",
   2555       "မ်": "an",
   2556       "ိမ်": "ein",
   2557       "ုမ်": "on",
   2558       "ွမ်": "un",
   2559       "ယ်": "e",
   2560       "ိုလ်": "ol",
   2561       "ဉ်": "in",
   2562       "ံ": "an",
   2563       "ိံ": "ein",
   2564       "ုံ": "on",
   2565       "ައް": "ah",
   2566       "ަށް": "ah"
   2567     };
   2568     var langCharMap = {
   2569       "en": {},
   2570       "az": {
   2571         "ç": "c",
   2572         "ə": "e",
   2573         "ğ": "g",
   2574         "ı": "i",
   2575         "ö": "o",
   2576         "ş": "s",
   2577         "ü": "u",
   2578         "Ç": "C",
   2579         "Ə": "E",
   2580         "Ğ": "G",
   2581         "İ": "I",
   2582         "Ö": "O",
   2583         "Ş": "S",
   2584         "Ü": "U"
   2585       },
   2586       "cs": {
   2587         "č": "c",
   2588         "ď": "d",
   2589         "ě": "e",
   2590         "ň": "n",
   2591         "ř": "r",
   2592         "š": "s",
   2593         "ť": "t",
   2594         "ů": "u",
   2595         "ž": "z",
   2596         "Č": "C",
   2597         "Ď": "D",
   2598         "Ě": "E",
   2599         "Ň": "N",
   2600         "Ř": "R",
   2601         "Š": "S",
   2602         "Ť": "T",
   2603         "Ů": "U",
   2604         "Ž": "Z"
   2605       },
   2606       "fi": {
   2607         "ä": "a",
   2608         "Ä": "A",
   2609         "ö": "o",
   2610         "Ö": "O"
   2611       },
   2612       "hu": {
   2613         "ä": "a",
   2614         "Ä": "A",
   2615         "ö": "o",
   2616         "Ö": "O",
   2617         "ü": "u",
   2618         "Ü": "U",
   2619         "ű": "u",
   2620         "Ű": "U"
   2621       },
   2622       "lt": {
   2623         "ą": "a",
   2624         "č": "c",
   2625         "ę": "e",
   2626         "ė": "e",
   2627         "į": "i",
   2628         "š": "s",
   2629         "ų": "u",
   2630         "ū": "u",
   2631         "ž": "z",
   2632         "Ą": "A",
   2633         "Č": "C",
   2634         "Ę": "E",
   2635         "Ė": "E",
   2636         "Į": "I",
   2637         "Š": "S",
   2638         "Ų": "U",
   2639         "Ū": "U"
   2640       },
   2641       "lv": {
   2642         "ā": "a",
   2643         "č": "c",
   2644         "ē": "e",
   2645         "ģ": "g",
   2646         "ī": "i",
   2647         "ķ": "k",
   2648         "ļ": "l",
   2649         "ņ": "n",
   2650         "š": "s",
   2651         "ū": "u",
   2652         "ž": "z",
   2653         "Ā": "A",
   2654         "Č": "C",
   2655         "Ē": "E",
   2656         "Ģ": "G",
   2657         "Ī": "i",
   2658         "Ķ": "k",
   2659         "Ļ": "L",
   2660         "Ņ": "N",
   2661         "Š": "S",
   2662         "Ū": "u",
   2663         "Ž": "Z"
   2664       },
   2665       "pl": {
   2666         "ą": "a",
   2667         "ć": "c",
   2668         "ę": "e",
   2669         "ł": "l",
   2670         "ń": "n",
   2671         "ó": "o",
   2672         "ś": "s",
   2673         "ź": "z",
   2674         "ż": "z",
   2675         "Ą": "A",
   2676         "Ć": "C",
   2677         "Ę": "e",
   2678         "Ł": "L",
   2679         "Ń": "N",
   2680         "Ó": "O",
   2681         "Ś": "S",
   2682         "Ź": "Z",
   2683         "Ż": "Z"
   2684       },
   2685       "sv": {
   2686         "ä": "a",
   2687         "Ä": "A",
   2688         "ö": "o",
   2689         "Ö": "O"
   2690       },
   2691       "sk": {
   2692         "ä": "a",
   2693         "Ä": "A"
   2694       },
   2695       "sr": {
   2696         "љ": "lj",
   2697         "њ": "nj",
   2698         "Љ": "Lj",
   2699         "Њ": "Nj",
   2700         "đ": "dj",
   2701         "Đ": "Dj"
   2702       },
   2703       "tr": {
   2704         "Ü": "U",
   2705         "Ö": "O",
   2706         "ü": "u",
   2707         "ö": "o"
   2708       }
   2709     };
   2710     var symbolMap = {
   2711       "ar": {
   2712         "∆": "delta",
   2713         "∞": "la-nihaya",
   2714         "♥": "hob",
   2715         "&": "wa",
   2716         "|": "aw",
   2717         "<": "aqal-men",
   2718         ">": "akbar-men",
   2719         "∑": "majmou",
   2720         "¤": "omla"
   2721       },
   2722       "az": {},
   2723       "ca": {
   2724         "∆": "delta",
   2725         "∞": "infinit",
   2726         "♥": "amor",
   2727         "&": "i",
   2728         "|": "o",
   2729         "<": "menys que",
   2730         ">": "mes que",
   2731         "∑": "suma dels",
   2732         "¤": "moneda"
   2733       },
   2734       "cs": {
   2735         "∆": "delta",
   2736         "∞": "nekonecno",
   2737         "♥": "laska",
   2738         "&": "a",
   2739         "|": "nebo",
   2740         "<": "mensi nez",
   2741         ">": "vetsi nez",
   2742         "∑": "soucet",
   2743         "¤": "mena"
   2744       },
   2745       "de": {
   2746         "∆": "delta",
   2747         "∞": "unendlich",
   2748         "♥": "Liebe",
   2749         "&": "und",
   2750         "|": "oder",
   2751         "<": "kleiner als",
   2752         ">": "groesser als",
   2753         "∑": "Summe von",
   2754         "¤": "Waehrung"
   2755       },
   2756       "dv": {
   2757         "∆": "delta",
   2758         "∞": "kolunulaa",
   2759         "♥": "loabi",
   2760         "&": "aai",
   2761         "|": "noonee",
   2762         "<": "ah vure kuda",
   2763         ">": "ah vure bodu",
   2764         "∑": "jumula",
   2765         "¤": "faisaa"
   2766       },
   2767       "en": {
   2768         "∆": "delta",
   2769         "∞": "infinity",
   2770         "♥": "love",
   2771         "&": "and",
   2772         "|": "or",
   2773         "<": "less than",
   2774         ">": "greater than",
   2775         "∑": "sum",
   2776         "¤": "currency"
   2777       },
   2778       "es": {
   2779         "∆": "delta",
   2780         "∞": "infinito",
   2781         "♥": "amor",
   2782         "&": "y",
   2783         "|": "u",
   2784         "<": "menos que",
   2785         ">": "mas que",
   2786         "∑": "suma de los",
   2787         "¤": "moneda"
   2788       },
   2789       "fa": {
   2790         "∆": "delta",
   2791         "∞": "bi-nahayat",
   2792         "♥": "eshgh",
   2793         "&": "va",
   2794         "|": "ya",
   2795         "<": "kamtar-az",
   2796         ">": "bishtar-az",
   2797         "∑": "majmooe",
   2798         "¤": "vahed"
   2799       },
   2800       "fi": {
   2801         "∆": "delta",
   2802         "∞": "aarettomyys",
   2803         "♥": "rakkaus",
   2804         "&": "ja",
   2805         "|": "tai",
   2806         "<": "pienempi kuin",
   2807         ">": "suurempi kuin",
   2808         "∑": "summa",
   2809         "¤": "valuutta"
   2810       },
   2811       "fr": {
   2812         "∆": "delta",
   2813         "∞": "infiniment",
   2814         "♥": "Amour",
   2815         "&": "et",
   2816         "|": "ou",
   2817         "<": "moins que",
   2818         ">": "superieure a",
   2819         "∑": "somme des",
   2820         "¤": "monnaie"
   2821       },
   2822       "ge": {
   2823         "∆": "delta",
   2824         "∞": "usasruloba",
   2825         "♥": "siqvaruli",
   2826         "&": "da",
   2827         "|": "an",
   2828         "<": "naklebi",
   2829         ">": "meti",
   2830         "∑": "jami",
   2831         "¤": "valuta"
   2832       },
   2833       "gr": {},
   2834       "hu": {
   2835         "∆": "delta",
   2836         "∞": "vegtelen",
   2837         "♥": "szerelem",
   2838         "&": "es",
   2839         "|": "vagy",
   2840         "<": "kisebb mint",
   2841         ">": "nagyobb mint",
   2842         "∑": "szumma",
   2843         "¤": "penznem"
   2844       },
   2845       "it": {
   2846         "∆": "delta",
   2847         "∞": "infinito",
   2848         "♥": "amore",
   2849         "&": "e",
   2850         "|": "o",
   2851         "<": "minore di",
   2852         ">": "maggiore di",
   2853         "∑": "somma",
   2854         "¤": "moneta"
   2855       },
   2856       "lt": {
   2857         "∆": "delta",
   2858         "∞": "begalybe",
   2859         "♥": "meile",
   2860         "&": "ir",
   2861         "|": "ar",
   2862         "<": "maziau nei",
   2863         ">": "daugiau nei",
   2864         "∑": "suma",
   2865         "¤": "valiuta"
   2866       },
   2867       "lv": {
   2868         "∆": "delta",
   2869         "∞": "bezgaliba",
   2870         "♥": "milestiba",
   2871         "&": "un",
   2872         "|": "vai",
   2873         "<": "mazak neka",
   2874         ">": "lielaks neka",
   2875         "∑": "summa",
   2876         "¤": "valuta"
   2877       },
   2878       "my": {
   2879         "∆": "kwahkhyaet",
   2880         "∞": "asaonasme",
   2881         "♥": "akhyait",
   2882         "&": "nhin",
   2883         "|": "tho",
   2884         "<": "ngethaw",
   2885         ">": "kyithaw",
   2886         "∑": "paungld",
   2887         "¤": "ngwekye"
   2888       },
   2889       "mk": {},
   2890       "nl": {
   2891         "∆": "delta",
   2892         "∞": "oneindig",
   2893         "♥": "liefde",
   2894         "&": "en",
   2895         "|": "of",
   2896         "<": "kleiner dan",
   2897         ">": "groter dan",
   2898         "∑": "som",
   2899         "¤": "valuta"
   2900       },
   2901       "pl": {
   2902         "∆": "delta",
   2903         "∞": "nieskonczonosc",
   2904         "♥": "milosc",
   2905         "&": "i",
   2906         "|": "lub",
   2907         "<": "mniejsze niz",
   2908         ">": "wieksze niz",
   2909         "∑": "suma",
   2910         "¤": "waluta"
   2911       },
   2912       "pt": {
   2913         "∆": "delta",
   2914         "∞": "infinito",
   2915         "♥": "amor",
   2916         "&": "e",
   2917         "|": "ou",
   2918         "<": "menor que",
   2919         ">": "maior que",
   2920         "∑": "soma",
   2921         "¤": "moeda"
   2922       },
   2923       "ro": {
   2924         "∆": "delta",
   2925         "∞": "infinit",
   2926         "♥": "dragoste",
   2927         "&": "si",
   2928         "|": "sau",
   2929         "<": "mai mic ca",
   2930         ">": "mai mare ca",
   2931         "∑": "suma",
   2932         "¤": "valuta"
   2933       },
   2934       "ru": {
   2935         "∆": "delta",
   2936         "∞": "beskonechno",
   2937         "♥": "lubov",
   2938         "&": "i",
   2939         "|": "ili",
   2940         "<": "menshe",
   2941         ">": "bolshe",
   2942         "∑": "summa",
   2943         "¤": "valjuta"
   2944       },
   2945       "sk": {
   2946         "∆": "delta",
   2947         "∞": "nekonecno",
   2948         "♥": "laska",
   2949         "&": "a",
   2950         "|": "alebo",
   2951         "<": "menej ako",
   2952         ">": "viac ako",
   2953         "∑": "sucet",
   2954         "¤": "mena"
   2955       },
   2956       "sr": {},
   2957       "tr": {
   2958         "∆": "delta",
   2959         "∞": "sonsuzluk",
   2960         "♥": "ask",
   2961         "&": "ve",
   2962         "|": "veya",
   2963         "<": "kucuktur",
   2964         ">": "buyuktur",
   2965         "∑": "toplam",
   2966         "¤": "para birimi"
   2967       },
   2968       "uk": {
   2969         "∆": "delta",
   2970         "∞": "bezkinechnist",
   2971         "♥": "lubov",
   2972         "&": "i",
   2973         "|": "abo",
   2974         "<": "menshe",
   2975         ">": "bilshe",
   2976         "∑": "suma",
   2977         "¤": "valjuta"
   2978       },
   2979       "vn": {
   2980         "∆": "delta",
   2981         "∞": "vo cuc",
   2982         "♥": "yeu",
   2983         "&": "va",
   2984         "|": "hoac",
   2985         "<": "nho hon",
   2986         ">": "lon hon",
   2987         "∑": "tong",
   2988         "¤": "tien te"
   2989       }
   2990     };
   2991     var uricChars = [
   2992       ";",
   2993       "?",
   2994       ":",
   2995       "@",
   2996       "&",
   2997       "=",
   2998       "+",
   2999       "$",
   3000       ",",
   3001       "/"
   3002     ].join("");
   3003     var uricNoSlashChars = [
   3004       ";",
   3005       "?",
   3006       ":",
   3007       "@",
   3008       "&",
   3009       "=",
   3010       "+",
   3011       "$",
   3012       ","
   3013     ].join("");
   3014     var markChars = [
   3015       ".",
   3016       "!",
   3017       "~",
   3018       "*",
   3019       "'",
   3020       "(",
   3021       ")"
   3022     ].join("");
   3023     var getSlug = function getSlug2(input, opts) {
   3024       var separator = "-";
   3025       var result = "";
   3026       var diatricString = "";
   3027       var convertSymbols = true;
   3028       var customReplacements = {};
   3029       var maintainCase;
   3030       var titleCase;
   3031       var truncate;
   3032       var uricFlag;
   3033       var uricNoSlashFlag;
   3034       var markFlag;
   3035       var symbol;
   3036       var langChar;
   3037       var lucky;
   3038       var i;
   3039       var ch;
   3040       var l;
   3041       var lastCharWasSymbol;
   3042       var lastCharWasDiatric;
   3043       var allowedChars = "";
   3044       if (typeof input !== "string") return "";
   3045       if (typeof opts === "string") separator = opts;
   3046       symbol = symbolMap.en;
   3047       langChar = langCharMap.en;
   3048       if (typeof opts === "object") {
   3049         maintainCase = opts.maintainCase || false;
   3050         customReplacements = opts.custom && typeof opts.custom === "object" ? opts.custom : customReplacements;
   3051         truncate = +opts.truncate > 1 && opts.truncate || false;
   3052         uricFlag = opts.uric || false;
   3053         uricNoSlashFlag = opts.uricNoSlash || false;
   3054         markFlag = opts.mark || false;
   3055         convertSymbols = opts.symbols === false || opts.lang === false ? false : true;
   3056         separator = opts.separator || separator;
   3057         if (uricFlag) allowedChars += uricChars;
   3058         if (uricNoSlashFlag) allowedChars += uricNoSlashChars;
   3059         if (markFlag) allowedChars += markChars;
   3060         symbol = opts.lang && symbolMap[opts.lang] && convertSymbols ? symbolMap[opts.lang] : convertSymbols ? symbolMap.en : {};
   3061         langChar = opts.lang && langCharMap[opts.lang] ? langCharMap[opts.lang] : opts.lang === false || opts.lang === true ? {} : langCharMap.en;
   3062         if (opts.titleCase && typeof opts.titleCase.length === "number" && Array.prototype.toString.call(opts.titleCase)) {
   3063           opts.titleCase.forEach(function(v) {
   3064             customReplacements[v + ""] = v + "";
   3065           });
   3066           titleCase = true;
   3067         } else titleCase = !!opts.titleCase;
   3068         if (opts.custom && typeof opts.custom.length === "number" && Array.prototype.toString.call(opts.custom)) opts.custom.forEach(function(v) {
   3069           customReplacements[v + ""] = v + "";
   3070         });
   3071         Object.keys(customReplacements).forEach(function(v) {
   3072           var r;
   3073           if (v.length > 1) r = new RegExp("\\b" + escapeChars(v) + "\\b", "gi");
   3074           else r = new RegExp(escapeChars(v), "gi");
   3075           input = input.replace(r, customReplacements[v]);
   3076         });
   3077         for (ch in customReplacements) allowedChars += ch;
   3078       }
   3079       allowedChars += separator;
   3080       allowedChars = escapeChars(allowedChars);
   3081       input = input.replace(/(^\s+|\s+$)/g, "");
   3082       lastCharWasSymbol = false;
   3083       lastCharWasDiatric = false;
   3084       for (i = 0, l = input.length; i < l; i++) {
   3085         ch = input[i];
   3086         if (isReplacedCustomChar(ch, customReplacements)) lastCharWasSymbol = false;
   3087         else if (langChar[ch]) {
   3088           ch = lastCharWasSymbol && langChar[ch].match(/[A-Za-z0-9]/) ? " " + langChar[ch] : langChar[ch];
   3089           lastCharWasSymbol = false;
   3090         } else if (ch in charMap) {
   3091           if (i + 1 < l && lookAheadCharArray.indexOf(input[i + 1]) >= 0) {
   3092             diatricString += ch;
   3093             ch = "";
   3094           } else if (lastCharWasDiatric === true) {
   3095             ch = diatricMap[diatricString] + charMap[ch];
   3096             diatricString = "";
   3097           } else ch = lastCharWasSymbol && charMap[ch].match(/[A-Za-z0-9]/) ? " " + charMap[ch] : charMap[ch];
   3098           lastCharWasSymbol = false;
   3099           lastCharWasDiatric = false;
   3100         } else if (ch in diatricMap) {
   3101           diatricString += ch;
   3102           ch = "";
   3103           if (i === l - 1) ch = diatricMap[diatricString];
   3104           lastCharWasDiatric = true;
   3105         } else if (symbol[ch] && !(uricFlag && uricChars.indexOf(ch) !== -1) && !(uricNoSlashFlag && uricNoSlashChars.indexOf(ch) !== -1)) {
   3106           ch = lastCharWasSymbol || result.substr(-1).match(/[A-Za-z0-9]/) ? separator + symbol[ch] : symbol[ch];
   3107           ch += input[i + 1] !== void 0 && input[i + 1].match(/[A-Za-z0-9]/) ? separator : "";
   3108           lastCharWasSymbol = true;
   3109         } else {
   3110           if (lastCharWasDiatric === true) {
   3111             ch = diatricMap[diatricString] + ch;
   3112             diatricString = "";
   3113             lastCharWasDiatric = false;
   3114           } else if (lastCharWasSymbol && (/[A-Za-z0-9]/.test(ch) || result.substr(-1).match(/A-Za-z0-9]/))) ch = " " + ch;
   3115           lastCharWasSymbol = false;
   3116         }
   3117         result += ch.replace(new RegExp("[^\\w\\s" + allowedChars + "_-]", "g"), separator);
   3118       }
   3119       if (titleCase) result = result.replace(/(\w)(\S*)/g, function(_, i2, r) {
   3120         var j = i2.toUpperCase() + (r !== null ? r : "");
   3121         return Object.keys(customReplacements).indexOf(j.toLowerCase()) < 0 ? j : j.toLowerCase();
   3122       });
   3123       result = result.replace(/\s+/g, separator).replace(new RegExp("\\" + separator + "+", "g"), separator).replace(new RegExp("(^\\" + separator + "+|\\" + separator + "+$)", "g"), "");
   3124       if (truncate && result.length > truncate) {
   3125         lucky = result.charAt(truncate) === separator;
   3126         result = result.slice(0, truncate);
   3127         if (!lucky) result = result.slice(0, result.lastIndexOf(separator));
   3128       }
   3129       if (!maintainCase && !titleCase) result = result.toLowerCase();
   3130       return result;
   3131     };
   3132     var createSlug = function createSlug2(opts) {
   3133       return function getSlugWithConfig(input) {
   3134         return getSlug(input, opts);
   3135       };
   3136     };
   3137     var escapeChars = function escapeChars2(input) {
   3138       return input.replace(/[-\\^$*+?.()|[\]{}\/]/g, "\\$&");
   3139     };
   3140     var isReplacedCustomChar = function(ch, customReplacements) {
   3141       for (var c in customReplacements) if (customReplacements[c] === ch) return true;
   3142     };
   3143     if (typeof module !== "undefined" && module.exports) {
   3144       module.exports = getSlug;
   3145       module.exports.createSlug = createSlug;
   3146     } else if (typeof define !== "undefined" && define.amd) define([], function() {
   3147       return getSlug;
   3148     });
   3149     else try {
   3150       if (root.getSlug || root.createSlug) throw "speakingurl: globals exists /(getSlug|createSlug)/";
   3151       else {
   3152         root.getSlug = getSlug;
   3153         root.createSlug = createSlug;
   3154       }
   3155     } catch (e) {
   3156     }
   3157   })(exports);
   3158 }));
   3159 var import_speakingurl = __toESM2(__commonJSMin2(((exports, module) => {
   3160   module.exports = require_speakingurl$1();
   3161 }))(), 1);
   3162 var appRecordInfo = target.__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__ ??= {
   3163   id: 0,
   3164   appIds: /* @__PURE__ */ new Set()
   3165 };
   3166 function onDevToolsClientConnected(fn) {
   3167   return new Promise((resolve) => {
   3168     if (devtoolsState.connected && devtoolsState.clientConnected) {
   3169       fn();
   3170       resolve();
   3171       return;
   3172     }
   3173     devtoolsContext.hooks.hook(DevToolsMessagingHookKeys.DEVTOOLS_CONNECTED_UPDATED, ({ state }) => {
   3174       if (state.connected && state.clientConnected) {
   3175         fn();
   3176         resolve();
   3177       }
   3178     });
   3179   });
   3180 }
   3181 function toggleHighPerfMode(state) {
   3182   devtoolsState.highPerfModeEnabled = state ?? !devtoolsState.highPerfModeEnabled;
   3183   if (!state && activeAppRecord.value) registerDevToolsPlugin(activeAppRecord.value.app);
   3184 }
   3185 function updateDevToolsClientDetected(params) {
   3186   devtoolsState.devtoolsClientDetected = {
   3187     ...devtoolsState.devtoolsClientDetected,
   3188     ...params
   3189   };
   3190   toggleHighPerfMode(!Object.values(devtoolsState.devtoolsClientDetected).some(Boolean));
   3191 }
   3192 target.__VUE_DEVTOOLS_UPDATE_CLIENT_DETECTED__ ??= updateDevToolsClientDetected;
   3193 var DoubleIndexedKV = class {
   3194   constructor() {
   3195     this.keyToValue = /* @__PURE__ */ new Map();
   3196     this.valueToKey = /* @__PURE__ */ new Map();
   3197   }
   3198   set(key, value) {
   3199     this.keyToValue.set(key, value);
   3200     this.valueToKey.set(value, key);
   3201   }
   3202   getByKey(key) {
   3203     return this.keyToValue.get(key);
   3204   }
   3205   getByValue(value) {
   3206     return this.valueToKey.get(value);
   3207   }
   3208   clear() {
   3209     this.keyToValue.clear();
   3210     this.valueToKey.clear();
   3211   }
   3212 };
   3213 var Registry = class {
   3214   constructor(generateIdentifier) {
   3215     this.generateIdentifier = generateIdentifier;
   3216     this.kv = new DoubleIndexedKV();
   3217   }
   3218   register(value, identifier) {
   3219     if (this.kv.getByValue(value)) return;
   3220     if (!identifier) identifier = this.generateIdentifier(value);
   3221     this.kv.set(identifier, value);
   3222   }
   3223   clear() {
   3224     this.kv.clear();
   3225   }
   3226   getIdentifier(value) {
   3227     return this.kv.getByValue(value);
   3228   }
   3229   getValue(identifier) {
   3230     return this.kv.getByKey(identifier);
   3231   }
   3232 };
   3233 var ClassRegistry = class extends Registry {
   3234   constructor() {
   3235     super((c) => c.name);
   3236     this.classToAllowedProps = /* @__PURE__ */ new Map();
   3237   }
   3238   register(value, options) {
   3239     if (typeof options === "object") {
   3240       if (options.allowProps) this.classToAllowedProps.set(value, options.allowProps);
   3241       super.register(value, options.identifier);
   3242     } else super.register(value, options);
   3243   }
   3244   getAllowedProps(value) {
   3245     return this.classToAllowedProps.get(value);
   3246   }
   3247 };
   3248 function valuesOfObj(record) {
   3249   if ("values" in Object) return Object.values(record);
   3250   const values = [];
   3251   for (const key in record) if (record.hasOwnProperty(key)) values.push(record[key]);
   3252   return values;
   3253 }
   3254 function find(record, predicate) {
   3255   const values = valuesOfObj(record);
   3256   if ("find" in values) return values.find(predicate);
   3257   const valuesNotNever = values;
   3258   for (let i = 0; i < valuesNotNever.length; i++) {
   3259     const value = valuesNotNever[i];
   3260     if (predicate(value)) return value;
   3261   }
   3262 }
   3263 function forEach(record, run) {
   3264   Object.entries(record).forEach(([key, value]) => run(value, key));
   3265 }
   3266 function includes(arr, value) {
   3267   return arr.indexOf(value) !== -1;
   3268 }
   3269 function findArr(record, predicate) {
   3270   for (let i = 0; i < record.length; i++) {
   3271     const value = record[i];
   3272     if (predicate(value)) return value;
   3273   }
   3274 }
   3275 var CustomTransformerRegistry = class {
   3276   constructor() {
   3277     this.transfomers = {};
   3278   }
   3279   register(transformer) {
   3280     this.transfomers[transformer.name] = transformer;
   3281   }
   3282   findApplicable(v) {
   3283     return find(this.transfomers, (transformer) => transformer.isApplicable(v));
   3284   }
   3285   findByName(name) {
   3286     return this.transfomers[name];
   3287   }
   3288 };
   3289 var getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
   3290 var isUndefined$1 = (payload) => typeof payload === "undefined";
   3291 var isNull$1 = (payload) => payload === null;
   3292 var isPlainObject$2 = (payload) => {
   3293   if (typeof payload !== "object" || payload === null) return false;
   3294   if (payload === Object.prototype) return false;
   3295   if (Object.getPrototypeOf(payload) === null) return true;
   3296   return Object.getPrototypeOf(payload) === Object.prototype;
   3297 };
   3298 var isEmptyObject = (payload) => isPlainObject$2(payload) && Object.keys(payload).length === 0;
   3299 var isArray$2 = (payload) => Array.isArray(payload);
   3300 var isString = (payload) => typeof payload === "string";
   3301 var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
   3302 var isBoolean = (payload) => typeof payload === "boolean";
   3303 var isRegExp = (payload) => payload instanceof RegExp;
   3304 var isMap = (payload) => payload instanceof Map;
   3305 var isSet = (payload) => payload instanceof Set;
   3306 var isSymbol = (payload) => getType$1(payload) === "Symbol";
   3307 var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
   3308 var isError = (payload) => payload instanceof Error;
   3309 var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
   3310 var isPrimitive = (payload) => isBoolean(payload) || isNull$1(payload) || isUndefined$1(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
   3311 var isBigint = (payload) => typeof payload === "bigint";
   3312 var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
   3313 var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
   3314 var isURL = (payload) => payload instanceof URL;
   3315 var escapeKey = (key) => key.replace(/\./g, "\\.");
   3316 var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
   3317 var parsePath = (string) => {
   3318   const result = [];
   3319   let segment = "";
   3320   for (let i = 0; i < string.length; i++) {
   3321     let char = string.charAt(i);
   3322     if (char === "\\" && string.charAt(i + 1) === ".") {
   3323       segment += ".";
   3324       i++;
   3325       continue;
   3326     }
   3327     if (char === ".") {
   3328       result.push(segment);
   3329       segment = "";
   3330       continue;
   3331     }
   3332     segment += char;
   3333   }
   3334   const lastSegment = segment;
   3335   result.push(lastSegment);
   3336   return result;
   3337 };
   3338 function simpleTransformation(isApplicable, annotation, transform, untransform) {
   3339   return {
   3340     isApplicable,
   3341     annotation,
   3342     transform,
   3343     untransform
   3344   };
   3345 }
   3346 var simpleRules = [
   3347   simpleTransformation(isUndefined$1, "undefined", () => null, () => void 0),
   3348   simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
   3349     if (typeof BigInt !== "undefined") return BigInt(v);
   3350     console.error("Please add a BigInt polyfill.");
   3351     return v;
   3352   }),
   3353   simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
   3354   simpleTransformation(isError, "Error", (v, superJson) => {
   3355     const baseError = {
   3356       name: v.name,
   3357       message: v.message
   3358     };
   3359     superJson.allowedErrorProps.forEach((prop) => {
   3360       baseError[prop] = v[prop];
   3361     });
   3362     return baseError;
   3363   }, (v, superJson) => {
   3364     const e = new Error(v.message);
   3365     e.name = v.name;
   3366     e.stack = v.stack;
   3367     superJson.allowedErrorProps.forEach((prop) => {
   3368       e[prop] = v[prop];
   3369     });
   3370     return e;
   3371   }),
   3372   simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
   3373     const body = regex.slice(1, regex.lastIndexOf("/"));
   3374     const flags = regex.slice(regex.lastIndexOf("/") + 1);
   3375     return new RegExp(body, flags);
   3376   }),
   3377   simpleTransformation(isSet, "set", (v) => [...v.values()], (v) => new Set(v)),
   3378   simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
   3379   simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
   3380     if (isNaNValue(v)) return "NaN";
   3381     if (v > 0) return "Infinity";
   3382     else return "-Infinity";
   3383   }, Number),
   3384   simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
   3385     return "-0";
   3386   }, Number),
   3387   simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
   3388 ];
   3389 function compositeTransformation(isApplicable, annotation, transform, untransform) {
   3390   return {
   3391     isApplicable,
   3392     annotation,
   3393     transform,
   3394     untransform
   3395   };
   3396 }
   3397 var symbolRule = compositeTransformation((s, superJson) => {
   3398   if (isSymbol(s)) return !!superJson.symbolRegistry.getIdentifier(s);
   3399   return false;
   3400 }, (s, superJson) => {
   3401   return ["symbol", superJson.symbolRegistry.getIdentifier(s)];
   3402 }, (v) => v.description, (_, a, superJson) => {
   3403   const value = superJson.symbolRegistry.getValue(a[1]);
   3404   if (!value) throw new Error("Trying to deserialize unknown symbol");
   3405   return value;
   3406 });
   3407 var constructorToName = [
   3408   Int8Array,
   3409   Uint8Array,
   3410   Int16Array,
   3411   Uint16Array,
   3412   Int32Array,
   3413   Uint32Array,
   3414   Float32Array,
   3415   Float64Array,
   3416   Uint8ClampedArray
   3417 ].reduce((obj, ctor) => {
   3418   obj[ctor.name] = ctor;
   3419   return obj;
   3420 }, {});
   3421 var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
   3422   const ctor = constructorToName[a[1]];
   3423   if (!ctor) throw new Error("Trying to deserialize unknown typed array");
   3424   return new ctor(v);
   3425 });
   3426 function isInstanceOfRegisteredClass(potentialClass, superJson) {
   3427   if (potentialClass?.constructor) return !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
   3428   return false;
   3429 }
   3430 var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
   3431   return ["class", superJson.classRegistry.getIdentifier(clazz.constructor)];
   3432 }, (clazz, superJson) => {
   3433   const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
   3434   if (!allowedProps) return { ...clazz };
   3435   const result = {};
   3436   allowedProps.forEach((prop) => {
   3437     result[prop] = clazz[prop];
   3438   });
   3439   return result;
   3440 }, (v, a, superJson) => {
   3441   const clazz = superJson.classRegistry.getValue(a[1]);
   3442   if (!clazz) throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
   3443   return Object.assign(Object.create(clazz.prototype), v);
   3444 });
   3445 var customRule = compositeTransformation((value, superJson) => {
   3446   return !!superJson.customTransformerRegistry.findApplicable(value);
   3447 }, (value, superJson) => {
   3448   return ["custom", superJson.customTransformerRegistry.findApplicable(value).name];
   3449 }, (value, superJson) => {
   3450   return superJson.customTransformerRegistry.findApplicable(value).serialize(value);
   3451 }, (v, a, superJson) => {
   3452   const transformer = superJson.customTransformerRegistry.findByName(a[1]);
   3453   if (!transformer) throw new Error("Trying to deserialize unknown custom value");
   3454   return transformer.deserialize(v);
   3455 });
   3456 var compositeRules = [
   3457   classRule,
   3458   symbolRule,
   3459   customRule,
   3460   typedArrayRule
   3461 ];
   3462 var transformValue = (value, superJson) => {
   3463   const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
   3464   if (applicableCompositeRule) return {
   3465     value: applicableCompositeRule.transform(value, superJson),
   3466     type: applicableCompositeRule.annotation(value, superJson)
   3467   };
   3468   const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
   3469   if (applicableSimpleRule) return {
   3470     value: applicableSimpleRule.transform(value, superJson),
   3471     type: applicableSimpleRule.annotation
   3472   };
   3473 };
   3474 var simpleRulesByAnnotation = {};
   3475 simpleRules.forEach((rule) => {
   3476   simpleRulesByAnnotation[rule.annotation] = rule;
   3477 });
   3478 var untransformValue = (json, type, superJson) => {
   3479   if (isArray$2(type)) switch (type[0]) {
   3480     case "symbol":
   3481       return symbolRule.untransform(json, type, superJson);
   3482     case "class":
   3483       return classRule.untransform(json, type, superJson);
   3484     case "custom":
   3485       return customRule.untransform(json, type, superJson);
   3486     case "typed-array":
   3487       return typedArrayRule.untransform(json, type, superJson);
   3488     default:
   3489       throw new Error("Unknown transformation: " + type);
   3490   }
   3491   else {
   3492     const transformation = simpleRulesByAnnotation[type];
   3493     if (!transformation) throw new Error("Unknown transformation: " + type);
   3494     return transformation.untransform(json, superJson);
   3495   }
   3496 };
   3497 var getNthKey = (value, n) => {
   3498   if (n > value.size) throw new Error("index out of bounds");
   3499   const keys = value.keys();
   3500   while (n > 0) {
   3501     keys.next();
   3502     n--;
   3503   }
   3504   return keys.next().value;
   3505 };
   3506 function validatePath(path) {
   3507   if (includes(path, "__proto__")) throw new Error("__proto__ is not allowed as a property");
   3508   if (includes(path, "prototype")) throw new Error("prototype is not allowed as a property");
   3509   if (includes(path, "constructor")) throw new Error("constructor is not allowed as a property");
   3510 }
   3511 var getDeep = (object, path) => {
   3512   validatePath(path);
   3513   for (let i = 0; i < path.length; i++) {
   3514     const key = path[i];
   3515     if (isSet(object)) object = getNthKey(object, +key);
   3516     else if (isMap(object)) {
   3517       const row = +key;
   3518       const type = +path[++i] === 0 ? "key" : "value";
   3519       const keyOfRow = getNthKey(object, row);
   3520       switch (type) {
   3521         case "key":
   3522           object = keyOfRow;
   3523           break;
   3524         case "value":
   3525           object = object.get(keyOfRow);
   3526           break;
   3527       }
   3528     } else object = object[key];
   3529   }
   3530   return object;
   3531 };
   3532 var setDeep = (object, path, mapper) => {
   3533   validatePath(path);
   3534   if (path.length === 0) return mapper(object);
   3535   let parent = object;
   3536   for (let i = 0; i < path.length - 1; i++) {
   3537     const key = path[i];
   3538     if (isArray$2(parent)) {
   3539       const index = +key;
   3540       parent = parent[index];
   3541     } else if (isPlainObject$2(parent)) parent = parent[key];
   3542     else if (isSet(parent)) {
   3543       const row = +key;
   3544       parent = getNthKey(parent, row);
   3545     } else if (isMap(parent)) {
   3546       if (i === path.length - 2) break;
   3547       const row = +key;
   3548       const type = +path[++i] === 0 ? "key" : "value";
   3549       const keyOfRow = getNthKey(parent, row);
   3550       switch (type) {
   3551         case "key":
   3552           parent = keyOfRow;
   3553           break;
   3554         case "value":
   3555           parent = parent.get(keyOfRow);
   3556           break;
   3557       }
   3558     }
   3559   }
   3560   const lastKey = path[path.length - 1];
   3561   if (isArray$2(parent)) parent[+lastKey] = mapper(parent[+lastKey]);
   3562   else if (isPlainObject$2(parent)) parent[lastKey] = mapper(parent[lastKey]);
   3563   if (isSet(parent)) {
   3564     const oldValue = getNthKey(parent, +lastKey);
   3565     const newValue = mapper(oldValue);
   3566     if (oldValue !== newValue) {
   3567       parent.delete(oldValue);
   3568       parent.add(newValue);
   3569     }
   3570   }
   3571   if (isMap(parent)) {
   3572     const row = +path[path.length - 2];
   3573     const keyToRow = getNthKey(parent, row);
   3574     switch (+lastKey === 0 ? "key" : "value") {
   3575       case "key": {
   3576         const newKey = mapper(keyToRow);
   3577         parent.set(newKey, parent.get(keyToRow));
   3578         if (newKey !== keyToRow) parent.delete(keyToRow);
   3579         break;
   3580       }
   3581       case "value":
   3582         parent.set(keyToRow, mapper(parent.get(keyToRow)));
   3583         break;
   3584     }
   3585   }
   3586   return object;
   3587 };
   3588 function traverse(tree, walker2, origin = []) {
   3589   if (!tree) return;
   3590   if (!isArray$2(tree)) {
   3591     forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
   3592     return;
   3593   }
   3594   const [nodeValue, children] = tree;
   3595   if (children) forEach(children, (child, key) => {
   3596     traverse(child, walker2, [...origin, ...parsePath(key)]);
   3597   });
   3598   walker2(nodeValue, origin);
   3599 }
   3600 function applyValueAnnotations(plain, annotations, superJson) {
   3601   traverse(annotations, (type, path) => {
   3602     plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
   3603   });
   3604   return plain;
   3605 }
   3606 function applyReferentialEqualityAnnotations(plain, annotations) {
   3607   function apply(identicalPaths, path) {
   3608     const object = getDeep(plain, parsePath(path));
   3609     identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
   3610       plain = setDeep(plain, identicalObjectPath, () => object);
   3611     });
   3612   }
   3613   if (isArray$2(annotations)) {
   3614     const [root, other] = annotations;
   3615     root.forEach((identicalPath) => {
   3616       plain = setDeep(plain, parsePath(identicalPath), () => plain);
   3617     });
   3618     if (other) forEach(other, apply);
   3619   } else forEach(annotations, apply);
   3620   return plain;
   3621 }
   3622 var isDeep = (object, superJson) => isPlainObject$2(object) || isArray$2(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
   3623 function addIdentity(object, path, identities) {
   3624   const existingSet = identities.get(object);
   3625   if (existingSet) existingSet.push(path);
   3626   else identities.set(object, [path]);
   3627 }
   3628 function generateReferentialEqualityAnnotations(identitites, dedupe) {
   3629   const result = {};
   3630   let rootEqualityPaths = void 0;
   3631   identitites.forEach((paths) => {
   3632     if (paths.length <= 1) return;
   3633     if (!dedupe) paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
   3634     const [representativePath, ...identicalPaths] = paths;
   3635     if (representativePath.length === 0) rootEqualityPaths = identicalPaths.map(stringifyPath);
   3636     else result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
   3637   });
   3638   if (rootEqualityPaths) if (isEmptyObject(result)) return [rootEqualityPaths];
   3639   else return [rootEqualityPaths, result];
   3640   else return isEmptyObject(result) ? void 0 : result;
   3641 }
   3642 var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
   3643   const primitive = isPrimitive(object);
   3644   if (!primitive) {
   3645     addIdentity(object, path, identities);
   3646     const seen = seenObjects.get(object);
   3647     if (seen) return dedupe ? { transformedValue: null } : seen;
   3648   }
   3649   if (!isDeep(object, superJson)) {
   3650     const transformed2 = transformValue(object, superJson);
   3651     const result2 = transformed2 ? {
   3652       transformedValue: transformed2.value,
   3653       annotations: [transformed2.type]
   3654     } : { transformedValue: object };
   3655     if (!primitive) seenObjects.set(object, result2);
   3656     return result2;
   3657   }
   3658   if (includes(objectsInThisPath, object)) return { transformedValue: null };
   3659   const transformationResult = transformValue(object, superJson);
   3660   const transformed = transformationResult?.value ?? object;
   3661   const transformedValue = isArray$2(transformed) ? [] : {};
   3662   const innerAnnotations = {};
   3663   forEach(transformed, (value, index) => {
   3664     if (index === "__proto__" || index === "constructor" || index === "prototype") throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
   3665     const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
   3666     transformedValue[index] = recursiveResult.transformedValue;
   3667     if (isArray$2(recursiveResult.annotations)) innerAnnotations[index] = recursiveResult.annotations;
   3668     else if (isPlainObject$2(recursiveResult.annotations)) forEach(recursiveResult.annotations, (tree, key) => {
   3669       innerAnnotations[escapeKey(index) + "." + key] = tree;
   3670     });
   3671   });
   3672   const result = isEmptyObject(innerAnnotations) ? {
   3673     transformedValue,
   3674     annotations: !!transformationResult ? [transformationResult.type] : void 0
   3675   } : {
   3676     transformedValue,
   3677     annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
   3678   };
   3679   if (!primitive) seenObjects.set(object, result);
   3680   return result;
   3681 };
   3682 function getType(payload) {
   3683   return Object.prototype.toString.call(payload).slice(8, -1);
   3684 }
   3685 function isArray$1(payload) {
   3686   return getType(payload) === "Array";
   3687 }
   3688 function isPlainObject$1(payload) {
   3689   if (getType(payload) !== "Object") return false;
   3690   const prototype = Object.getPrototypeOf(payload);
   3691   return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
   3692 }
   3693 function isNull(payload) {
   3694   return getType(payload) === "Null";
   3695 }
   3696 function isOneOf(a, b, c, d, e) {
   3697   return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
   3698 }
   3699 function isUndefined(payload) {
   3700   return getType(payload) === "Undefined";
   3701 }
   3702 isOneOf(isNull, isUndefined);
   3703 function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
   3704   const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
   3705   if (propType === "enumerable") carry[key] = newVal;
   3706   if (includeNonenumerable && propType === "nonenumerable") Object.defineProperty(carry, key, {
   3707     value: newVal,
   3708     enumerable: false,
   3709     writable: true,
   3710     configurable: true
   3711   });
   3712 }
   3713 function copy(target2, options = {}) {
   3714   if (isArray$1(target2)) return target2.map((item) => copy(item, options));
   3715   if (!isPlainObject$1(target2)) return target2;
   3716   const props = Object.getOwnPropertyNames(target2);
   3717   const symbols = Object.getOwnPropertySymbols(target2);
   3718   return [...props, ...symbols].reduce((carry, key) => {
   3719     if (isArray$1(options.props) && !options.props.includes(key)) return carry;
   3720     const val = target2[key];
   3721     assignProp(carry, key, copy(val, options), target2, options.nonenumerable);
   3722     return carry;
   3723   }, {});
   3724 }
   3725 var SuperJSON = class {
   3726   /**
   3727   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
   3728   */
   3729   constructor({ dedupe = false } = {}) {
   3730     this.classRegistry = new ClassRegistry();
   3731     this.symbolRegistry = new Registry((s) => s.description ?? "");
   3732     this.customTransformerRegistry = new CustomTransformerRegistry();
   3733     this.allowedErrorProps = [];
   3734     this.dedupe = dedupe;
   3735   }
   3736   serialize(object) {
   3737     const identities = /* @__PURE__ */ new Map();
   3738     const output = walker(object, identities, this, this.dedupe);
   3739     const res = { json: output.transformedValue };
   3740     if (output.annotations) res.meta = {
   3741       ...res.meta,
   3742       values: output.annotations
   3743     };
   3744     const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
   3745     if (equalityAnnotations) res.meta = {
   3746       ...res.meta,
   3747       referentialEqualities: equalityAnnotations
   3748     };
   3749     return res;
   3750   }
   3751   deserialize(payload) {
   3752     const { json, meta } = payload;
   3753     let result = copy(json);
   3754     if (meta?.values) result = applyValueAnnotations(result, meta.values, this);
   3755     if (meta?.referentialEqualities) result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
   3756     return result;
   3757   }
   3758   stringify(object) {
   3759     return JSON.stringify(this.serialize(object));
   3760   }
   3761   parse(string) {
   3762     return this.deserialize(JSON.parse(string));
   3763   }
   3764   registerClass(v, options) {
   3765     this.classRegistry.register(v, options);
   3766   }
   3767   registerSymbol(v, identifier) {
   3768     this.symbolRegistry.register(v, identifier);
   3769   }
   3770   registerCustom(transformer, name) {
   3771     this.customTransformerRegistry.register({
   3772       name,
   3773       ...transformer
   3774     });
   3775   }
   3776   allowErrorProps(...props) {
   3777     this.allowedErrorProps.push(...props);
   3778   }
   3779 };
   3780 SuperJSON.defaultInstance = new SuperJSON();
   3781 SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
   3782 SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
   3783 SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
   3784 SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
   3785 SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
   3786 SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
   3787 SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
   3788 SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
   3789 SuperJSON.serialize;
   3790 SuperJSON.deserialize;
   3791 SuperJSON.stringify;
   3792 SuperJSON.parse;
   3793 SuperJSON.registerClass;
   3794 SuperJSON.registerCustom;
   3795 SuperJSON.registerSymbol;
   3796 SuperJSON.allowErrorProps;
   3797 target.__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__ ??= [];
   3798 target.__VUE_DEVTOOLS_KIT_RPC_CLIENT__ ??= null;
   3799 target.__VUE_DEVTOOLS_KIT_RPC_SERVER__ ??= null;
   3800 target.__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__ ??= null;
   3801 target.__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__ ??= null;
   3802 target.__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__ ??= null;
   3803 var MAX_SERIALIZED_SIZE = 2 * 1024 * 1024;
   3804 export {
   3805   addCustomCommand,
   3806   addCustomTab,
   3807   onDevToolsClientConnected,
   3808   onDevToolsConnected,
   3809   removeCustomCommand,
   3810   setupDevToolsPlugin,
   3811   setupDevToolsPlugin as setupDevtoolsPlugin
   3812 };
   3813 //# sourceMappingURL=vitepress___@vue_devtools-api.js.map
	bsc Comprehensive codebase and cou...
	Log \| Files \| Refs \| README \| LICENSE