@cparra/apexdocs 2.25.0-alpha.4 → 2.25.0-alpha.6

package/examples/vitepress/docs/.vitepress/cache/deps/vitepress___@vue_devtools-api.js

@@ -0,0 +1,4339 @@
+// node_modules/@vue/devtools-shared/dist/index.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.1.0_@microsoft+api-extractor@7.43.0_@types+node@20.14.10__@swc+core@1.5.29_postcss@8.4.39_typescript@5.5.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+var require_rfdc = __commonJS({
+  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = rfdc2;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc2(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+init_esm_shims();
+init_esm_shims();
+var isBrowser = typeof navigator !== "undefined";
+var target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+var isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+var isInIframe = isBrowser && target.self !== target.top;
+var isInElectron = typeof navigator !== "undefined" && navigator.userAgent.toLowerCase().includes("electron");
+var isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+init_esm_shims();
+var import_rfdc = __toESM(require_rfdc(), 1);
+var classifyRE = /(?:^|[-_/])(\w)/g;
+function toUpper(_, c) {
+  return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+  return str && `${str}`.replace(classifyRE, toUpper);
+}
+function basename(filename, ext) {
+  const normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+  const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+  const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+  if (ext) {
+    const extIndex = baseNameWithExt.lastIndexOf(ext);
+    return baseNameWithExt.substring(0, extIndex);
+  }
+  return "";
+}
+var HTTP_URL_RE = /^https?:\/\//;
+function isUrlString(str) {
+  return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+var deepClone = (0, import_rfdc.default)({ circles: true });
+init_esm_shims();
+
+// node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks2 = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks2, name);
+    } else if (typeof subHook === "function") {
+      hooks2[name] = subHook;
+    }
+  }
+  return hooks2;
+}
+var defaultTask = { run: (function_) => function_() };
+var _createTask = () => defaultTask;
+var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks2, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks2.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks2, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks2.map((hook2) => task.run(() => hook2(...args))));
+}
+function callEachWith(callbacks, arg0) {
+  for (const callback of [...callbacks]) {
+    callback(arg0);
+  }
+}
+var Hookable = class {
+  constructor() {
+    this._hooks = {};
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
+    this._deprecatedHooks = {};
+    this.hook = this.hook.bind(this);
+    this.callHook = this.callHook.bind(this);
+    this.callHookWith = this.callHookWith.bind(this);
+  }
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch {
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
+      }
+      if (this._hooks[name].length === 0) {
+        delete this._hooks[name];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+    const _hooks = this._hooks[name] || [];
+    delete this._hooks[name];
+    for (const hook2 of _hooks) {
+      this.hook(name, hook2);
+    }
+  }
+  deprecateHooks(deprecatedHooks) {
+    Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
+  }
+  addHooks(configHooks) {
+    const hooks2 = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks2).map(
+      (key) => this.hook(key, hooks2[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks2 = flatHooks(configHooks);
+    for (const key in hooks2) {
+      this.removeHook(key, hooks2[key]);
+    }
+  }
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+  }
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(
+      name in this._hooks ? [...this._hooks[name]] : [],
+      arguments_
+    );
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      if (this._before !== void 0) {
+        const index = this._before.indexOf(function_);
+        if (index !== -1) {
+          this._before.splice(index, 1);
+        }
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      if (this._after !== void 0) {
+        const index = this._after.indexOf(function_);
+        if (index !== -1) {
+          this._after.splice(index, 1);
+        }
+      }
+    };
+  }
+};
+function createHooks() {
+  return new Hookable();
+}
+
+// node_modules/perfect-debounce/dist/index.mjs
+var DEBOUNCE_DEFAULTS = {
+  trailing: true
+};
+function debounce(fn, wait = 25, options = {}) {
+  options = { ...DEBOUNCE_DEFAULTS, ...options };
+  if (!Number.isFinite(wait)) {
+    throw new TypeError("Expected `wait` to be a finite number");
+  }
+  let leadingValue;
+  let timeout;
+  let resolveList = [];
+  let currentPromise;
+  let trailingArgs;
+  const applyFn = (_this, args) => {
+    currentPromise = _applyPromised(fn, _this, args);
+    currentPromise.finally(() => {
+      currentPromise = null;
+      if (options.trailing && trailingArgs && !timeout) {
+        const promise = applyFn(_this, trailingArgs);
+        trailingArgs = null;
+        return promise;
+      }
+    });
+    return currentPromise;
+  };
+  return function(...args) {
+    if (currentPromise) {
+      if (options.trailing) {
+        trailingArgs = args;
+      }
+      return currentPromise;
+    }
+    return new Promise((resolve) => {
+      const shouldCallNow = !timeout && options.leading;
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        timeout = null;
+        const promise = options.leading ? leadingValue : applyFn(this, args);
+        for (const _resolve of resolveList) {
+          _resolve(promise);
+        }
+        resolveList = [];
+      }, wait);
+      if (shouldCallNow) {
+        leadingValue = applyFn(this, args);
+        resolve(leadingValue);
+      } else {
+        resolveList.push(resolve);
+      }
+    });
+  };
+}
+async function _applyPromised(fn, _this, args) {
+  return await fn.apply(_this, args);
+}
+
+// node_modules/birpc/dist/index.mjs
+var { clearTimeout: clearTimeout2, setTimeout: setTimeout2 } = globalThis;
+var random = Math.random.bind(Math);
+
+// node_modules/@vue/devtools-kit/dist/index.js
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __esm2 = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS2 = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target21) => (target21 = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target21, "default", { value: mod, enumerable: true }) : target21,
+  mod
+));
+var init_esm_shims2 = __esm2({
+  "../../node_modules/.pnpm/tsup@8.1.0_@microsoft+api-extractor@7.43.0_@types+node@20.14.10__@swc+core@1.5.29_postcss@8.4.39_typescript@5.5.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+var require_speakingurl = __commonJS2({
+  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/lib/speakingurl.js"(exports, module) {
+    "use strict";
+    init_esm_shims2();
+    (function(root) {
+      "use strict";
+      var charMap = {
+        // latin
+        "À": "A",
+        "Á": "A",
+        "Â": "A",
+        "Ã": "A",
+        "Ä": "Ae",
+        "Å": "A",
+        "Æ": "AE",
+        "Ç": "C",
+        "È": "E",
+        "É": "E",
+        "Ê": "E",
+        "Ë": "E",
+        "Ì": "I",
+        "Í": "I",
+        "Î": "I",
+        "Ï": "I",
+        "Ð": "D",
+        "Ñ": "N",
+        "Ò": "O",
+        "Ó": "O",
+        "Ô": "O",
+        "Õ": "O",
+        "Ö": "Oe",
+        "Ő": "O",
+        "Ø": "O",
+        "Ù": "U",
+        "Ú": "U",
+        "Û": "U",
+        "Ü": "Ue",
+        "Ű": "U",
+        "Ý": "Y",
+        "Þ": "TH",
+        "ß": "ss",
+        "à": "a",
+        "á": "a",
+        "â": "a",
+        "ã": "a",
+        "ä": "ae",
+        "å": "a",
+        "æ": "ae",
+        "ç": "c",
+        "è": "e",
+        "é": "e",
+        "ê": "e",
+        "ë": "e",
+        "ì": "i",
+        "í": "i",
+        "î": "i",
+        "ï": "i",
+        "ð": "d",
+        "ñ": "n",
+        "ò": "o",
+        "ó": "o",
+        "ô": "o",
+        "õ": "o",
+        "ö": "oe",
+        "ő": "o",
+        "ø": "o",
+        "ù": "u",
+        "ú": "u",
+        "û": "u",
+        "ü": "ue",
+        "ű": "u",
+        "ý": "y",
+        "þ": "th",
+        "ÿ": "y",
+        "ẞ": "SS",
+        // language specific
+        // Arabic
+        "ا": "a",
+        "أ": "a",
+        "إ": "i",
+        "آ": "aa",
+        "ؤ": "u",
+        "ئ": "e",
+        "ء": "a",
+        "ب": "b",
+        "ت": "t",
+        "ث": "th",
+        "ج": "j",
+        "ح": "h",
+        "خ": "kh",
+        "د": "d",
+        "ذ": "th",
+        "ر": "r",
+        "ز": "z",
+        "س": "s",
+        "ش": "sh",
+        "ص": "s",
+        "ض": "dh",
+        "ط": "t",
+        "ظ": "z",
+        "ع": "a",
+        "غ": "gh",
+        "ف": "f",
+        "ق": "q",
+        "ك": "k",
+        "ل": "l",
+        "م": "m",
+        "ن": "n",
+        "ه": "h",
+        "و": "w",
+        "ي": "y",
+        "ى": "a",
+        "ة": "h",
+        "ﻻ": "la",
+        "ﻷ": "laa",
+        "ﻹ": "lai",
+        "ﻵ": "laa",
+        // Persian additional characters than Arabic
+        "گ": "g",
+        "چ": "ch",
+        "پ": "p",
+        "ژ": "zh",
+        "ک": "k",
+        "ی": "y",
+        // Arabic diactrics
+        "َ": "a",
+        "ً": "an",
+        "ِ": "e",
+        "ٍ": "en",
+        "ُ": "u",
+        "ٌ": "on",
+        "ْ": "",
+        // Arabic numbers
+        "٠": "0",
+        "١": "1",
+        "٢": "2",
+        "٣": "3",
+        "٤": "4",
+        "٥": "5",
+        "٦": "6",
+        "٧": "7",
+        "٨": "8",
+        "٩": "9",
+        // Persian numbers
+        "۰": "0",
+        "۱": "1",
+        "۲": "2",
+        "۳": "3",
+        "۴": "4",
+        "۵": "5",
+        "۶": "6",
+        "۷": "7",
+        "۸": "8",
+        "۹": "9",
+        // Burmese consonants
+        "က": "k",
+        "ခ": "kh",
+        "ဂ": "g",
+        "ဃ": "ga",
+        "င": "ng",
+        "စ": "s",
+        "ဆ": "sa",
+        "ဇ": "z",
+        "စျ": "za",
+        "ည": "ny",
+        "ဋ": "t",
+        "ဌ": "ta",
+        "ဍ": "d",
+        "ဎ": "da",
+        "ဏ": "na",
+        "တ": "t",
+        "ထ": "ta",
+        "ဒ": "d",
+        "ဓ": "da",
+        "န": "n",
+        "ပ": "p",
+        "ဖ": "pa",
+        "ဗ": "b",
+        "ဘ": "ba",
+        "မ": "m",
+        "ယ": "y",
+        "ရ": "ya",
+        "လ": "l",
+        "ဝ": "w",
+        "သ": "th",
+        "ဟ": "h",
+        "ဠ": "la",
+        "အ": "a",
+        // consonant character combos
+        "ြ": "y",
+        "ျ": "ya",
+        "ွ": "w",
+        "ြွ": "yw",
+        "ျွ": "ywa",
+        "ှ": "h",
+        // independent vowels
+        "ဧ": "e",
+        "၏": "-e",
+        "ဣ": "i",
+        "ဤ": "-i",
+        "ဉ": "u",
+        "ဦ": "-u",
+        "ဩ": "aw",
+        "သြော": "aw",
+        "ဪ": "aw",
+        // numbers
+        "၀": "0",
+        "၁": "1",
+        "၂": "2",
+        "၃": "3",
+        "၄": "4",
+        "၅": "5",
+        "၆": "6",
+        "၇": "7",
+        "၈": "8",
+        "၉": "9",
+        // virama and tone marks which are silent in transliteration
+        "္": "",
+        "့": "",
+        "း": "",
+        // Czech
+        "č": "c",
+        "ď": "d",
+        "ě": "e",
+        "ň": "n",
+        "ř": "r",
+        "š": "s",
+        "ť": "t",
+        "ů": "u",
+        "ž": "z",
+        "Č": "C",
+        "Ď": "D",
+        "Ě": "E",
+        "Ň": "N",
+        "Ř": "R",
+        "Š": "S",
+        "Ť": "T",
+        "Ů": "U",
+        "Ž": "Z",
+        // Dhivehi
+        "ހ": "h",
+        "ށ": "sh",
+        "ނ": "n",
+        "ރ": "r",
+        "ބ": "b",
+        "ޅ": "lh",
+        "ކ": "k",
+        "އ": "a",
+        "ވ": "v",
+        "މ": "m",
+        "ފ": "f",
+        "ދ": "dh",
+        "ތ": "th",
+        "ލ": "l",
+        "ގ": "g",
+        "ޏ": "gn",
+        "ސ": "s",
+        "ޑ": "d",
+        "ޒ": "z",
+        "ޓ": "t",
+        "ޔ": "y",
+        "ޕ": "p",
+        "ޖ": "j",
+        "ޗ": "ch",
+        "ޘ": "tt",
+        "ޙ": "hh",
+        "ޚ": "kh",
+        "ޛ": "th",
+        "ޜ": "z",
+        "ޝ": "sh",
+        "ޞ": "s",
+        "ޟ": "d",
+        "ޠ": "t",
+        "ޡ": "z",
+        "ޢ": "a",
+        "ޣ": "gh",
+        "ޤ": "q",
+        "ޥ": "w",
+        "ަ": "a",
+        "ާ": "aa",
+        "ި": "i",
+        "ީ": "ee",
+        "ު": "u",
+        "ޫ": "oo",
+        "ެ": "e",
+        "ޭ": "ey",
+        "ޮ": "o",
+        "ޯ": "oa",
+        "ް": "",
+        // Georgian https://en.wikipedia.org/wiki/Romanization_of_Georgian
+        // National system (2002)
+        "ა": "a",
+        "ბ": "b",
+        "გ": "g",
+        "დ": "d",
+        "ე": "e",
+        "ვ": "v",
+        "ზ": "z",
+        "თ": "t",
+        "ი": "i",
+        "კ": "k",
+        "ლ": "l",
+        "მ": "m",
+        "ნ": "n",
+        "ო": "o",
+        "პ": "p",
+        "ჟ": "zh",
+        "რ": "r",
+        "ს": "s",
+        "ტ": "t",
+        "უ": "u",
+        "ფ": "p",
+        "ქ": "k",
+        "ღ": "gh",
+        "ყ": "q",
+        "შ": "sh",
+        "ჩ": "ch",
+        "ც": "ts",
+        "ძ": "dz",
+        "წ": "ts",
+        "ჭ": "ch",
+        "ხ": "kh",
+        "ჯ": "j",
+        "ჰ": "h",
+        // Greek
+        "α": "a",
+        "β": "v",
+        "γ": "g",
+        "δ": "d",
+        "ε": "e",
+        "ζ": "z",
+        "η": "i",
+        "θ": "th",
+        "ι": "i",
+        "κ": "k",
+        "λ": "l",
+        "μ": "m",
+        "ν": "n",
+        "ξ": "ks",
+        "ο": "o",
+        "π": "p",
+        "ρ": "r",
+        "σ": "s",
+        "τ": "t",
+        "υ": "y",
+        "φ": "f",
+        "χ": "x",
+        "ψ": "ps",
+        "ω": "o",
+        "ά": "a",
+        "έ": "e",
+        "ί": "i",
+        "ό": "o",
+        "ύ": "y",
+        "ή": "i",
+        "ώ": "o",
+        "ς": "s",
+        "ϊ": "i",
+        "ΰ": "y",
+        "ϋ": "y",
+        "ΐ": "i",
+        "Α": "A",
+        "Β": "B",
+        "Γ": "G",
+        "Δ": "D",
+        "Ε": "E",
+        "Ζ": "Z",
+        "Η": "I",
+        "Θ": "TH",
+        "Ι": "I",
+        "Κ": "K",
+        "Λ": "L",
+        "Μ": "M",
+        "Ν": "N",
+        "Ξ": "KS",
+        "Ο": "O",
+        "Π": "P",
+        "Ρ": "R",
+        "Σ": "S",
+        "Τ": "T",
+        "Υ": "Y",
+        "Φ": "F",
+        "Χ": "X",
+        "Ψ": "PS",
+        "Ω": "O",
+        "Ά": "A",
+        "Έ": "E",
+        "Ί": "I",
+        "Ό": "O",
+        "Ύ": "Y",
+        "Ή": "I",
+        "Ώ": "O",
+        "Ϊ": "I",
+        "Ϋ": "Y",
+        // Latvian
+        "ā": "a",
+        // 'č': 'c', // duplicate
+        "ē": "e",
+        "ģ": "g",
+        "ī": "i",
+        "ķ": "k",
+        "ļ": "l",
+        "ņ": "n",
+        // 'š': 's', // duplicate
+        "ū": "u",
+        // 'ž': 'z', // duplicate
+        "Ā": "A",
+        // 'Č': 'C', // duplicate
+        "Ē": "E",
+        "Ģ": "G",
+        "Ī": "I",
+        "Ķ": "k",
+        "Ļ": "L",
+        "Ņ": "N",
+        // 'Š': 'S', // duplicate
+        "Ū": "U",
+        // 'Ž': 'Z', // duplicate
+        // Macedonian
+        "Ќ": "Kj",
+        "ќ": "kj",
+        "Љ": "Lj",
+        "љ": "lj",
+        "Њ": "Nj",
+        "њ": "nj",
+        "Тс": "Ts",
+        "тс": "ts",
+        // Polish
+        "ą": "a",
+        "ć": "c",
+        "ę": "e",
+        "ł": "l",
+        "ń": "n",
+        // 'ó': 'o', // duplicate
+        "ś": "s",
+        "ź": "z",
+        "ż": "z",
+        "Ą": "A",
+        "Ć": "C",
+        "Ę": "E",
+        "Ł": "L",
+        "Ń": "N",
+        "Ś": "S",
+        "Ź": "Z",
+        "Ż": "Z",
+        // Ukranian
+        "Є": "Ye",
+        "І": "I",
+        "Ї": "Yi",
+        "Ґ": "G",
+        "є": "ye",
+        "і": "i",
+        "ї": "yi",
+        "ґ": "g",
+        // Romanian
+        "ă": "a",
+        "Ă": "A",
+        "ș": "s",
+        "Ș": "S",
+        // 'ş': 's', // duplicate
+        // 'Ş': 'S', // duplicate
+        "ț": "t",
+        "Ț": "T",
+        "ţ": "t",
+        "Ţ": "T",
+        // Russian https://en.wikipedia.org/wiki/Romanization_of_Russian
+        // ICAO
+        "а": "a",
+        "б": "b",
+        "в": "v",
+        "г": "g",
+        "д": "d",
+        "е": "e",
+        "ё": "yo",
+        "ж": "zh",
+        "з": "z",
+        "и": "i",
+        "й": "i",
+        "к": "k",
+        "л": "l",
+        "м": "m",
+        "н": "n",
+        "о": "o",
+        "п": "p",
+        "р": "r",
+        "с": "s",
+        "т": "t",
+        "у": "u",
+        "ф": "f",
+        "х": "kh",
+        "ц": "c",
+        "ч": "ch",
+        "ш": "sh",
+        "щ": "sh",
+        "ъ": "",
+        "ы": "y",
+        "ь": "",
+        "э": "e",
+        "ю": "yu",
+        "я": "ya",
+        "А": "A",
+        "Б": "B",
+        "В": "V",
+        "Г": "G",
+        "Д": "D",
+        "Е": "E",
+        "Ё": "Yo",
+        "Ж": "Zh",
+        "З": "Z",
+        "И": "I",
+        "Й": "I",
+        "К": "K",
+        "Л": "L",
+        "М": "M",
+        "Н": "N",
+        "О": "O",
+        "П": "P",
+        "Р": "R",
+        "С": "S",
+        "Т": "T",
+        "У": "U",
+        "Ф": "F",
+        "Х": "Kh",
+        "Ц": "C",
+        "Ч": "Ch",
+        "Ш": "Sh",
+        "Щ": "Sh",
+        "Ъ": "",
+        "Ы": "Y",
+        "Ь": "",
+        "Э": "E",
+        "Ю": "Yu",
+        "Я": "Ya",
+        // Serbian
+        "ђ": "dj",
+        "ј": "j",
+        // 'љ': 'lj',  // duplicate
+        // 'њ': 'nj', // duplicate
+        "ћ": "c",
+        "џ": "dz",
+        "Ђ": "Dj",
+        "Ј": "j",
+        // 'Љ': 'Lj', // duplicate
+        // 'Њ': 'Nj', // duplicate
+        "Ћ": "C",
+        "Џ": "Dz",
+        // Slovak
+        "ľ": "l",
+        "ĺ": "l",
+        "ŕ": "r",
+        "Ľ": "L",
+        "Ĺ": "L",
+        "Ŕ": "R",
+        // Turkish
+        "ş": "s",
+        "Ş": "S",
+        "ı": "i",
+        "İ": "I",
+        // 'ç': 'c', // duplicate
+        // 'Ç': 'C', // duplicate
+        // 'ü': 'u', // duplicate, see langCharMap
+        // 'Ü': 'U', // duplicate, see langCharMap
+        // 'ö': 'o', // duplicate, see langCharMap
+        // 'Ö': 'O', // duplicate, see langCharMap
+        "ğ": "g",
+        "Ğ": "G",
+        // Vietnamese
+        "ả": "a",
+        "Ả": "A",
+        "ẳ": "a",
+        "Ẳ": "A",
+        "ẩ": "a",
+        "Ẩ": "A",
+        "đ": "d",
+        "Đ": "D",
+        "ẹ": "e",
+        "Ẹ": "E",
+        "ẽ": "e",
+        "Ẽ": "E",
+        "ẻ": "e",
+        "Ẻ": "E",
+        "ế": "e",
+        "Ế": "E",
+        "ề": "e",
+        "Ề": "E",
+        "ệ": "e",
+        "Ệ": "E",
+        "ễ": "e",
+        "Ễ": "E",
+        "ể": "e",
+        "Ể": "E",
+        "ỏ": "o",
+        "ọ": "o",
+        "Ọ": "o",
+        "ố": "o",
+        "Ố": "O",
+        "ồ": "o",
+        "Ồ": "O",
+        "ổ": "o",
+        "Ổ": "O",
+        "ộ": "o",
+        "Ộ": "O",
+        "ỗ": "o",
+        "Ỗ": "O",
+        "ơ": "o",
+        "Ơ": "O",
+        "ớ": "o",
+        "Ớ": "O",
+        "ờ": "o",
+        "Ờ": "O",
+        "ợ": "o",
+        "Ợ": "O",
+        "ỡ": "o",
+        "Ỡ": "O",
+        "Ở": "o",
+        "ở": "o",
+        "ị": "i",
+        "Ị": "I",
+        "ĩ": "i",
+        "Ĩ": "I",
+        "ỉ": "i",
+        "Ỉ": "i",
+        "ủ": "u",
+        "Ủ": "U",
+        "ụ": "u",
+        "Ụ": "U",
+        "ũ": "u",
+        "Ũ": "U",
+        "ư": "u",
+        "Ư": "U",
+        "ứ": "u",
+        "Ứ": "U",
+        "ừ": "u",
+        "Ừ": "U",
+        "ự": "u",
+        "Ự": "U",
+        "ữ": "u",
+        "Ữ": "U",
+        "ử": "u",
+        "Ử": "ư",
+        "ỷ": "y",
+        "Ỷ": "y",
+        "ỳ": "y",
+        "Ỳ": "Y",
+        "ỵ": "y",
+        "Ỵ": "Y",
+        "ỹ": "y",
+        "Ỹ": "Y",
+        "ạ": "a",
+        "Ạ": "A",
+        "ấ": "a",
+        "Ấ": "A",
+        "ầ": "a",
+        "Ầ": "A",
+        "ậ": "a",
+        "Ậ": "A",
+        "ẫ": "a",
+        "Ẫ": "A",
+        // 'ă': 'a', // duplicate
+        // 'Ă': 'A', // duplicate
+        "ắ": "a",
+        "Ắ": "A",
+        "ằ": "a",
+        "Ằ": "A",
+        "ặ": "a",
+        "Ặ": "A",
+        "ẵ": "a",
+        "Ẵ": "A",
+        "⓪": "0",
+        "①": "1",
+        "②": "2",
+        "③": "3",
+        "④": "4",
+        "⑤": "5",
+        "⑥": "6",
+        "⑦": "7",
+        "⑧": "8",
+        "⑨": "9",
+        "⑩": "10",
+        "⑪": "11",
+        "⑫": "12",
+        "⑬": "13",
+        "⑭": "14",
+        "⑮": "15",
+        "⑯": "16",
+        "⑰": "17",
+        "⑱": "18",
+        "⑲": "18",
+        "⑳": "18",
+        "⓵": "1",
+        "⓶": "2",
+        "⓷": "3",
+        "⓸": "4",
+        "⓹": "5",
+        "⓺": "6",
+        "⓻": "7",
+        "⓼": "8",
+        "⓽": "9",
+        "⓾": "10",
+        "⓿": "0",
+        "⓫": "11",
+        "⓬": "12",
+        "⓭": "13",
+        "⓮": "14",
+        "⓯": "15",
+        "⓰": "16",
+        "⓱": "17",
+        "⓲": "18",
+        "⓳": "19",
+        "⓴": "20",
+        "Ⓐ": "A",
+        "Ⓑ": "B",
+        "Ⓒ": "C",
+        "Ⓓ": "D",
+        "Ⓔ": "E",
+        "Ⓕ": "F",
+        "Ⓖ": "G",
+        "Ⓗ": "H",
+        "Ⓘ": "I",
+        "Ⓙ": "J",
+        "Ⓚ": "K",
+        "Ⓛ": "L",
+        "Ⓜ": "M",
+        "Ⓝ": "N",
+        "Ⓞ": "O",
+        "Ⓟ": "P",
+        "Ⓠ": "Q",
+        "Ⓡ": "R",
+        "Ⓢ": "S",
+        "Ⓣ": "T",
+        "Ⓤ": "U",
+        "Ⓥ": "V",
+        "Ⓦ": "W",
+        "Ⓧ": "X",
+        "Ⓨ": "Y",
+        "Ⓩ": "Z",
+        "ⓐ": "a",
+        "ⓑ": "b",
+        "ⓒ": "c",
+        "ⓓ": "d",
+        "ⓔ": "e",
+        "ⓕ": "f",
+        "ⓖ": "g",
+        "ⓗ": "h",
+        "ⓘ": "i",
+        "ⓙ": "j",
+        "ⓚ": "k",
+        "ⓛ": "l",
+        "ⓜ": "m",
+        "ⓝ": "n",
+        "ⓞ": "o",
+        "ⓟ": "p",
+        "ⓠ": "q",
+        "ⓡ": "r",
+        "ⓢ": "s",
+        "ⓣ": "t",
+        "ⓤ": "u",
+        "ⓦ": "v",
+        "ⓥ": "w",
+        "ⓧ": "x",
+        "ⓨ": "y",
+        "ⓩ": "z",
+        // symbols
+        "“": '"',
+        "”": '"',
+        "‘": "'",
+        "’": "'",
+        "∂": "d",
+        "ƒ": "f",
+        "™": "(TM)",
+        "©": "(C)",
+        "œ": "oe",
+        "Œ": "OE",
+        "®": "(R)",
+        "†": "+",
+        "℠": "(SM)",
+        "…": "...",
+        "˚": "o",
+        "º": "o",
+        "ª": "a",
+        "•": "*",
+        "၊": ",",
+        "။": ".",
+        // currency
+        "$": "USD",
+        "€": "EUR",
+        "₢": "BRN",
+        "₣": "FRF",
+        "£": "GBP",
+        "₤": "ITL",
+        "₦": "NGN",
+        "₧": "ESP",
+        "₩": "KRW",
+        "₪": "ILS",
+        "₫": "VND",
+        "₭": "LAK",
+        "₮": "MNT",
+        "₯": "GRD",
+        "₱": "ARS",
+        "₲": "PYG",
+        "₳": "ARA",
+        "₴": "UAH",
+        "₵": "GHS",
+        "¢": "cent",
+        "¥": "CNY",
+        "元": "CNY",
+        "円": "YEN",
+        "﷼": "IRR",
+        "₠": "EWE",
+        "฿": "THB",
+        "₨": "INR",
+        "₹": "INR",
+        "₰": "PF",
+        "₺": "TRY",
+        "؋": "AFN",
+        "₼": "AZN",
+        "лв": "BGN",
+        "៛": "KHR",
+        "₡": "CRC",
+        "₸": "KZT",
+        "ден": "MKD",
+        "zł": "PLN",
+        "₽": "RUB",
+        "₾": "GEL"
+      };
+      var lookAheadCharArray = [
+        // burmese
+        "်",
+        // Dhivehi
+        "ް"
+      ];
+      var diatricMap = {
+        // Burmese
+        // dependent vowels
+        "ာ": "a",
+        "ါ": "a",
+        "ေ": "e",
+        "ဲ": "e",
+        "ိ": "i",
+        "ီ": "i",
+        "ို": "o",
+        "ု": "u",
+        "ူ": "u",
+        "ေါင်": "aung",
+        "ော": "aw",
+        "ော်": "aw",
+        "ေါ": "aw",
+        "ေါ်": "aw",
+        "်": "်",
+        // this is special case but the character will be converted to latin in the code
+        "က်": "et",
+        "ိုက်": "aik",
+        "ောက်": "auk",
+        "င်": "in",
+        "ိုင်": "aing",
+        "ောင်": "aung",
+        "စ်": "it",
+        "ည်": "i",
+        "တ်": "at",
+        "ိတ်": "eik",
+        "ုတ်": "ok",
+        "ွတ်": "ut",
+        "ေတ်": "it",
+        "ဒ်": "d",
+        "ိုဒ်": "ok",
+        "ုဒ်": "ait",
+        "န်": "an",
+        "ာန်": "an",
+        "ိန်": "ein",
+        "ုန်": "on",
+        "ွန်": "un",
+        "ပ်": "at",
+        "ိပ်": "eik",
+        "ုပ်": "ok",
+        "ွပ်": "ut",
+        "န်ုပ်": "nub",
+        "မ်": "an",
+        "ိမ်": "ein",
+        "ုမ်": "on",
+        "ွမ်": "un",
+        "ယ်": "e",
+        "ိုလ်": "ol",
+        "ဉ်": "in",
+        "ံ": "an",
+        "ိံ": "ein",
+        "ုံ": "on",
+        // Dhivehi
+        "ައް": "ah",
+        "ަށް": "ah"
+      };
+      var langCharMap = {
+        "en": {},
+        // default language
+        "az": {
+          // Azerbaijani
+          "ç": "c",
+          "ə": "e",
+          "ğ": "g",
+          "ı": "i",
+          "ö": "o",
+          "ş": "s",
+          "ü": "u",
+          "Ç": "C",
+          "Ə": "E",
+          "Ğ": "G",
+          "İ": "I",
+          "Ö": "O",
+          "Ş": "S",
+          "Ü": "U"
+        },
+        "cs": {
+          // Czech
+          "č": "c",
+          "ď": "d",
+          "ě": "e",
+          "ň": "n",
+          "ř": "r",
+          "š": "s",
+          "ť": "t",
+          "ů": "u",
+          "ž": "z",
+          "Č": "C",
+          "Ď": "D",
+          "Ě": "E",
+          "Ň": "N",
+          "Ř": "R",
+          "Š": "S",
+          "Ť": "T",
+          "Ů": "U",
+          "Ž": "Z"
+        },
+        "fi": {
+          // Finnish
+          // 'å': 'a', duplicate see charMap/latin
+          // 'Å': 'A', duplicate see charMap/latin
+          "ä": "a",
+          // ok
+          "Ä": "A",
+          // ok
+          "ö": "o",
+          // ok
+          "Ö": "O"
+          // ok
+        },
+        "hu": {
+          // Hungarian
+          "ä": "a",
+          // ok
+          "Ä": "A",
+          // ok
+          // 'á': 'a', duplicate see charMap/latin
+          // 'Á': 'A', duplicate see charMap/latin
+          "ö": "o",
+          // ok
+          "Ö": "O",
+          // ok
+          // 'ő': 'o', duplicate see charMap/latin
+          // 'Ő': 'O', duplicate see charMap/latin
+          "ü": "u",
+          "Ü": "U",
+          "ű": "u",
+          "Ű": "U"
+        },
+        "lt": {
+          // Lithuanian
+          "ą": "a",
+          "č": "c",
+          "ę": "e",
+          "ė": "e",
+          "į": "i",
+          "š": "s",
+          "ų": "u",
+          "ū": "u",
+          "ž": "z",
+          "Ą": "A",
+          "Č": "C",
+          "Ę": "E",
+          "Ė": "E",
+          "Į": "I",
+          "Š": "S",
+          "Ų": "U",
+          "Ū": "U"
+        },
+        "lv": {
+          // Latvian
+          "ā": "a",
+          "č": "c",
+          "ē": "e",
+          "ģ": "g",
+          "ī": "i",
+          "ķ": "k",
+          "ļ": "l",
+          "ņ": "n",
+          "š": "s",
+          "ū": "u",
+          "ž": "z",
+          "Ā": "A",
+          "Č": "C",
+          "Ē": "E",
+          "Ģ": "G",
+          "Ī": "i",
+          "Ķ": "k",
+          "Ļ": "L",
+          "Ņ": "N",
+          "Š": "S",
+          "Ū": "u",
+          "Ž": "Z"
+        },
+        "pl": {
+          // Polish
+          "ą": "a",
+          "ć": "c",
+          "ę": "e",
+          "ł": "l",
+          "ń": "n",
+          "ó": "o",
+          "ś": "s",
+          "ź": "z",
+          "ż": "z",
+          "Ą": "A",
+          "Ć": "C",
+          "Ę": "e",
+          "Ł": "L",
+          "Ń": "N",
+          "Ó": "O",
+          "Ś": "S",
+          "Ź": "Z",
+          "Ż": "Z"
+        },
+        "sv": {
+          // Swedish
+          // 'å': 'a', duplicate see charMap/latin
+          // 'Å': 'A', duplicate see charMap/latin
+          "ä": "a",
+          // ok
+          "Ä": "A",
+          // ok
+          "ö": "o",
+          // ok
+          "Ö": "O"
+          // ok
+        },
+        "sk": {
+          // Slovak
+          "ä": "a",
+          "Ä": "A"
+        },
+        "sr": {
+          // Serbian
+          "љ": "lj",
+          "њ": "nj",
+          "Љ": "Lj",
+          "Њ": "Nj",
+          "đ": "dj",
+          "Đ": "Dj"
+        },
+        "tr": {
+          // Turkish
+          "Ü": "U",
+          "Ö": "O",
+          "ü": "u",
+          "ö": "o"
+        }
+      };
+      var symbolMap = {
+        "ar": {
+          "∆": "delta",
+          "∞": "la-nihaya",
+          "♥": "hob",
+          "&": "wa",
+          "|": "aw",
+          "<": "aqal-men",
+          ">": "akbar-men",
+          "∑": "majmou",
+          "¤": "omla"
+        },
+        "az": {},
+        "ca": {
+          "∆": "delta",
+          "∞": "infinit",
+          "♥": "amor",
+          "&": "i",
+          "|": "o",
+          "<": "menys que",
+          ">": "mes que",
+          "∑": "suma dels",
+          "¤": "moneda"
+        },
+        "cs": {
+          "∆": "delta",
+          "∞": "nekonecno",
+          "♥": "laska",
+          "&": "a",
+          "|": "nebo",
+          "<": "mensi nez",
+          ">": "vetsi nez",
+          "∑": "soucet",
+          "¤": "mena"
+        },
+        "de": {
+          "∆": "delta",
+          "∞": "unendlich",
+          "♥": "Liebe",
+          "&": "und",
+          "|": "oder",
+          "<": "kleiner als",
+          ">": "groesser als",
+          "∑": "Summe von",
+          "¤": "Waehrung"
+        },
+        "dv": {
+          "∆": "delta",
+          "∞": "kolunulaa",
+          "♥": "loabi",
+          "&": "aai",
+          "|": "noonee",
+          "<": "ah vure kuda",
+          ">": "ah vure bodu",
+          "∑": "jumula",
+          "¤": "faisaa"
+        },
+        "en": {
+          "∆": "delta",
+          "∞": "infinity",
+          "♥": "love",
+          "&": "and",
+          "|": "or",
+          "<": "less than",
+          ">": "greater than",
+          "∑": "sum",
+          "¤": "currency"
+        },
+        "es": {
+          "∆": "delta",
+          "∞": "infinito",
+          "♥": "amor",
+          "&": "y",
+          "|": "u",
+          "<": "menos que",
+          ">": "mas que",
+          "∑": "suma de los",
+          "¤": "moneda"
+        },
+        "fa": {
+          "∆": "delta",
+          "∞": "bi-nahayat",
+          "♥": "eshgh",
+          "&": "va",
+          "|": "ya",
+          "<": "kamtar-az",
+          ">": "bishtar-az",
+          "∑": "majmooe",
+          "¤": "vahed"
+        },
+        "fi": {
+          "∆": "delta",
+          "∞": "aarettomyys",
+          "♥": "rakkaus",
+          "&": "ja",
+          "|": "tai",
+          "<": "pienempi kuin",
+          ">": "suurempi kuin",
+          "∑": "summa",
+          "¤": "valuutta"
+        },
+        "fr": {
+          "∆": "delta",
+          "∞": "infiniment",
+          "♥": "Amour",
+          "&": "et",
+          "|": "ou",
+          "<": "moins que",
+          ">": "superieure a",
+          "∑": "somme des",
+          "¤": "monnaie"
+        },
+        "ge": {
+          "∆": "delta",
+          "∞": "usasruloba",
+          "♥": "siqvaruli",
+          "&": "da",
+          "|": "an",
+          "<": "naklebi",
+          ">": "meti",
+          "∑": "jami",
+          "¤": "valuta"
+        },
+        "gr": {},
+        "hu": {
+          "∆": "delta",
+          "∞": "vegtelen",
+          "♥": "szerelem",
+          "&": "es",
+          "|": "vagy",
+          "<": "kisebb mint",
+          ">": "nagyobb mint",
+          "∑": "szumma",
+          "¤": "penznem"
+        },
+        "it": {
+          "∆": "delta",
+          "∞": "infinito",
+          "♥": "amore",
+          "&": "e",
+          "|": "o",
+          "<": "minore di",
+          ">": "maggiore di",
+          "∑": "somma",
+          "¤": "moneta"
+        },
+        "lt": {
+          "∆": "delta",
+          "∞": "begalybe",
+          "♥": "meile",
+          "&": "ir",
+          "|": "ar",
+          "<": "maziau nei",
+          ">": "daugiau nei",
+          "∑": "suma",
+          "¤": "valiuta"
+        },
+        "lv": {
+          "∆": "delta",
+          "∞": "bezgaliba",
+          "♥": "milestiba",
+          "&": "un",
+          "|": "vai",
+          "<": "mazak neka",
+          ">": "lielaks neka",
+          "∑": "summa",
+          "¤": "valuta"
+        },
+        "my": {
+          "∆": "kwahkhyaet",
+          "∞": "asaonasme",
+          "♥": "akhyait",
+          "&": "nhin",
+          "|": "tho",
+          "<": "ngethaw",
+          ">": "kyithaw",
+          "∑": "paungld",
+          "¤": "ngwekye"
+        },
+        "mk": {},
+        "nl": {
+          "∆": "delta",
+          "∞": "oneindig",
+          "♥": "liefde",
+          "&": "en",
+          "|": "of",
+          "<": "kleiner dan",
+          ">": "groter dan",
+          "∑": "som",
+          "¤": "valuta"
+        },
+        "pl": {
+          "∆": "delta",
+          "∞": "nieskonczonosc",
+          "♥": "milosc",
+          "&": "i",
+          "|": "lub",
+          "<": "mniejsze niz",
+          ">": "wieksze niz",
+          "∑": "suma",
+          "¤": "waluta"
+        },
+        "pt": {
+          "∆": "delta",
+          "∞": "infinito",
+          "♥": "amor",
+          "&": "e",
+          "|": "ou",
+          "<": "menor que",
+          ">": "maior que",
+          "∑": "soma",
+          "¤": "moeda"
+        },
+        "ro": {
+          "∆": "delta",
+          "∞": "infinit",
+          "♥": "dragoste",
+          "&": "si",
+          "|": "sau",
+          "<": "mai mic ca",
+          ">": "mai mare ca",
+          "∑": "suma",
+          "¤": "valuta"
+        },
+        "ru": {
+          "∆": "delta",
+          "∞": "beskonechno",
+          "♥": "lubov",
+          "&": "i",
+          "|": "ili",
+          "<": "menshe",
+          ">": "bolshe",
+          "∑": "summa",
+          "¤": "valjuta"
+        },
+        "sk": {
+          "∆": "delta",
+          "∞": "nekonecno",
+          "♥": "laska",
+          "&": "a",
+          "|": "alebo",
+          "<": "menej ako",
+          ">": "viac ako",
+          "∑": "sucet",
+          "¤": "mena"
+        },
+        "sr": {},
+        "tr": {
+          "∆": "delta",
+          "∞": "sonsuzluk",
+          "♥": "ask",
+          "&": "ve",
+          "|": "veya",
+          "<": "kucuktur",
+          ">": "buyuktur",
+          "∑": "toplam",
+          "¤": "para birimi"
+        },
+        "uk": {
+          "∆": "delta",
+          "∞": "bezkinechnist",
+          "♥": "lubov",
+          "&": "i",
+          "|": "abo",
+          "<": "menshe",
+          ">": "bilshe",
+          "∑": "suma",
+          "¤": "valjuta"
+        },
+        "vn": {
+          "∆": "delta",
+          "∞": "vo cuc",
+          "♥": "yeu",
+          "&": "va",
+          "|": "hoac",
+          "<": "nho hon",
+          ">": "lon hon",
+          "∑": "tong",
+          "¤": "tien te"
+        }
+      };
+      var uricChars = [";", "?", ":", "@", "&", "=", "+", "$", ",", "/"].join("");
+      var uricNoSlashChars = [";", "?", ":", "@", "&", "=", "+", "$", ","].join("");
+      var markChars = [".", "!", "~", "*", "'", "(", ")"].join("");
+      var getSlug = function getSlug2(input, opts) {
+        var separator = "-";
+        var result = "";
+        var diatricString = "";
+        var convertSymbols = true;
+        var customReplacements = {};
+        var maintainCase;
+        var titleCase;
+        var truncate;
+        var uricFlag;
+        var uricNoSlashFlag;
+        var markFlag;
+        var symbol;
+        var langChar;
+        var lucky;
+        var i;
+        var ch;
+        var l;
+        var lastCharWasSymbol;
+        var lastCharWasDiatric;
+        var allowedChars = "";
+        if (typeof input !== "string") {
+          return "";
+        }
+        if (typeof opts === "string") {
+          separator = opts;
+        }
+        symbol = symbolMap.en;
+        langChar = langCharMap.en;
+        if (typeof opts === "object") {
+          maintainCase = opts.maintainCase || false;
+          customReplacements = opts.custom && typeof opts.custom === "object" ? opts.custom : customReplacements;
+          truncate = +opts.truncate > 1 && opts.truncate || false;
+          uricFlag = opts.uric || false;
+          uricNoSlashFlag = opts.uricNoSlash || false;
+          markFlag = opts.mark || false;
+          convertSymbols = opts.symbols === false || opts.lang === false ? false : true;
+          separator = opts.separator || separator;
+          if (uricFlag) {
+            allowedChars += uricChars;
+          }
+          if (uricNoSlashFlag) {
+            allowedChars += uricNoSlashChars;
+          }
+          if (markFlag) {
+            allowedChars += markChars;
+          }
+          symbol = opts.lang && symbolMap[opts.lang] && convertSymbols ? symbolMap[opts.lang] : convertSymbols ? symbolMap.en : {};
+          langChar = opts.lang && langCharMap[opts.lang] ? langCharMap[opts.lang] : opts.lang === false || opts.lang === true ? {} : langCharMap.en;
+          if (opts.titleCase && typeof opts.titleCase.length === "number" && Array.prototype.toString.call(opts.titleCase)) {
+            opts.titleCase.forEach(function(v) {
+              customReplacements[v + ""] = v + "";
+            });
+            titleCase = true;
+          } else {
+            titleCase = !!opts.titleCase;
+          }
+          if (opts.custom && typeof opts.custom.length === "number" && Array.prototype.toString.call(opts.custom)) {
+            opts.custom.forEach(function(v) {
+              customReplacements[v + ""] = v + "";
+            });
+          }
+          Object.keys(customReplacements).forEach(function(v) {
+            var r;
+            if (v.length > 1) {
+              r = new RegExp("\\b" + escapeChars(v) + "\\b", "gi");
+            } else {
+              r = new RegExp(escapeChars(v), "gi");
+            }
+            input = input.replace(r, customReplacements[v]);
+          });
+          for (ch in customReplacements) {
+            allowedChars += ch;
+          }
+        }
+        allowedChars += separator;
+        allowedChars = escapeChars(allowedChars);
+        input = input.replace(/(^\s+|\s+$)/g, "");
+        lastCharWasSymbol = false;
+        lastCharWasDiatric = false;
+        for (i = 0, l = input.length; i < l; i++) {
+          ch = input[i];
+          if (isReplacedCustomChar(ch, customReplacements)) {
+            lastCharWasSymbol = false;
+          } else if (langChar[ch]) {
+            ch = lastCharWasSymbol && langChar[ch].match(/[A-Za-z0-9]/) ? " " + langChar[ch] : langChar[ch];
+            lastCharWasSymbol = false;
+          } else if (ch in charMap) {
+            if (i + 1 < l && lookAheadCharArray.indexOf(input[i + 1]) >= 0) {
+              diatricString += ch;
+              ch = "";
+            } else if (lastCharWasDiatric === true) {
+              ch = diatricMap[diatricString] + charMap[ch];
+              diatricString = "";
+            } else {
+              ch = lastCharWasSymbol && charMap[ch].match(/[A-Za-z0-9]/) ? " " + charMap[ch] : charMap[ch];
+            }
+            lastCharWasSymbol = false;
+            lastCharWasDiatric = false;
+          } else if (ch in diatricMap) {
+            diatricString += ch;
+            ch = "";
+            if (i === l - 1) {
+              ch = diatricMap[diatricString];
+            }
+            lastCharWasDiatric = true;
+          } else if (
+            // process symbol chars
+            symbol[ch] && !(uricFlag && uricChars.indexOf(ch) !== -1) && !(uricNoSlashFlag && uricNoSlashChars.indexOf(ch) !== -1)
+          ) {
+            ch = lastCharWasSymbol || result.substr(-1).match(/[A-Za-z0-9]/) ? separator + symbol[ch] : symbol[ch];
+            ch += input[i + 1] !== void 0 && input[i + 1].match(/[A-Za-z0-9]/) ? separator : "";
+            lastCharWasSymbol = true;
+          } else {
+            if (lastCharWasDiatric === true) {
+              ch = diatricMap[diatricString] + ch;
+              diatricString = "";
+              lastCharWasDiatric = false;
+            } else if (lastCharWasSymbol && (/[A-Za-z0-9]/.test(ch) || result.substr(-1).match(/A-Za-z0-9]/))) {
+              ch = " " + ch;
+            }
+            lastCharWasSymbol = false;
+          }
+          result += ch.replace(new RegExp("[^\\w\\s" + allowedChars + "_-]", "g"), separator);
+        }
+        if (titleCase) {
+          result = result.replace(/(\w)(\S*)/g, function(_, i2, r) {
+            var j = i2.toUpperCase() + (r !== null ? r : "");
+            return Object.keys(customReplacements).indexOf(j.toLowerCase()) < 0 ? j : j.toLowerCase();
+          });
+        }
+        result = result.replace(/\s+/g, separator).replace(new RegExp("\\" + separator + "+", "g"), separator).replace(new RegExp("(^\\" + separator + "+|\\" + separator + "+$)", "g"), "");
+        if (truncate && result.length > truncate) {
+          lucky = result.charAt(truncate) === separator;
+          result = result.slice(0, truncate);
+          if (!lucky) {
+            result = result.slice(0, result.lastIndexOf(separator));
+          }
+        }
+        if (!maintainCase && !titleCase) {
+          result = result.toLowerCase();
+        }
+        return result;
+      };
+      var createSlug = function createSlug2(opts) {
+        return function getSlugWithConfig(input) {
+          return getSlug(input, opts);
+        };
+      };
+      var escapeChars = function escapeChars2(input) {
+        return input.replace(/[-\\^$*+?.()|[\]{}\/]/g, "\\$&");
+      };
+      var isReplacedCustomChar = function(ch, customReplacements) {
+        for (var c in customReplacements) {
+          if (customReplacements[c] === ch) {
+            return true;
+          }
+        }
+      };
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = getSlug;
+        module.exports.createSlug = createSlug;
+      } else if (typeof define !== "undefined" && define.amd) {
+        define([], function() {
+          return getSlug;
+        });
+      } else {
+        try {
+          if (root.getSlug || root.createSlug) {
+            throw "speakingurl: globals exists /(getSlug|createSlug)/";
+          } else {
+            root.getSlug = getSlug;
+            root.createSlug = createSlug;
+          }
+        } catch (e) {
+        }
+      }
+    })(exports);
+  }
+});
+var require_speakingurl2 = __commonJS2({
+  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims2();
+    module.exports = require_speakingurl();
+  }
+});
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var _a;
+var _b;
+var devtoolsHooks = (_b = (_a = target).__VUE_DEVTOOLS_HOOK) != null ? _b : _a.__VUE_DEVTOOLS_HOOK = createHooks();
+var on = {
+  vueAppInit(fn) {
+    devtoolsHooks.hook("app:init", fn);
+  },
+  vueAppUnmount(fn) {
+    devtoolsHooks.hook("app:unmount", fn);
+  },
+  vueAppConnected(fn) {
+    devtoolsHooks.hook("app:connected", fn);
+  },
+  componentAdded(fn) {
+    return devtoolsHooks.hook("component:added", fn);
+  },
+  componentUpdated(fn) {
+    return devtoolsHooks.hook("component:updated", fn);
+  },
+  componentRemoved(fn) {
+    return devtoolsHooks.hook("component:removed", fn);
+  },
+  setupDevtoolsPlugin(fn) {
+    devtoolsHooks.hook("devtools-plugin:setup", fn);
+  }
+};
+var hook = {
+  on,
+  setupDevToolsPlugin(pluginDescriptor, setupFn) {
+    return devtoolsHooks.callHook("devtools-plugin:setup", pluginDescriptor, setupFn);
+  }
+};
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+function isReadonly(value) {
+  return !!(value && value[
+    "__v_isReadonly"
+    /* IS_READONLY */
+  ]);
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value[
+      "__v_raw"
+      /* RAW */
+    ]);
+  }
+  return !!(value && value[
+    "__v_isReactive"
+    /* IS_REACTIVE */
+  ]);
+}
+function isRef(r) {
+  return !!(r && r.__v_isRef === true);
+}
+function toRaw(observed) {
+  const raw = observed && observed[
+    "__v_raw"
+    /* RAW */
+  ];
+  return raw ? toRaw(raw) : observed;
+}
+var Fragment = Symbol.for("v-fgt");
+function getComponentTypeName(options) {
+  return options.name || options._componentTag || options.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ || options.__name;
+}
+function getComponentFileName(options) {
+  const file = options.__file;
+  if (file)
+    return classify(basename(file, ".vue"));
+}
+function saveComponentGussedName(instance, name) {
+  instance.type.__VUE_DEVTOOLS_COMPONENT_GUSSED_NAME__ = name;
+  return name;
+}
+function getAppRecord(instance) {
+  if (instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__)
+    return instance.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
+  else if (instance.root)
+    return instance.appContext.app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
+}
+async function getComponentId(options) {
+  const { app, uid, instance } = options;
+  try {
+    if (instance.__VUE_DEVTOOLS_NEXT_UID__)
+      return instance.__VUE_DEVTOOLS_NEXT_UID__;
+    const appRecord = await getAppRecord(app);
+    if (!appRecord)
+      return null;
+    const isRoot = appRecord.rootInstance === instance;
+    return `${appRecord.id}:${isRoot ? "root" : uid}`;
+  } catch (e) {
+  }
+}
+function isFragment(instance) {
+  var _a24;
+  const subTreeType = (_a24 = instance.subTree) == null ? void 0 : _a24.type;
+  return subTreeType === Fragment;
+}
+function getInstanceName(instance) {
+  var _a24, _b24, _c;
+  const name = getComponentTypeName((instance == null ? void 0 : instance.type) || {});
+  if (name)
+    return name;
+  if ((instance == null ? void 0 : instance.root) === instance)
+    return "Root";
+  for (const key in (_b24 = (_a24 = instance.parent) == null ? void 0 : _a24.type) == null ? void 0 : _b24.components) {
+    if (instance.parent.type.components[key] === (instance == null ? void 0 : instance.type))
+      return saveComponentGussedName(instance, key);
+  }
+  for (const key in (_c = instance.appContext) == null ? void 0 : _c.components) {
+    if (instance.appContext.components[key] === (instance == null ? void 0 : instance.type))
+      return saveComponentGussedName(instance, key);
+  }
+  const fileName = getComponentFileName((instance == null ? void 0 : instance.type) || {});
+  if (fileName)
+    return fileName;
+  return "Anonymous Component";
+}
+function getComponentInstance(appRecord, instanceId) {
+  instanceId = instanceId || `${appRecord.id}:root`;
+  const instance = appRecord.instanceMap.get(instanceId);
+  return instance || appRecord.instanceMap.get(":root");
+}
+init_esm_shims2();
+function getRootElementsFromComponentInstance(instance) {
+  if (isFragment(instance))
+    return getFragmentRootElements(instance.subTree);
+  if (!instance.subTree)
+    return [];
+  return [instance.subTree.el];
+}
+function getFragmentRootElements(vnode) {
+  if (!vnode.children)
+    return [];
+  const list = [];
+  vnode.children.forEach((childVnode) => {
+    if (childVnode.component)
+      list.push(...getRootElementsFromComponentInstance(childVnode.component));
+    else if (childVnode == null ? void 0 : childVnode.el)
+      list.push(childVnode.el);
+  });
+  return list;
+}
+init_esm_shims2();
+function createRect() {
+  const rect = {
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0,
+    get width() {
+      return rect.right - rect.left;
+    },
+    get height() {
+      return rect.bottom - rect.top;
+    }
+  };
+  return rect;
+}
+var range;
+function getTextRect(node) {
+  if (!range)
+    range = document.createRange();
+  range.selectNode(node);
+  return range.getBoundingClientRect();
+}
+function getFragmentRect(vnode) {
+  const rect = createRect();
+  if (!vnode.children)
+    return rect;
+  for (let i = 0, l = vnode.children.length; i < l; i++) {
+    const childVnode = vnode.children[i];
+    let childRect;
+    if (childVnode.component) {
+      childRect = getComponentBoundingRect(childVnode.component);
+    } else if (childVnode.el) {
+      const el = childVnode.el;
+      if (el.nodeType === 1 || el.getBoundingClientRect)
+        childRect = el.getBoundingClientRect();
+      else if (el.nodeType === 3 && el.data.trim())
+        childRect = getTextRect(el);
+    }
+    if (childRect)
+      mergeRects(rect, childRect);
+  }
+  return rect;
+}
+function mergeRects(a, b) {
+  if (!a.top || b.top < a.top)
+    a.top = b.top;
+  if (!a.bottom || b.bottom > a.bottom)
+    a.bottom = b.bottom;
+  if (!a.left || b.left < a.left)
+    a.left = b.left;
+  if (!a.right || b.right > a.right)
+    a.right = b.right;
+  return a;
+}
+var DEFAULT_RECT = {
+  top: 0,
+  left: 0,
+  right: 0,
+  bottom: 0,
+  width: 0,
+  height: 0
+};
+function getComponentBoundingRect(instance) {
+  const el = instance.subTree.el;
+  if (typeof window === "undefined") {
+    return DEFAULT_RECT;
+  }
+  if (isFragment(instance))
+    return getFragmentRect(instance.subTree);
+  else if ((el == null ? void 0 : el.nodeType) === 1)
+    return el == null ? void 0 : el.getBoundingClientRect();
+  else if (instance.subTree.component)
+    return getComponentBoundingRect(instance.subTree.component);
+  else
+    return DEFAULT_RECT;
+}
+var CONTAINER_ELEMENT_ID = "__vue-devtools-component-inspector__";
+var CARD_ELEMENT_ID = "__vue-devtools-component-inspector__card__";
+var COMPONENT_NAME_ELEMENT_ID = "__vue-devtools-component-inspector__name__";
+var INDICATOR_ELEMENT_ID = "__vue-devtools-component-inspector__indicator__";
+var containerStyles = {
+  display: "block",
+  zIndex: 2147483640,
+  position: "fixed",
+  backgroundColor: "#42b88325",
+  border: "1px solid #42b88350",
+  borderRadius: "5px",
+  transition: "all 0.1s ease-in",
+  pointerEvents: "none"
+};
+var cardStyles = {
+  fontFamily: "Arial, Helvetica, sans-serif",
+  padding: "5px 8px",
+  borderRadius: "4px",
+  textAlign: "left",
+  position: "absolute",
+  left: 0,
+  color: "#e9e9e9",
+  fontSize: "14px",
+  fontWeight: 600,
+  lineHeight: "24px",
+  backgroundColor: "#42b883",
+  boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)"
+};
+var indicatorStyles = {
+  display: "inline-block",
+  fontWeight: 400,
+  fontStyle: "normal",
+  fontSize: "12px",
+  opacity: 0.7
+};
+function getContainerElement() {
+  return document.getElementById(CONTAINER_ELEMENT_ID);
+}
+function getCardElement() {
+  return document.getElementById(CARD_ELEMENT_ID);
+}
+function getIndicatorElement() {
+  return document.getElementById(INDICATOR_ELEMENT_ID);
+}
+function getNameElement() {
+  return document.getElementById(COMPONENT_NAME_ELEMENT_ID);
+}
+function getStyles(bounds) {
+  return {
+    left: `${Math.round(bounds.left * 100) / 100}px`,
+    top: `${Math.round(bounds.top * 100) / 100}px`,
+    width: `${Math.round(bounds.width * 100) / 100}px`,
+    height: `${Math.round(bounds.height * 100) / 100}px`
+  };
+}
+function create(options) {
+  var _a24;
+  const containerEl = document.createElement("div");
+  containerEl.id = (_a24 = options.elementId) != null ? _a24 : CONTAINER_ELEMENT_ID;
+  Object.assign(containerEl.style, {
+    ...containerStyles,
+    ...getStyles(options.bounds),
+    ...options.style
+  });
+  const cardEl = document.createElement("span");
+  cardEl.id = CARD_ELEMENT_ID;
+  Object.assign(cardEl.style, {
+    ...cardStyles,
+    top: options.bounds.top < 35 ? 0 : "-35px"
+  });
+  const nameEl = document.createElement("span");
+  nameEl.id = COMPONENT_NAME_ELEMENT_ID;
+  nameEl.innerHTML = `&lt;${options.name}&gt;&nbsp;&nbsp;`;
+  const indicatorEl = document.createElement("i");
+  indicatorEl.id = INDICATOR_ELEMENT_ID;
+  indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
+  Object.assign(indicatorEl.style, indicatorStyles);
+  cardEl.appendChild(nameEl);
+  cardEl.appendChild(indicatorEl);
+  containerEl.appendChild(cardEl);
+  document.body.appendChild(containerEl);
+  return containerEl;
+}
+function update(options) {
+  const containerEl = getContainerElement();
+  const cardEl = getCardElement();
+  const nameEl = getNameElement();
+  const indicatorEl = getIndicatorElement();
+  if (containerEl) {
+    Object.assign(containerEl.style, {
+      ...containerStyles,
+      ...getStyles(options.bounds)
+    });
+    Object.assign(cardEl.style, {
+      top: options.bounds.top < 35 ? 0 : "-35px"
+    });
+    nameEl.innerHTML = `&lt;${options.name}&gt;&nbsp;&nbsp;`;
+    indicatorEl.innerHTML = `${Math.round(options.bounds.width * 100) / 100} x ${Math.round(options.bounds.height * 100) / 100}`;
+  }
+}
+function highlight(instance) {
+  const bounds = getComponentBoundingRect(instance);
+  const name = getInstanceName(instance);
+  const container = getContainerElement();
+  container ? update({ bounds, name }) : create({ bounds, name });
+}
+function unhighlight() {
+  const el = getContainerElement();
+  if (el)
+    el.style.display = "none";
+}
+var inspectInstance = null;
+function inspectFn(e) {
+  const target21 = e.target;
+  if (target21) {
+    const instance = target21.__vueParentComponent;
+    if (instance) {
+      inspectInstance = instance;
+      const el = instance.vnode.el;
+      if (el) {
+        const bounds = getComponentBoundingRect(instance);
+        const name = getInstanceName(instance);
+        const container = getContainerElement();
+        container ? update({ bounds, name }) : create({ bounds, name });
+      }
+    }
+  }
+}
+function selectComponentFn(e, cb) {
+  var _a24;
+  e.preventDefault();
+  e.stopPropagation();
+  if (inspectInstance) {
+    const app = (_a24 = activeAppRecord.value) == null ? void 0 : _a24.app;
+    getComponentId({
+      app,
+      uid: app.uid,
+      instance: inspectInstance
+    }).then((id) => {
+      cb(id);
+    });
+  }
+}
+var inspectComponentHighLighterSelectFn = null;
+function cancelInspectComponentHighLighter() {
+  unhighlight();
+  window.removeEventListener("mouseover", inspectFn);
+  window.removeEventListener("click", inspectComponentHighLighterSelectFn, true);
+  inspectComponentHighLighterSelectFn = null;
+}
+function inspectComponentHighLighter() {
+  window.addEventListener("mouseover", inspectFn);
+  return new Promise((resolve) => {
+    function onSelect(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      selectComponentFn(e, (id) => {
+        window.removeEventListener("click", onSelect, true);
+        inspectComponentHighLighterSelectFn = null;
+        window.removeEventListener("mouseover", inspectFn);
+        const el = getContainerElement();
+        if (el)
+          el.style.display = "none";
+        resolve(JSON.stringify({ id }));
+      });
+    }
+    inspectComponentHighLighterSelectFn = onSelect;
+    window.addEventListener("click", onSelect, true);
+  });
+}
+function scrollToComponent(options) {
+  const instance = getComponentInstance(activeAppRecord.value, options.id);
+  if (instance) {
+    const [el] = getRootElementsFromComponentInstance(instance);
+    if (typeof el.scrollIntoView === "function") {
+      el.scrollIntoView({
+        behavior: "smooth"
+      });
+    } else {
+      const bounds = getComponentBoundingRect(instance);
+      const scrollTarget = document.createElement("div");
+      const styles = {
+        ...getStyles(bounds),
+        position: "absolute"
+      };
+      Object.assign(scrollTarget.style, styles);
+      document.body.appendChild(scrollTarget);
+      scrollTarget.scrollIntoView({
+        behavior: "smooth"
+      });
+      setTimeout(() => {
+        document.body.removeChild(scrollTarget);
+      }, 2e3);
+    }
+    setTimeout(() => {
+      const bounds = getComponentBoundingRect(instance);
+      if (bounds.width || bounds.height) {
+        const name = getInstanceName(instance);
+        const el2 = getContainerElement();
+        el2 ? update({ ...options, name, bounds }) : create({ ...options, name, bounds });
+        setTimeout(() => {
+          if (el2)
+            el2.style.display = "none";
+        }, 1500);
+      }
+    }, 1200);
+  }
+}
+init_esm_shims2();
+init_esm_shims2();
+var _a2;
+var _b2;
+(_b2 = (_a2 = target).__VUE_DEVTOOLS_KIT_APP_RECORDS__) != null ? _b2 : _a2.__VUE_DEVTOOLS_KIT_APP_RECORDS__ = [];
+var _a3;
+var _b3;
+(_b3 = (_a3 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__) != null ? _b3 : _a3.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = {};
+var _a4;
+var _b4;
+(_b4 = (_a4 = target).__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__) != null ? _b4 : _a4.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = "";
+var _a5;
+var _b5;
+(_b5 = (_a5 = target).__VUE_DEVTOOLS_KIT_CUSTOM_TABS__) != null ? _b5 : _a5.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__ = [];
+var _a6;
+var _b6;
+(_b6 = (_a6 = target).__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__) != null ? _b6 : _a6.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__ = [];
+var STATE_KEY = "__VUE_DEVTOOLS_KIT_GLOBAL_STATE__";
+function initStateFactory() {
+  return {
+    connected: false,
+    clientConnected: false,
+    vitePluginDetected: true,
+    appRecords: [],
+    activeAppRecordId: "",
+    tabs: [],
+    commands: [],
+    highPerfModeEnabled: false
+  };
+}
+var _a7;
+var _b7;
+(_b7 = (_a7 = target)[STATE_KEY]) != null ? _b7 : _a7[STATE_KEY] = initStateFactory();
+var callStateUpdatedHook = debounce((state) => {
+  devtoolsContext.hooks.callHook("devtoolsStateUpdated", { state });
+});
+var callConnectedUpdatedHook = debounce((state, oldState) => {
+  devtoolsContext.hooks.callHook("devtoolsConnectedUpdated", { state, oldState });
+});
+var devtoolsAppRecords = new Proxy(target.__VUE_DEVTOOLS_KIT_APP_RECORDS__, {
+  get(_target, prop, receiver) {
+    if (prop === "value")
+      return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__;
+    return target.__VUE_DEVTOOLS_KIT_APP_RECORDS__[prop];
+  }
+});
+var activeAppRecord = new Proxy(target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__, {
+  get(_target, prop, receiver) {
+    if (prop === "value")
+      return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__;
+    else if (prop === "id")
+      return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__;
+    return target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__[prop];
+  }
+});
+function updateAllStates() {
+  callStateUpdatedHook({
+    ...target[STATE_KEY],
+    appRecords: devtoolsAppRecords.value,
+    activeAppRecordId: activeAppRecord.id,
+    tabs: target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__,
+    commands: target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__
+  });
+}
+function setActiveAppRecord(app) {
+  target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD__ = app;
+  updateAllStates();
+}
+function setActiveAppRecordId(id) {
+  target.__VUE_DEVTOOLS_KIT_ACTIVE_APP_RECORD_ID__ = id;
+  updateAllStates();
+}
+var devtoolsState = new Proxy(target[STATE_KEY], {
+  get(target21, property) {
+    if (property === "appRecords") {
+      return devtoolsAppRecords;
+    } else if (property === "activeAppRecordId") {
+      return activeAppRecord.id;
+    } else if (property === "tabs") {
+      return target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
+    } else if (property === "commands") {
+      return target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
+    }
+    return target[STATE_KEY][property];
+  },
+  deleteProperty(target21, property) {
+    delete target21[property];
+    return true;
+  },
+  set(target21, property, value) {
+    const oldState = { ...target[STATE_KEY] };
+    target21[property] = value;
+    target[STATE_KEY][property] = value;
+    return true;
+  }
+});
+function onDevToolsConnected(fn) {
+  return new Promise((resolve) => {
+    if (devtoolsState.connected) {
+      fn();
+      resolve();
+    }
+    devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
+      if (state.connected) {
+        fn();
+        resolve();
+      }
+    });
+  });
+}
+var resolveIcon = (icon) => {
+  if (!icon)
+    return;
+  if (icon.startsWith("baseline-")) {
+    return `custom-ic-${icon}`;
+  }
+  if (icon.startsWith("i-") || isUrlString(icon))
+    return icon;
+  return `custom-ic-baseline-${icon}`;
+};
+function addCustomTab(tab) {
+  const tabs = target.__VUE_DEVTOOLS_KIT_CUSTOM_TABS__;
+  if (tabs.some((t) => t.name === tab.name))
+    return;
+  tabs.push({
+    ...tab,
+    icon: resolveIcon(tab.icon)
+  });
+  updateAllStates();
+}
+function addCustomCommand(action) {
+  const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
+  if (commands.some((t) => t.id === action.id))
+    return;
+  commands.push({
+    ...action,
+    icon: resolveIcon(action.icon),
+    children: action.children ? action.children.map((child) => ({
+      ...child,
+      icon: resolveIcon(child.icon)
+    })) : void 0
+  });
+  updateAllStates();
+}
+function removeCustomCommand(actionId) {
+  const commands = target.__VUE_DEVTOOLS_KIT_CUSTOM_COMMANDS__;
+  const index = commands.findIndex((t) => t.id === actionId);
+  if (index === -1)
+    return;
+  commands.splice(index, 1);
+  updateAllStates();
+}
+init_esm_shims2();
+var _a8;
+var _b8;
+(_b8 = (_a8 = target).__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS) != null ? _b8 : _a8.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS = [];
+var devtoolsTimelineLayers = new Proxy(target.__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS, {
+  get(target21, prop, receiver) {
+    return Reflect.get(target21, prop, receiver);
+  }
+});
+function addTimelineLayer(options, descriptor) {
+  devtoolsTimelineLayers.push({
+    ...options,
+    descriptorId: descriptor.id,
+    appRecord: getAppRecord(descriptor.app)
+  });
+}
+var _a9;
+var _b9;
+(_b9 = (_a9 = target).__VUE_DEVTOOLS_KIT_INSPECTOR__) != null ? _b9 : _a9.__VUE_DEVTOOLS_KIT_INSPECTOR__ = [];
+var devtoolsInspector = new Proxy(target.__VUE_DEVTOOLS_KIT_INSPECTOR__, {
+  get(target21, prop, receiver) {
+    return Reflect.get(target21, prop, receiver);
+  }
+});
+var callInspectorUpdatedHook = debounce(() => {
+  devtoolsContext.hooks.callHook("sendInspectorToClient", getActiveInspectors());
+});
+function addInspector(inspector, descriptor) {
+  devtoolsInspector.push({
+    options: inspector,
+    descriptor,
+    treeFilter: "",
+    selectedNodeId: "",
+    appRecord: getAppRecord(descriptor.app)
+  });
+  callInspectorUpdatedHook();
+}
+function getActiveInspectors() {
+  return devtoolsInspector.filter((inspector) => inspector.descriptor.app === activeAppRecord.value.app).filter((inspector) => inspector.descriptor.id !== "components").map((inspector) => {
+    var _a24;
+    const descriptor = inspector.descriptor;
+    const options = inspector.options;
+    return {
+      id: options.id,
+      label: options.label,
+      logo: descriptor.logo,
+      icon: `custom-ic-baseline-${(_a24 = options == null ? void 0 : options.icon) == null ? void 0 : _a24.replace(/_/g, "-")}`,
+      packageName: descriptor.packageName,
+      homepage: descriptor.homepage
+    };
+  });
+}
+function getInspector(id, app) {
+  return devtoolsInspector.find((inspector) => inspector.options.id === id && (app ? inspector.descriptor.app === app : true));
+}
+var DevToolsV6PluginAPIHookKeys = ((DevToolsV6PluginAPIHookKeys2) => {
+  DevToolsV6PluginAPIHookKeys2["VISIT_COMPONENT_TREE"] = "visitComponentTree";
+  DevToolsV6PluginAPIHookKeys2["INSPECT_COMPONENT"] = "inspectComponent";
+  DevToolsV6PluginAPIHookKeys2["EDIT_COMPONENT_STATE"] = "editComponentState";
+  DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_TREE"] = "getInspectorTree";
+  DevToolsV6PluginAPIHookKeys2["GET_INSPECTOR_STATE"] = "getInspectorState";
+  DevToolsV6PluginAPIHookKeys2["EDIT_INSPECTOR_STATE"] = "editInspectorState";
+  DevToolsV6PluginAPIHookKeys2["INSPECT_TIMELINE_EVENT"] = "inspectTimelineEvent";
+  DevToolsV6PluginAPIHookKeys2["TIMELINE_CLEARED"] = "timelineCleared";
+  DevToolsV6PluginAPIHookKeys2["SET_PLUGIN_SETTINGS"] = "setPluginSettings";
+  return DevToolsV6PluginAPIHookKeys2;
+})(DevToolsV6PluginAPIHookKeys || {});
+var DevToolsContextHookKeys = ((DevToolsContextHookKeys2) => {
+  DevToolsContextHookKeys2["ADD_INSPECTOR"] = "addInspector";
+  DevToolsContextHookKeys2["SEND_INSPECTOR_TREE"] = "sendInspectorTree";
+  DevToolsContextHookKeys2["SEND_INSPECTOR_STATE"] = "sendInspectorState";
+  DevToolsContextHookKeys2["CUSTOM_INSPECTOR_SELECT_NODE"] = "customInspectorSelectNode";
+  DevToolsContextHookKeys2["TIMELINE_LAYER_ADDED"] = "timelineLayerAdded";
+  DevToolsContextHookKeys2["TIMELINE_EVENT_ADDED"] = "timelineEventAdded";
+  DevToolsContextHookKeys2["GET_COMPONENT_INSTANCES"] = "getComponentInstances";
+  DevToolsContextHookKeys2["GET_COMPONENT_BOUNDS"] = "getComponentBounds";
+  DevToolsContextHookKeys2["GET_COMPONENT_NAME"] = "getComponentName";
+  DevToolsContextHookKeys2["COMPONENT_HIGHLIGHT"] = "componentHighlight";
+  DevToolsContextHookKeys2["COMPONENT_UNHIGHLIGHT"] = "componentUnhighlight";
+  return DevToolsContextHookKeys2;
+})(DevToolsContextHookKeys || {});
+var DevToolsMessagingHookKeys = ((DevToolsMessagingHookKeys2) => {
+  DevToolsMessagingHookKeys2["SEND_INSPECTOR_TREE_TO_CLIENT"] = "sendInspectorTreeToClient";
+  DevToolsMessagingHookKeys2["SEND_INSPECTOR_STATE_TO_CLIENT"] = "sendInspectorStateToClient";
+  DevToolsMessagingHookKeys2["SEND_TIMELINE_EVENT_TO_CLIENT"] = "sendTimelineEventToClient";
+  DevToolsMessagingHookKeys2["SEND_INSPECTOR_TO_CLIENT"] = "sendInspectorToClient";
+  DevToolsMessagingHookKeys2["SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT"] = "sendActiveAppUpdatedToClient";
+  DevToolsMessagingHookKeys2["DEVTOOLS_STATE_UPDATED"] = "devtoolsStateUpdated";
+  DevToolsMessagingHookKeys2["DEVTOOLS_CONNECTED_UPDATED"] = "devtoolsConnectedUpdated";
+  DevToolsMessagingHookKeys2["ROUTER_INFO_UPDATED"] = "routerInfoUpdated";
+  return DevToolsMessagingHookKeys2;
+})(DevToolsMessagingHookKeys || {});
+function createDevToolsCtxHooks() {
+  const hooks2 = createHooks();
+  hooks2.hook("addInspector", ({ inspector, plugin }) => {
+    addInspector(inspector, plugin.descriptor);
+  });
+  hooks2.hook("sendInspectorTree", async ({ inspectorId, plugin }) => {
+    var _a24;
+    if (!inspectorId || !((_a24 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a24.app))
+      return;
+    const inspector = getInspector(inspectorId, plugin.descriptor.app);
+    const _payload = {
+      app: plugin.descriptor.app,
+      inspectorId,
+      filter: (inspector == null ? void 0 : inspector.treeFilter) || "",
+      rootNodes: []
+    };
+    await new Promise((resolve) => {
+      hooks2.callHookWith(
+        async (callbacks) => {
+          await Promise.all(callbacks.map((cb) => cb(_payload)));
+          resolve();
+        },
+        "getInspectorTree"
+        /* GET_INSPECTOR_TREE */
+      );
+    });
+    hooks2.callHookWith(
+      async (callbacks) => {
+        await Promise.all(callbacks.map((cb) => cb({
+          inspectorId,
+          rootNodes: _payload.rootNodes
+        })));
+      },
+      "sendInspectorTreeToClient"
+      /* SEND_INSPECTOR_TREE_TO_CLIENT */
+    );
+  });
+  hooks2.hook("sendInspectorState", async ({ inspectorId, plugin }) => {
+    var _a24;
+    if (!inspectorId || !((_a24 = plugin == null ? void 0 : plugin.descriptor) == null ? void 0 : _a24.app))
+      return;
+    const inspector = getInspector(inspectorId, plugin.descriptor.app);
+    const _payload = {
+      app: plugin.descriptor.app,
+      inspectorId,
+      nodeId: (inspector == null ? void 0 : inspector.selectedNodeId) || "",
+      state: null
+    };
+    const ctx = {
+      currentTab: `custom-inspector:${inspectorId}`
+    };
+    if (_payload.nodeId) {
+      await new Promise((resolve) => {
+        hooks2.callHookWith(
+          async (callbacks) => {
+            await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
+            resolve();
+          },
+          "getInspectorState"
+          /* GET_INSPECTOR_STATE */
+        );
+      });
+    }
+    hooks2.callHookWith(
+      async (callbacks) => {
+        await Promise.all(callbacks.map((cb) => cb({
+          inspectorId,
+          nodeId: _payload.nodeId,
+          state: _payload.state
+        })));
+      },
+      "sendInspectorStateToClient"
+      /* SEND_INSPECTOR_STATE_TO_CLIENT */
+    );
+  });
+  hooks2.hook("customInspectorSelectNode", ({ inspectorId, nodeId, plugin }) => {
+    const inspector = getInspector(inspectorId, plugin.descriptor.app);
+    if (!inspector)
+      return;
+    inspector.selectedNodeId = nodeId;
+  });
+  hooks2.hook("timelineLayerAdded", ({ options, plugin }) => {
+    addTimelineLayer(options, plugin.descriptor);
+  });
+  hooks2.hook("timelineEventAdded", ({ options, plugin }) => {
+    hooks2.callHookWith(
+      async (callbacks) => {
+        await Promise.all(callbacks.map((cb) => cb(options)));
+      },
+      "sendTimelineEventToClient"
+      /* SEND_TIMELINE_EVENT_TO_CLIENT */
+    );
+  });
+  hooks2.hook("getComponentInstances", async ({ app }) => {
+    const appRecord = app.__VUE_DEVTOOLS_NEXT_APP_RECORD__;
+    if (!appRecord)
+      return null;
+    const appId = appRecord.id.toString();
+    const instances = [...appRecord.instanceMap].filter(([key]) => key.split(":")[0] === appId).map(([, instance]) => instance);
+    return instances;
+  });
+  hooks2.hook("getComponentBounds", async ({ instance }) => {
+    const bounds = getComponentBoundingRect(instance);
+    return bounds;
+  });
+  hooks2.hook("getComponentName", ({ instance }) => {
+    const name = getInstanceName(instance);
+    return name;
+  });
+  hooks2.hook("componentHighlight", ({ uid }) => {
+    const instance = activeAppRecord.value.instanceMap.get(uid);
+    if (instance) {
+      highlight(instance);
+    }
+  });
+  hooks2.hook("componentUnhighlight", () => {
+    unhighlight();
+  });
+  return hooks2;
+}
+init_esm_shims2();
+init_esm_shims2();
+var StateEditor = class {
+  constructor() {
+    this.refEditor = new RefStateEditor();
+  }
+  set(object, path, value, cb) {
+    const sections = Array.isArray(path) ? path : path.split(".");
+    const markRef = false;
+    while (sections.length > 1) {
+      const section = sections.shift();
+      if (object instanceof Map)
+        object = object.get(section);
+      if (object instanceof Set)
+        object = Array.from(object.values())[section];
+      else object = object[section];
+      if (this.refEditor.isRef(object))
+        object = this.refEditor.get(object);
+    }
+    const field = sections[0];
+    const item = this.refEditor.get(object)[field];
+    if (cb) {
+      cb(object, field, value);
+    } else {
+      if (this.refEditor.isRef(item))
+        this.refEditor.set(item, value);
+      else if (markRef)
+        object[field] = value;
+      else
+        object[field] = value;
+    }
+  }
+  get(object, path) {
+    const sections = Array.isArray(path) ? path : path.split(".");
+    for (let i = 0; i < sections.length; i++) {
+      if (object instanceof Map)
+        object = object.get(sections[i]);
+      else
+        object = object[sections[i]];
+      if (this.refEditor.isRef(object))
+        object = this.refEditor.get(object);
+      if (!object)
+        return void 0;
+    }
+    return object;
+  }
+  has(object, path, parent = false) {
+    if (typeof object === "undefined")
+      return false;
+    const sections = Array.isArray(path) ? path.slice() : path.split(".");
+    const size = !parent ? 1 : 2;
+    while (object && sections.length > size) {
+      const section = sections.shift();
+      object = object[section];
+      if (this.refEditor.isRef(object))
+        object = this.refEditor.get(object);
+    }
+    return object != null && Object.prototype.hasOwnProperty.call(object, sections[0]);
+  }
+  createDefaultSetCallback(state) {
+    return (object, field, value) => {
+      if (state.remove || state.newKey) {
+        if (Array.isArray(object))
+          object.splice(field, 1);
+        else if (toRaw(object) instanceof Map)
+          object.delete(field);
+        else if (toRaw(object) instanceof Set)
+          object.delete(Array.from(object.values())[field]);
+        else Reflect.deleteProperty(object, field);
+      }
+      if (!state.remove) {
+        const target21 = object[state.newKey || field];
+        if (this.refEditor.isRef(target21))
+          this.refEditor.set(target21, value);
+        else if (toRaw(object) instanceof Map)
+          object.set(state.newKey || field, value);
+        else if (toRaw(object) instanceof Set)
+          object.add(value);
+        else
+          object[state.newKey || field] = value;
+      }
+    };
+  }
+};
+var RefStateEditor = class {
+  set(ref, value) {
+    if (isRef(ref)) {
+      ref.value = value;
+    } else {
+      if (ref instanceof Set && Array.isArray(value)) {
+        ref.clear();
+        value.forEach((v) => ref.add(v));
+        return;
+      }
+      const currentKeys = Object.keys(value);
+      if (ref instanceof Map) {
+        const previousKeysSet2 = new Set(ref.keys());
+        currentKeys.forEach((key) => {
+          ref.set(key, Reflect.get(value, key));
+          previousKeysSet2.delete(key);
+        });
+        previousKeysSet2.forEach((key) => ref.delete(key));
+        return;
+      }
+      const previousKeysSet = new Set(Object.keys(ref));
+      currentKeys.forEach((key) => {
+        Reflect.set(ref, key, Reflect.get(value, key));
+        previousKeysSet.delete(key);
+      });
+      previousKeysSet.forEach((key) => Reflect.deleteProperty(ref, key));
+    }
+  }
+  get(ref) {
+    return isRef(ref) ? ref.value : ref;
+  }
+  isRef(ref) {
+    return isRef(ref) || isReactive(ref);
+  }
+};
+var stateEditor = new StateEditor();
+init_esm_shims2();
+function openInEditor(options = {}) {
+  var _a24;
+  const { file, baseUrl = window.location.origin, line = 0, column = 0 } = options;
+  if (file) {
+    if (devtoolsState.vitePluginDetected) {
+      const _baseUrl = (_a24 = target.__VUE_DEVTOOLS_OPEN_IN_EDITOR_BASE_URL__) != null ? _a24 : baseUrl;
+      target.__VUE_INSPECTOR__.openInEditor(_baseUrl, file, line, column);
+    } else {
+    }
+  }
+}
+init_esm_shims2();
+init_esm_shims2();
+var ROUTER_KEY = "__VUE_DEVTOOLS_ROUTER__";
+var ROUTER_INFO_KEY = "__VUE_DEVTOOLS_ROUTER_INFO__";
+var _a10;
+var _b10;
+(_b10 = (_a10 = target)[ROUTER_INFO_KEY]) != null ? _b10 : _a10[ROUTER_INFO_KEY] = {
+  currentRoute: null,
+  routes: []
+};
+var _a11;
+var _b11;
+(_b11 = (_a11 = target)[ROUTER_KEY]) != null ? _b11 : _a11[ROUTER_KEY] = {};
+var devtoolsRouterInfo = new Proxy(target[ROUTER_INFO_KEY], {
+  get(target21, property) {
+    return target[ROUTER_INFO_KEY][property];
+  }
+});
+var devtoolsRouter = new Proxy(target[ROUTER_KEY], {
+  get(target21, property) {
+    if (property === "value") {
+      return target[ROUTER_KEY];
+    }
+  }
+});
+function getRoutes(router) {
+  const routesMap = /* @__PURE__ */ new Map();
+  return ((router == null ? void 0 : router.getRoutes()) || []).filter((i) => !routesMap.has(i.path) && routesMap.set(i.path, 1));
+}
+function filterRoutes(routes) {
+  return routes.map((item) => {
+    let { path, name, children } = item;
+    if (children == null ? void 0 : children.length)
+      children = filterRoutes(children);
+    return {
+      path,
+      name,
+      children
+    };
+  });
+}
+function filterCurrentRoute(route) {
+  if (route) {
+    const { fullPath, hash, href, path, name, matched, params, query } = route;
+    return {
+      fullPath,
+      hash,
+      href,
+      path,
+      name,
+      params,
+      query,
+      matched: filterRoutes(matched)
+    };
+  }
+  return route;
+}
+function normalizeRouterInfo(appRecord, activeAppRecord2) {
+  function init() {
+    var _a24;
+    const router = (_a24 = appRecord.app) == null ? void 0 : _a24.config.globalProperties.$router;
+    const currentRoute = filterCurrentRoute(router == null ? void 0 : router.currentRoute.value);
+    const routes = filterRoutes(getRoutes(router));
+    const c = console.warn;
+    console.warn = () => {
+    };
+    target[ROUTER_INFO_KEY] = {
+      currentRoute: currentRoute ? deepClone(currentRoute) : {},
+      routes: deepClone(routes)
+    };
+    target[ROUTER_KEY] = router;
+    console.warn = c;
+  }
+  init();
+  hook.on.componentUpdated(debounce(() => {
+    var _a24;
+    if (((_a24 = activeAppRecord2.value) == null ? void 0 : _a24.app) !== appRecord.app)
+      return;
+    init();
+    devtoolsContext.hooks.callHook("routerInfoUpdated", { state: target[ROUTER_INFO_KEY] });
+  }, 200));
+}
+init_esm_shims2();
+var _a12;
+var _b12;
+(_b12 = (_a12 = target).__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__) != null ? _b12 : _a12.__VUE_DEVTOOLS_COMPONENT_INSPECTOR_ENABLED__ = true;
+function waitForInspectorInit(cb) {
+  let total = 0;
+  const timer = setInterval(() => {
+    if (target.__VUE_INSPECTOR__) {
+      clearInterval(timer);
+      total += 30;
+      cb();
+    }
+    if (total >= /* 5s */
+    5e3)
+      clearInterval(timer);
+  }, 30);
+}
+function setupInspector() {
+  const inspector = target.__VUE_INSPECTOR__;
+  const _openInEditor = inspector.openInEditor;
+  inspector.openInEditor = async (...params) => {
+    inspector.disable();
+    _openInEditor(...params);
+  };
+}
+function getComponentInspector() {
+  return new Promise((resolve) => {
+    function setup() {
+      setupInspector();
+      resolve(target.__VUE_INSPECTOR__);
+    }
+    if (!target.__VUE_INSPECTOR__) {
+      waitForInspectorInit(() => {
+        setup();
+      });
+    } else {
+      setup();
+    }
+  });
+}
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var _a13;
+var _b13;
+(_b13 = (_a13 = target).__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__) != null ? _b13 : _a13.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__ = [];
+var devtoolsPluginBuffer = new Proxy(target.__VUE_DEVTOOLS_KIT_PLUGIN_BUFFER__, {
+  get(target21, prop, receiver) {
+    return Reflect.get(target21, prop, receiver);
+  }
+});
+var DevToolsV6PluginAPI = class {
+  constructor({ plugin, ctx }) {
+    this.hooks = ctx.hooks;
+    this.plugin = plugin;
+  }
+  get on() {
+    return {
+      // component inspector
+      visitComponentTree: (handler) => {
+        this.hooks.hook("visitComponentTree", handler);
+      },
+      inspectComponent: (handler) => {
+        this.hooks.hook("inspectComponent", handler);
+      },
+      editComponentState: (handler) => {
+        this.hooks.hook("editComponentState", handler);
+      },
+      // custom inspector
+      getInspectorTree: (handler) => {
+        this.hooks.hook("getInspectorTree", handler);
+      },
+      getInspectorState: (handler) => {
+        this.hooks.hook("getInspectorState", handler);
+      },
+      editInspectorState: (handler) => {
+        this.hooks.hook("editInspectorState", handler);
+      },
+      // timeline
+      inspectTimelineEvent: (handler) => {
+        this.hooks.hook("inspectTimelineEvent", handler);
+      },
+      timelineCleared: (handler) => {
+        this.hooks.hook("timelineCleared", handler);
+      },
+      // settings
+      setPluginSettings: (handler) => {
+        this.hooks.hook("setPluginSettings", handler);
+      }
+    };
+  }
+  // component inspector
+  notifyComponentUpdate(instance) {
+    var _a24;
+    const inspector = getActiveInspectors().find((i) => i.packageName === this.plugin.descriptor.packageName);
+    if (inspector == null ? void 0 : inspector.id) {
+      if (instance) {
+        const args = [
+          instance.appContext.app,
+          instance.uid,
+          (_a24 = instance.parent) == null ? void 0 : _a24.uid,
+          instance
+        ];
+        devtoolsHooks.callHook("component:updated", ...args);
+      } else {
+        devtoolsHooks.callHook(
+          "component:updated"
+          /* COMPONENT_UPDATED */
+        );
+      }
+      this.hooks.callHook("sendInspectorState", { inspectorId: inspector.id, plugin: this.plugin });
+    }
+  }
+  // custom inspector
+  addInspector(options) {
+    this.hooks.callHook("addInspector", { inspector: options, plugin: this.plugin });
+  }
+  sendInspectorTree(inspectorId) {
+    this.hooks.callHook("sendInspectorTree", { inspectorId, plugin: this.plugin });
+  }
+  sendInspectorState(inspectorId) {
+    this.hooks.callHook("sendInspectorState", { inspectorId, plugin: this.plugin });
+  }
+  selectInspectorNode(inspectorId, nodeId) {
+    this.hooks.callHook("customInspectorSelectNode", { inspectorId, nodeId, plugin: this.plugin });
+  }
+  // timeline
+  now() {
+    return Date.now();
+  }
+  addTimelineLayer(options) {
+    this.hooks.callHook("timelineLayerAdded", { options, plugin: this.plugin });
+  }
+  addTimelineEvent(options) {
+    this.hooks.callHook("timelineEventAdded", { options, plugin: this.plugin });
+  }
+  // settings
+  getSettings(pluginId) {
+    var _a24, _b24, _c;
+    function _getSettings(settings) {
+      const _settings = {};
+      Object.keys(settings).forEach((key) => {
+        _settings[key] = settings[key].defaultValue;
+      });
+      return _settings;
+    }
+    if (pluginId) {
+      const item = (_b24 = (_a24 = devtoolsPluginBuffer.find((item2) => item2[0].id === pluginId)) == null ? void 0 : _a24[0]) != null ? _b24 : null;
+      return (_c = _getSettings(item == null ? void 0 : item.settings)) != null ? _c : _getSettings(this.plugin.descriptor.settings);
+    } else {
+      return _getSettings(this.plugin.descriptor.settings);
+    }
+  }
+  // utilities
+  getComponentInstances(app) {
+    return this.hooks.callHook("getComponentInstances", { app });
+  }
+  getComponentBounds(instance) {
+    return this.hooks.callHook("getComponentBounds", { instance });
+  }
+  getComponentName(instance) {
+    return this.hooks.callHook("getComponentName", { instance });
+  }
+  highlightElement(instance) {
+    const uid = instance.__VUE_DEVTOOLS_NEXT_UID__;
+    return this.hooks.callHook("componentHighlight", { uid });
+  }
+  unhighlightElement() {
+    return this.hooks.callHook(
+      "componentUnhighlight"
+      /* COMPONENT_UNHIGHLIGHT */
+    );
+  }
+};
+var DevToolsPluginAPI = DevToolsV6PluginAPI;
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var UNDEFINED = "__vue_devtool_undefined__";
+var INFINITY = "__vue_devtool_infinity__";
+var NEGATIVE_INFINITY = "__vue_devtool_negative_infinity__";
+var NAN = "__vue_devtool_nan__";
+init_esm_shims2();
+init_esm_shims2();
+var tokenMap = {
+  [UNDEFINED]: "undefined",
+  [NAN]: "NaN",
+  [INFINITY]: "Infinity",
+  [NEGATIVE_INFINITY]: "-Infinity"
+};
+var reversedTokenMap = Object.entries(tokenMap).reduce((acc, [key, value]) => {
+  acc[value] = key;
+  return acc;
+}, {});
+init_esm_shims2();
+var _a14;
+var _b14;
+(_b14 = (_a14 = target).__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__) != null ? _b14 : _a14.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__ = /* @__PURE__ */ new Set();
+function setupDevToolsPlugin(pluginDescriptor, setupFn) {
+  return hook.setupDevToolsPlugin(pluginDescriptor, setupFn);
+}
+function callDevToolsPluginSetupFn(plugin, app) {
+  const [pluginDescriptor, setupFn] = plugin;
+  if (pluginDescriptor.app !== app)
+    return;
+  const api = new DevToolsPluginAPI({
+    plugin: {
+      setupFn,
+      descriptor: pluginDescriptor
+    },
+    ctx: devtoolsContext
+  });
+  if (pluginDescriptor.packageName === "vuex") {
+    api.on.editInspectorState((payload) => {
+      api.sendInspectorState(payload.inspectorId);
+    });
+  }
+  setupFn(api);
+}
+function registerDevToolsPlugin(app) {
+  if (target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.has(app))
+    return;
+  target.__VUE_DEVTOOLS_KIT__REGISTERED_PLUGIN_APPS__.add(app);
+  devtoolsPluginBuffer.forEach((plugin) => {
+    callDevToolsPluginSetupFn(plugin, app);
+  });
+}
+function createDevToolsApi(hooks2) {
+  return {
+    // get inspector tree
+    async getInspectorTree(payload) {
+      const _payload = {
+        ...payload,
+        app: activeAppRecord.value.app,
+        rootNodes: []
+      };
+      await new Promise((resolve) => {
+        hooks2.callHookWith(
+          async (callbacks) => {
+            await Promise.all(callbacks.map((cb) => cb(_payload)));
+            resolve();
+          },
+          "getInspectorTree"
+          /* GET_INSPECTOR_TREE */
+        );
+      });
+      return _payload.rootNodes;
+    },
+    // get inspector state
+    async getInspectorState(payload) {
+      const _payload = {
+        ...payload,
+        app: activeAppRecord.value.app,
+        state: null
+      };
+      const ctx = {
+        currentTab: `custom-inspector:${payload.inspectorId}`
+      };
+      await new Promise((resolve) => {
+        hooks2.callHookWith(
+          async (callbacks) => {
+            await Promise.all(callbacks.map((cb) => cb(_payload, ctx)));
+            resolve();
+          },
+          "getInspectorState"
+          /* GET_INSPECTOR_STATE */
+        );
+      });
+      return _payload.state;
+    },
+    // edit inspector state
+    editInspectorState(payload) {
+      const stateEditor2 = new StateEditor();
+      const _payload = {
+        ...payload,
+        app: activeAppRecord.value.app,
+        set: (obj, path = payload.path, value = payload.state.value, cb) => {
+          stateEditor2.set(obj, path, value, cb || stateEditor2.createDefaultSetCallback(payload.state));
+        }
+      };
+      hooks2.callHookWith(
+        (callbacks) => {
+          callbacks.forEach((cb) => cb(_payload));
+        },
+        "editInspectorState"
+        /* EDIT_INSPECTOR_STATE */
+      );
+    },
+    // send inspector state
+    sendInspectorState(inspectorId) {
+      const inspector = getInspector(inspectorId);
+      hooks2.callHook("sendInspectorState", { inspectorId, plugin: {
+        descriptor: inspector.descriptor,
+        setupFn: () => ({})
+      } });
+    },
+    // inspect component inspector
+    inspectComponentInspector() {
+      return inspectComponentHighLighter();
+    },
+    // cancel inspect component inspector
+    cancelInspectComponentInspector() {
+      return cancelInspectComponentHighLighter();
+    },
+    // get component render code
+    getComponentRenderCode(id) {
+      const instance = getComponentInstance(activeAppRecord.value, id);
+      if (instance)
+        return !((instance == null ? void 0 : instance.type) instanceof Function) ? instance.render.toString() : instance.type.toString();
+    },
+    // scroll to component
+    scrollToComponent(id) {
+      return scrollToComponent({ id });
+    },
+    // open in editor
+    openInEditor,
+    // get vue inspector
+    getVueInspector: getComponentInspector,
+    // toggle app
+    toggleApp(id) {
+      const appRecord = devtoolsAppRecords.value.find((record) => record.id === id);
+      if (appRecord) {
+        setActiveAppRecordId(id);
+        setActiveAppRecord(appRecord);
+        normalizeRouterInfo(appRecord, activeAppRecord);
+        callInspectorUpdatedHook();
+        registerDevToolsPlugin(appRecord.app);
+      }
+    },
+    // inspect dom
+    inspectDOM(instanceId) {
+      const instance = getComponentInstance(activeAppRecord.value, instanceId);
+      if (instance) {
+        const [el] = getRootElementsFromComponentInstance(instance);
+        if (el) {
+          target.__VUE_DEVTOOLS_INSPECT_DOM_TARGET__ = el;
+        }
+      }
+    }
+  };
+}
+init_esm_shims2();
+var _a15;
+var _b15;
+(_b15 = (_a15 = target).__VUE_DEVTOOLS_ENV__) != null ? _b15 : _a15.__VUE_DEVTOOLS_ENV__ = {
+  vitePluginDetected: false
+};
+var hooks = createDevToolsCtxHooks();
+var _a16;
+var _b16;
+(_b16 = (_a16 = target).__VUE_DEVTOOLS_KIT_CONTEXT__) != null ? _b16 : _a16.__VUE_DEVTOOLS_KIT_CONTEXT__ = {
+  hooks,
+  get state() {
+    return {
+      ...devtoolsState,
+      activeAppRecordId: activeAppRecord.id,
+      activeAppRecord: activeAppRecord.value,
+      appRecords: devtoolsAppRecords.value
+    };
+  },
+  api: createDevToolsApi(hooks)
+};
+var devtoolsContext = target.__VUE_DEVTOOLS_KIT_CONTEXT__;
+init_esm_shims2();
+init_esm_shims2();
+var import_speakingurl = __toESM2(require_speakingurl2(), 1);
+var _a17;
+var _b17;
+var appRecordInfo = (_b17 = (_a17 = target).__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__) != null ? _b17 : _a17.__VUE_DEVTOOLS_NEXT_APP_RECORD_INFO__ = {
+  id: 0,
+  appIds: /* @__PURE__ */ new Set()
+};
+function onDevToolsClientConnected(fn) {
+  return new Promise((resolve) => {
+    if (devtoolsState.connected && devtoolsState.clientConnected) {
+      fn();
+      resolve();
+      return;
+    }
+    devtoolsContext.hooks.hook("devtoolsConnectedUpdated", ({ state }) => {
+      if (state.connected && state.clientConnected) {
+        fn();
+        resolve();
+      }
+    });
+  });
+}
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var DoubleIndexedKV = class {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+};
+var Registry = class {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+};
+var ClassRegistry = class extends Registry {
+  constructor() {
+    super((c) => c.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+};
+init_esm_shims2();
+init_esm_shims2();
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+var CustomTransformerRegistry = class {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+};
+init_esm_shims2();
+init_esm_shims2();
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject2 = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject2(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive2 = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+init_esm_shims2();
+var escapeKey = (key) => key.replace(/\./g, "\\.");
+var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+var parsePath = (string) => {
+  const result = [];
+  let segment = "";
+  for (let i = 0; i < string.length; i++) {
+    let char = string.charAt(i);
+    const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+init_esm_shims2();
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message);
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation((s, superJson) => {
+  if (isSymbol(s)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, (s, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+  const ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass == null ? void 0 : potentialClass.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error("Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564");
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+init_esm_shims2();
+var getNthKey = (value, n) => {
+  const keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = (object, path) => {
+  validatePath(path);
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = (object, path, mapper) => {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (isArray(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject2(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject2(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path[path.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+function traverse(tree, walker2, origin = []) {
+  if (!tree) {
+    return;
+  }
+  if (!isArray(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, [...origin, ...parsePath(key)]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, superJson) {
+  traverse(annotations, (type, path) => {
+    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+  });
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations) {
+  function apply(identicalPaths, path) {
+    const object = getDeep(plain, parsePath(path));
+    identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = (object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  var _a24;
+  const primitive = isPrimitive2(object);
+  if (!primitive) {
+    addIdentity(object, path, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = (_a24 = transformationResult == null ? void 0 : transformationResult.value) != null ? _a24 : object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    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.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[index] = recursiveResult.annotations;
+    } else if (isPlainObject2(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+init_esm_shims2();
+init_esm_shims2();
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+function isPlainObject3(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function isNull2(payload) {
+  return getType2(payload) === "Null";
+}
+function isOneOf(a, b, c, d, e) {
+  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
+}
+function isUndefined2(payload) {
+  return getType2(payload) === "Undefined";
+}
+var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target21, options = {}) {
+  if (isArray2(target21)) {
+    return target21.map((item) => copy(item, options));
+  }
+  if (!isPlainObject3(target21)) {
+    return target21;
+  }
+  const props = Object.getOwnPropertyNames(target21);
+  const symbols = Object.getOwnPropertySymbols(target21);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target21[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target21, options.nonenumerable);
+    return carry;
+  }, {});
+}
+var SuperJSON = class {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s) => {
+      var _a24;
+      return (_a24 = s.description) != null ? _a24 : "";
+    });
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    return res;
+  }
+  deserialize(payload) {
+    const { json, meta } = payload;
+    let result = copy(json);
+    if (meta == null ? void 0 : meta.values) {
+      result = applyValueAnnotations(result, meta.values, this);
+    }
+    if (meta == null ? void 0 : meta.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string));
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var _a18;
+var _b18;
+(_b18 = (_a18 = target).__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__) != null ? _b18 : _a18.__VUE_DEVTOOLS_KIT_MESSAGE_CHANNELS__ = [];
+var _a19;
+var _b19;
+(_b19 = (_a19 = target).__VUE_DEVTOOLS_KIT_RPC_CLIENT__) != null ? _b19 : _a19.__VUE_DEVTOOLS_KIT_RPC_CLIENT__ = null;
+var _a20;
+var _b20;
+(_b20 = (_a20 = target).__VUE_DEVTOOLS_KIT_RPC_SERVER__) != null ? _b20 : _a20.__VUE_DEVTOOLS_KIT_RPC_SERVER__ = null;
+var _a21;
+var _b21;
+(_b21 = (_a21 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__) != null ? _b21 : _a21.__VUE_DEVTOOLS_KIT_VITE_RPC_CLIENT__ = null;
+var _a22;
+var _b22;
+(_b22 = (_a22 = target).__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__) != null ? _b22 : _a22.__VUE_DEVTOOLS_KIT_VITE_RPC_SERVER__ = null;
+var _a23;
+var _b23;
+(_b23 = (_a23 = target).__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__) != null ? _b23 : _a23.__VUE_DEVTOOLS_KIT_BROADCAST_RPC_SERVER__ = null;
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+var MAX_SERIALIZED_SIZE = 2 * 1024 * 1024;
+init_esm_shims2();
+init_esm_shims2();
+init_esm_shims2();
+export {
+  addCustomCommand,
+  addCustomTab,
+  onDevToolsClientConnected,
+  onDevToolsConnected,
+  removeCustomCommand,
+  setupDevToolsPlugin,
+  setupDevToolsPlugin as setupDevtoolsPlugin
+};
+//# sourceMappingURL=vitepress___@vue_devtools-api.js.map