@inpageedit/core 0.14.5 → 0.16.0

package/dist/index-QnWieXQc.js

@@ -0,0 +1,4932 @@
+import { W as wi, d as bi, e as vi, r as _i, u as xi, c as ki, a as Si, f as $i } from "./index-CYfkwXRf.js";
+import { j as M, P as Ei, p as wt } from "./Promise.withResolvers-C4chhLB1.js";
+var Ci = Object.defineProperty, S = (i, e) => Ci(i, "name", { value: e, configurable: !0 });
+function Ai() {
+}
+S(Ai, "noop");
+function I(i) {
+  return i == null;
+}
+S(I, "isNullable");
+function Oi(i) {
+  return !I(i);
+}
+S(Oi, "isNonNullable");
+function le(i) {
+  return i && typeof i == "object" && !Array.isArray(i);
+}
+S(le, "isPlainObject");
+function bt(i, e) {
+  return Object.fromEntries(Object.entries(i).filter(([t, r]) => e(t, r)));
+}
+S(bt, "filterKeys");
+function q(i, e) {
+  return Object.fromEntries(Object.entries(i).map(([t, r]) => [t, e(r, t)]));
+}
+S(q, "mapValues");
+function vt(i, e, t) {
+  if (!e) return { ...i };
+  const r = {};
+  for (const n of e)
+    (t || i[n] !== void 0) && (r[n] = i[n]);
+  return r;
+}
+S(vt, "pick");
+function Pi(i, e) {
+  if (!e) return { ...i };
+  const t = { ...i };
+  for (const r of e)
+    Reflect.deleteProperty(t, r);
+  return t;
+}
+S(Pi, "omit");
+function j(i, e, t) {
+  return Object.defineProperty(i, e, { writable: !0, value: t, enumerable: !1 });
+}
+S(j, "defineProperty");
+function Ii(i, e) {
+  return e.every((t) => i.includes(t));
+}
+S(Ii, "contain");
+function Li(i, e) {
+  return i.filter((t) => e.includes(t));
+}
+S(Li, "intersection");
+function Ri(i, e) {
+  return i.filter((t) => !e.includes(t));
+}
+S(Ri, "difference");
+function ji(i, e) {
+  return Array.from(/* @__PURE__ */ new Set([...i, ...e]));
+}
+S(ji, "union");
+function Di(i) {
+  return [...new Set(i)];
+}
+S(Di, "deduplicate");
+function W(i, e) {
+  const t = i?.indexOf(e);
+  return t >= 0 ? (i.splice(t, 1), !0) : !1;
+}
+S(W, "remove");
+function Ti(i) {
+  return Array.isArray(i) ? i : I(i) ? [] : [i];
+}
+S(Ti, "makeArray");
+function G(i, e) {
+  return arguments.length === 1 ? (t) => G(i, t) : i in globalThis && e instanceof globalThis[i] || Object.prototype.toString.call(e).slice(8, -1) === i;
+}
+S(G, "is");
+function ne(i) {
+  return G("ArrayBuffer", i) || G("SharedArrayBuffer", i);
+}
+S(ne, "isArrayBufferLike");
+function _t(i) {
+  return ne(i) || ArrayBuffer.isView(i);
+}
+S(_t, "isArrayBufferSource");
+var B;
+((i) => {
+  i.is = ne, i.isSource = _t;
+  function e(o) {
+    return ArrayBuffer.isView(o) ? o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength) : o;
+  }
+  i.fromSource = e, S(e, "fromSource");
+  function t(o) {
+    if (typeof Buffer < "u")
+      return Buffer.from(o).toString("base64");
+    let a = "";
+    const f = new Uint8Array(o);
+    for (let u = 0; u < f.byteLength; u++)
+      a += String.fromCharCode(f[u]);
+    return btoa(a);
+  }
+  i.toBase64 = t, S(t, "toBase64");
+  function r(o) {
+    return typeof Buffer < "u" ? e(Buffer.from(o, "base64")) : Uint8Array.from(atob(o), (a) => a.charCodeAt(0));
+  }
+  i.fromBase64 = r, S(r, "fromBase64");
+  function n(o) {
+    return typeof Buffer < "u" ? Buffer.from(o).toString("hex") : Array.from(new Uint8Array(o), (a) => a.toString(16).padStart(2, "0")).join("");
+  }
+  i.toHex = n, S(n, "toHex");
+  function s(o) {
+    if (typeof Buffer < "u") return e(Buffer.from(o, "hex"));
+    const a = o.length % 2 === 0 ? o : o.slice(0, o.length - 1), f = [];
+    for (let u = 0; u < a.length; u += 2)
+      f.push(parseInt(`${a[u]}${a[u + 1]}`, 16));
+    return Uint8Array.from(f).buffer;
+  }
+  i.fromHex = s, S(s, "fromHex");
+})(B || (B = {}));
+B.fromBase64;
+B.toBase64;
+B.fromHex;
+B.toHex;
+function he(i, e = /* @__PURE__ */ new Map()) {
+  if (!i || typeof i != "object") return i;
+  if (G("Date", i)) return new Date(i.valueOf());
+  if (G("RegExp", i)) return new RegExp(i.source, i.flags);
+  if (ne(i)) return i.slice(0);
+  if (ArrayBuffer.isView(i)) return i.buffer.slice(i.byteOffset, i.byteOffset + i.byteLength);
+  const t = e.get(i);
+  if (t) return t;
+  if (Array.isArray(i)) {
+    const n = [];
+    return e.set(i, n), i.forEach((s, o) => {
+      n[o] = Reflect.apply(he, null, [s, e]);
+    }), n;
+  }
+  const r = Object.create(Object.getPrototypeOf(i));
+  e.set(i, r);
+  for (const n of Reflect.ownKeys(i)) {
+    const s = { ...Reflect.getOwnPropertyDescriptor(i, n) };
+    "value" in s && (s.value = Reflect.apply(he, null, [s.value, e])), Reflect.defineProperty(r, n, s);
+  }
+  return r;
+}
+S(he, "clone");
+function J(i, e, t) {
+  if (i === e || !t && I(i) && I(e)) return !0;
+  if (typeof i != typeof e || typeof i != "object" || !i || !e) return !1;
+  function r(n, s) {
+    return n(i) ? n(e) ? s(i, e) : !1 : n(e) ? !1 : void 0;
+  }
+  return S(r, "check"), r(Array.isArray, (n, s) => n.length === s.length && n.every((o, a) => J(o, s[a]))) ?? r(G("Date"), (n, s) => n.valueOf() === s.valueOf()) ?? r(G("RegExp"), (n, s) => n.source === s.source && n.flags === s.flags) ?? r(ne, (n, s) => {
+    if (n.byteLength !== s.byteLength) return !1;
+    const o = new Uint8Array(n), a = new Uint8Array(s);
+    for (let f = 0; f < o.length; f++)
+      if (o[f] !== a[f]) return !1;
+    return !0;
+  }) ?? Object.keys({ ...i, ...e }).every((n) => J(i[n], e[n], t));
+}
+S(J, "deepEqual");
+function Mi(i) {
+  return i.charAt(0).toUpperCase() + i.slice(1);
+}
+S(Mi, "capitalize");
+function Ni(i) {
+  return i.charAt(0).toLowerCase() + i.slice(1);
+}
+S(Ni, "uncapitalize");
+function Bi(i) {
+  return i.replace(/[_-][a-z]/g, (e) => e.slice(1).toUpperCase());
+}
+S(Bi, "camelCase");
+function Me(i, e, t) {
+  const r = [];
+  let n = 0;
+  for (let s = 0; s < i.length; s++) {
+    const o = i.charCodeAt(s);
+    if (o >= 65 && o <= 90) {
+      if (n === 1) {
+        const a = i.charCodeAt(s + 1);
+        a >= 97 && a <= 122 && r.push(t), r.push(o + 32);
+      } else
+        n !== 0 && r.push(t), r.push(o + 32);
+      n = 1;
+    } else o >= 97 && o <= 122 ? (r.push(o), n = 2) : e.includes(o) ? (n !== 0 && r.push(t), n = 0) : r.push(o);
+  }
+  return String.fromCharCode(...r);
+}
+S(Me, "tokenize");
+function Ui(i) {
+  return Me(i, [45, 95], 45);
+}
+S(Ui, "paramCase");
+function Fi(i) {
+  return Me(i, [45, 95], 95);
+}
+S(Fi, "snakeCase");
+function zi(i) {
+  return typeof i != "string" ? `[${i.toString()}]` : /^[a-z_$][\w$]*$/i.test(i) ? `.${i}` : `[${JSON.stringify(i)}]`;
+}
+S(zi, "formatProperty");
+function xt(i) {
+  return i.replace(/\/$/, "");
+}
+S(xt, "trimSlash");
+function Ki(i) {
+  return i.startsWith("/") || (i = "/" + i), xt(i);
+}
+S(Ki, "sanitize");
+var ot;
+((i) => {
+  i.millisecond = 1, i.second = 1e3, i.minute = i.second * 60, i.hour = i.minute * 60, i.day = i.hour * 24, i.week = i.day * 7;
+  let e = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function t(g) {
+    e = g;
+  }
+  i.setTimezoneOffset = t, S(t, "setTimezoneOffset");
+  function r() {
+    return e;
+  }
+  i.getTimezoneOffset = r, S(r, "getTimezoneOffset");
+  function n(g = /* @__PURE__ */ new Date(), w) {
+    return typeof g == "number" && (g = new Date(g)), w === void 0 && (w = e), Math.floor((g.valueOf() / i.minute - w) / 1440);
+  }
+  i.getDateNumber = n, S(n, "getDateNumber");
+  function s(g, w) {
+    const O = new Date(g * i.day);
+    return w === void 0 && (w = e), new Date(+O + w * i.minute);
+  }
+  i.fromDateNumber = s, S(s, "fromDateNumber");
+  const o = /\d+(?:\.\d+)?/.source, a = new RegExp(`^${[
+    "w(?:eek(?:s)?)?",
+    "d(?:ay(?:s)?)?",
+    "h(?:our(?:s)?)?",
+    "m(?:in(?:ute)?(?:s)?)?",
+    "s(?:ec(?:ond)?(?:s)?)?"
+  ].map((g) => `(${o}${g})?`).join("")}$`);
+  function f(g) {
+    const w = a.exec(g);
+    return w ? (parseFloat(w[1]) * i.week || 0) + (parseFloat(w[2]) * i.day || 0) + (parseFloat(w[3]) * i.hour || 0) + (parseFloat(w[4]) * i.minute || 0) + (parseFloat(w[5]) * i.second || 0) : 0;
+  }
+  i.parseTime = f, S(f, "parseTime");
+  function u(g) {
+    const w = f(g);
+    return w ? g = Date.now() + w : /^\d{1,2}(:\d{1,2}){1,2}$/.test(g) ? g = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${g}` : /^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(g) && (g = `${(/* @__PURE__ */ new Date()).getFullYear()}-${g}`), g ? new Date(g) : /* @__PURE__ */ new Date();
+  }
+  i.parseDate = u, S(u, "parseDate");
+  function p(g) {
+    const w = Math.abs(g);
+    return w >= i.day - i.hour / 2 ? Math.round(g / i.day) + "d" : w >= i.hour - i.minute / 2 ? Math.round(g / i.hour) + "h" : w >= i.minute - i.second / 2 ? Math.round(g / i.minute) + "m" : w >= i.second ? Math.round(g / i.second) + "s" : g + "ms";
+  }
+  i.format = p, S(p, "format");
+  function y(g, w = 2) {
+    return g.toString().padStart(w, "0");
+  }
+  i.toDigits = y, S(y, "toDigits");
+  function _(g, w = /* @__PURE__ */ new Date()) {
+    return g.replace("yyyy", w.getFullYear().toString()).replace("yy", w.getFullYear().toString().slice(2)).replace("MM", y(w.getMonth() + 1)).replace("dd", y(w.getDate())).replace("hh", y(w.getHours())).replace("mm", y(w.getMinutes())).replace("ss", y(w.getSeconds())).replace("SSS", y(w.getMilliseconds(), 3));
+  }
+  i.template = _, S(_, "template");
+})(ot || (ot = {}));
+var qi = Object.defineProperty, k = (i, e) => qi(i, "name", { value: e, configurable: !0 }), b = {
+  // internal symbols
+  shadow: /* @__PURE__ */ Symbol.for("cordis.shadow"),
+  receiver: /* @__PURE__ */ Symbol.for("cordis.receiver"),
+  original: /* @__PURE__ */ Symbol.for("cordis.original"),
+  // context symbols
+  store: /* @__PURE__ */ Symbol.for("cordis.store"),
+  events: /* @__PURE__ */ Symbol.for("cordis.events"),
+  static: /* @__PURE__ */ Symbol.for("cordis.static"),
+  filter: /* @__PURE__ */ Symbol.for("cordis.filter"),
+  expose: /* @__PURE__ */ Symbol.for("cordis.expose"),
+  isolate: /* @__PURE__ */ Symbol.for("cordis.isolate"),
+  internal: /* @__PURE__ */ Symbol.for("cordis.internal"),
+  intercept: /* @__PURE__ */ Symbol.for("cordis.intercept"),
+  // service symbols
+  setup: /* @__PURE__ */ Symbol.for("cordis.setup"),
+  invoke: /* @__PURE__ */ Symbol.for("cordis.invoke"),
+  extend: /* @__PURE__ */ Symbol.for("cordis.extend"),
+  tracker: /* @__PURE__ */ Symbol.for("cordis.tracker"),
+  provide: /* @__PURE__ */ Symbol.for("cordis.provide"),
+  immediate: /* @__PURE__ */ Symbol.for("cordis.immediate")
+}, Hi = function* () {
+}.constructor, at = async function* () {
+}.constructor;
+function Ne(i) {
+  return !(!i.prototype || i instanceof Hi || at !== Function && i instanceof at);
+}
+k(Ne, "isConstructor");
+function se(i, e) {
+  const t = i.Config || i.schema;
+  return t && i.schema !== !1 && (e = t(e)), e ?? {};
+}
+k(se, "resolveConfig");
+function kt(i) {
+  return [Map, Set, Date, Promise].some((e) => i instanceof e);
+}
+k(kt, "isUnproxyable");
+function Be(i, e) {
+  if (i === Object.prototype) return e;
+  const t = Object.create(Be(Object.getPrototypeOf(i), e));
+  for (const r of Reflect.ownKeys(i))
+    Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(i, r));
+  return t;
+}
+k(Be, "joinPrototype");
+function Ue(i) {
+  return i && (typeof i == "object" || typeof i == "function");
+}
+k(Ue, "isObject");
+function U(i, e, t) {
+  if (!Ue(e)) return e;
+  if (Object.hasOwn(e, b.shadow))
+    return Object.getPrototypeOf(e);
+  const r = e[b.tracker];
+  return r ? ve(i, e, r, t) : e;
+}
+k(U, "getTraceable");
+function ie(i, e) {
+  return e ? new Proxy(i, {
+    get: /* @__PURE__ */ k((t, r, n) => r in e && r !== "constructor" ? Reflect.get(e, r, n) : Reflect.get(t, r, n), "get"),
+    set: /* @__PURE__ */ k((t, r, n, s) => r in e && r !== "constructor" ? Reflect.set(e, r, n, s) : Reflect.set(t, r, n, s), "set")
+  }) : i;
+}
+k(ie, "withProps");
+function ue(i, e, t) {
+  return ie(i, Object.defineProperty(/* @__PURE__ */ Object.create(null), e, {
+    value: t,
+    writable: !1
+  }));
+}
+k(ue, "withProp");
+function Ee(i, e, t, r) {
+  if (!t) return r;
+  const n = Reflect.getOwnPropertyDescriptor(e, t)?.value;
+  return n ? ue(r, t, i.extend({ [b.shadow]: n })) : r;
+}
+k(Ee, "createShadow");
+function St(i, e, t, r) {
+  return new Proxy(e, {
+    apply: /* @__PURE__ */ k((n, s, o) => (s === t && (s = r), o = o.map((a) => typeof a != "function" || a[b.original] ? a : new Proxy(a, {
+      get: /* @__PURE__ */ k((f, u, p) => {
+        if (u === b.original) return f;
+        const y = Reflect.get(f, u, p);
+        return u === "toString" && y === Function.prototype.toString ? function(..._) {
+          return Reflect.apply(y, this === p ? f : this, _);
+        } : y;
+      }, "get"),
+      apply: /* @__PURE__ */ k((f, u, p) => Reflect.apply(f, U(i, u), p.map((y) => U(i, y))), "apply"),
+      construct: /* @__PURE__ */ k((f, u, p) => Reflect.construct(f, u.map((y) => U(i, y)), p), "construct")
+    })), U(i, Reflect.apply(n, s, o))), "apply")
+  });
+}
+k(St, "createShadowMethod");
+function ve(i, e, t, r) {
+  i[b.shadow] && (i = Object.getPrototypeOf(i));
+  const n = new Proxy(e, {
+    get: /* @__PURE__ */ k((s, o, a) => {
+      if (o === b.original) return s;
+      if (o === t.property) return i;
+      if (typeof o == "symbol")
+        return Reflect.get(s, o, a);
+      if (t.associate && i[b.internal][`${t.associate}.${o}`])
+        return Reflect.get(i, `${t.associate}.${o}`, ue(i, b.receiver, a));
+      const f = Ee(i, s, t.property, a), u = Reflect.get(s, o, f), p = u?.[b.tracker];
+      return p ? ve(i, u, p) : !r && typeof u == "function" ? St(i, u, a, f) : u;
+    }, "get"),
+    set: /* @__PURE__ */ k((s, o, a, f) => {
+      if (o === b.original || o === t.property) return !1;
+      if (typeof o == "symbol")
+        return Reflect.set(s, o, a, f);
+      if (t.associate && i[b.internal][`${t.associate}.${o}`])
+        return Reflect.set(i, `${t.associate}.${o}`, a, ue(i, b.receiver, f));
+      const u = Ee(i, s, t.property, f);
+      return Reflect.set(s, o, a, u);
+    }, "set"),
+    apply: /* @__PURE__ */ k((s, o, a) => Fe(n, s, o, a), "apply")
+  });
+  return n;
+}
+k(ve, "createTraceable");
+function Fe(i, e, t, r) {
+  return e[b.invoke] ? e[b.invoke].apply(i, r) : Reflect.apply(e, t, r);
+}
+k(Fe, "applyTraceable");
+function Ce(i, e, t) {
+  const r = /* @__PURE__ */ k(function(...n) {
+    const s = ve(r.ctx, r, t);
+    return Fe(s, r, this, n);
+  }, "self");
+  return j(r, "name", i), Object.setPrototypeOf(r, e);
+}
+k(Ce, "createCallable");
+var Wi = class Q {
+  constructor(e) {
+    this.ctx = e, j(this, b.tracker, {
+      associate: "reflect",
+      property: "ctx"
+    }), this._mixin("reflect", ["get", "set", "provide", "accessor", "mixin", "alias"]), this._mixin("scope", ["config", "runtime", "effect", "collect", "accept", "decline"]), this._mixin("registry", ["using", "inject", "plugin"]), this._mixin("lifecycle", ["on", "once", "parallel", "emit", "serial", "bail", "start", "stop"]);
+  }
+  static {
+    k(this, "ReflectService");
+  }
+  static resolveInject(e, t) {
+    let r = e[b.internal][t];
+    for (; r?.type === "alias"; )
+      t = r.name, r = e[b.internal][t];
+    return [t, r];
+  }
+  static checkInject(e, t, r) {
+    if (e = e[b.shadow] ?? e, ["prototype", "then", "registry", "lifecycle"].includes(t) || t[0] === "$" || t[0] === "_" || !e.runtime.plugin || e.bail(e, "internal/inject", t)) return;
+    const n = r.stack.split(`
+`);
+    n.splice(1, 1), r.stack = n.join(`
+`), e.emit(e, "internal/warning", r);
+  }
+  static handler = {
+    get: /* @__PURE__ */ k((e, t, r) => {
+      if (typeof t != "string") return Reflect.get(e, t, r);
+      if (Reflect.has(e, t))
+        return U(r, Reflect.get(e, t, r), !0);
+      const [n, s] = Q.resolveInject(e, t), o = new Error(`property ${n} is not registered, declare it as \`inject\` to suppress this warning`);
+      return s ? s.type === "accessor" ? s.get.call(r, r[b.receiver]) : (s.builtin || Q.checkInject(r, n, o), r.reflect.get(n)) : (Q.checkInject(r, n, o), Reflect.get(e, n, r));
+    }, "get"),
+    set: /* @__PURE__ */ k((e, t, r, n) => {
+      if (typeof t != "string") return Reflect.set(e, t, r, n);
+      const [s, o] = Q.resolveInject(e, t);
+      return o ? o.type === "accessor" ? o.set ? o.set.call(n, r, n[b.receiver]) : !1 : (n.reflect.set(s, r), !0) : Reflect.set(e, s, r, n);
+    }, "set"),
+    has: /* @__PURE__ */ k((e, t) => {
+      if (typeof t != "string") return Reflect.has(e, t);
+      if (Reflect.has(e, t)) return !0;
+      const [, r] = Q.resolveInject(e, t);
+      return !!r;
+    }, "has")
+  };
+  get(e) {
+    if (this.ctx[b.internal][e]?.type !== "service") return;
+    const r = this.ctx[b.isolate][e], n = this.ctx[b.store][r]?.value;
+    return U(this.ctx, n);
+  }
+  set(e, t) {
+    this.provide(e);
+    const r = this.ctx[b.isolate][e], n = this.ctx[b.store][r]?.value;
+    t ??= void 0;
+    let s = /* @__PURE__ */ k(() => {
+    }, "dispose");
+    if (n === t) return s;
+    if (!I(t) && !I(n))
+      throw new Error(`service ${e} has been registered`);
+    const o = this.ctx;
+    I(t) || (s = o.effect(() => () => {
+      o.set(e, void 0);
+    })), kt(t) && o.emit(o, "internal/warning", new Error(`service ${e} is an unproxyable object, which may lead to unexpected behavior`));
+    const a = Object.create(o);
+    return a[b.filter] = (f) => o[b.isolate][e] === f[b.isolate][e], o.emit(a, "internal/before-service", e, t), o[b.store][r] = { value: t, source: o }, o.emit(a, "internal/service", e, n), s;
+  }
+  provide(e, t, r) {
+    const n = this.ctx.root[b.internal];
+    if (e in n) return;
+    const s = Symbol(e);
+    n[e] = { type: "service", builtin: r }, this.ctx.root[b.isolate][e] = s, Ue(t) && (this.ctx[b.store][s] = { value: t, source: null }, j(t, b.tracker, {
+      associate: e,
+      property: "ctx"
+    }));
+  }
+  _accessor(e, t) {
+    const r = this.ctx.root[b.internal];
+    return e in r ? () => {
+    } : (r[e] = { type: "accessor", ...t }, () => delete this.ctx.root[b.isolate][e]);
+  }
+  accessor(e, t) {
+    this.ctx.scope.effect(() => this._accessor(e, t));
+  }
+  alias(e, t) {
+    const r = this.ctx.root[b.internal];
+    if (!(e in r))
+      for (const n of t)
+        r[n] ||= { type: "alias", name: e };
+  }
+  _mixin(e, t) {
+    const r = Array.isArray(t) ? t.map((o) => [o, o]) : Object.entries(t), n = typeof e == "string" ? (o) => o[e] : () => e, s = r.map(([o, a]) => this._accessor(a, {
+      get(f) {
+        const u = n(this);
+        if (I(u)) return u;
+        const p = f ? ie(f, u) : u, y = Reflect.get(u, o, p);
+        return typeof y != "function" ? y : y.bind(p ?? u);
+      },
+      set(f, u) {
+        const p = n(this), y = u ? ie(u, p) : p;
+        return Reflect.set(p, o, f, y);
+      }
+    }));
+    return () => s.forEach((o) => o());
+  }
+  mixin(e, t) {
+    this.ctx.scope.effect(() => this._mixin(e, t));
+  }
+  trace(e) {
+    return U(this.ctx, e);
+  }
+  bind(e) {
+    return new Proxy(e, {
+      apply: /* @__PURE__ */ k((t, r, n) => t.apply(this.trace(r), n.map((s) => this.trace(s))), "apply")
+    });
+  }
+}, Ae = Wi;
+function Oe(i) {
+  return i !== null && i !== !1 && i !== void 0;
+}
+k(Oe, "isBailed");
+var Gi = class {
+  constructor(i) {
+    this.ctx = i, j(this, b.tracker, {
+      associate: "lifecycle",
+      property: "ctx"
+    }), j(this.on("internal/listener", function(t, r, n) {
+      const s = n.prepend ? "unshift" : "push";
+      if (t === "ready")
+        return this.lifecycle.isActive ? (this.scope.ensure(async () => r()), () => !1) : void 0;
+      if (t === "dispose")
+        return this.scope.disposables[s](r), j(r, "name", "event <dispose>"), () => W(this.scope.disposables, r);
+      if (t === "fork")
+        return this.scope.runtime.forkables[s](r), this.scope.collect("event <fork>", () => W(this.scope.runtime.forkables, r));
+    }), N.static, i.scope);
+    for (const t of ["info", "error", "warning"])
+      j(this.on(`internal/${t}`, (r, ...n) => {
+        this._hooks[`internal/${t}`].length > 1;
+      }), N.static, i.scope);
+    j(this.on("internal/before-service", function(t) {
+      for (const r of this.registry.values()) {
+        if (!r.inject[t]?.required) continue;
+        const n = r.isReusable ? r.children : [r];
+        for (const s of n)
+          this[b.filter](s.ctx) && (s.updateStatus(), s.reset());
+      }
+    }, { global: !0 }), N.static, i.scope), j(this.on("internal/service", function(t) {
+      for (const r of this.registry.values()) {
+        if (!r.inject[t]?.required) continue;
+        const n = r.isReusable ? r.children : [r];
+        for (const s of n)
+          this[b.filter](s.ctx) && s.start();
+      }
+    }, { global: !0 }), N.static, i.scope);
+    const e = /* @__PURE__ */ k((t, r) => {
+      if (!t.runtime.plugin) return !1;
+      for (const n in t.runtime.inject)
+        if (r === Ae.resolveInject(t.ctx, n)[0]) return !0;
+      return e(t.parent.scope, r);
+    }, "checkInject");
+    j(this.on("internal/inject", function(t) {
+      return e(this.scope, t);
+    }, { global: !0 }), N.static, i.scope);
+  }
+  static {
+    k(this, "Lifecycle");
+  }
+  isActive = !1;
+  _tasks = /* @__PURE__ */ new Set();
+  _hooks = {};
+  async flush() {
+    for (; this._tasks.size; )
+      await Promise.all(Array.from(this._tasks));
+  }
+  filterHooks(i, e) {
+    return e = U(this.ctx, e), i.slice().filter((t) => {
+      const r = e?.[N.filter];
+      return t.global || !r || r.call(e, t.ctx);
+    });
+  }
+  *dispatch(i, e) {
+    const t = typeof e[0] == "object" || typeof e[0] == "function" ? e.shift() : null, r = e.shift();
+    r !== "internal/event" && this.emit("internal/event", i, r, e, t);
+    for (const n of this.filterHooks(this._hooks[r] || [], t))
+      yield n.callback.apply(t, e);
+  }
+  async parallel(...i) {
+    await Promise.all(this.dispatch("emit", i));
+  }
+  emit(...i) {
+    Array.from(this.dispatch("emit", i));
+  }
+  async serial(...i) {
+    for await (const e of this.dispatch("serial", i))
+      if (Oe(e)) return e;
+  }
+  bail(...i) {
+    for (const e of this.dispatch("bail", i))
+      if (Oe(e)) return e;
+  }
+  register(i, e, t, r) {
+    const n = r.prepend ? "unshift" : "push";
+    return e[n]({ ctx: this.ctx, callback: t, ...r }), this.ctx.state.collect(i, () => this.unregister(e, t));
+  }
+  unregister(i, e) {
+    const t = i.findIndex((r) => r.callback === e);
+    if (t >= 0)
+      return i.splice(t, 1), !0;
+  }
+  on(i, e, t) {
+    typeof t != "object" && (t = { prepend: t }), this.ctx.scope.assertActive(), e = this.ctx.reflect.bind(e);
+    const r = this.bail(this.ctx, "internal/listener", i, e, t);
+    if (r) return r;
+    const n = this._hooks[i] ||= [], s = typeof i == "string" ? `event <${i}>` : "event (Symbol)";
+    return this.register(s, n, e, t);
+  }
+  once(i, e, t) {
+    const r = this.on(i, function(...n) {
+      return r(), e.apply(this, n);
+    }, t);
+    return r;
+  }
+  async start() {
+    this.isActive = !0;
+    const i = this._hooks.ready || [];
+    for (; i.length; ) {
+      const { ctx: e, callback: t } = i.shift();
+      e.scope.ensure(async () => t());
+    }
+    await this.flush();
+  }
+  async stop() {
+    this.isActive = !1, this.ctx.scope.reset();
+  }
+}, Vi = Gi, Ji = /* @__PURE__ */ ((i) => (i[i.PENDING = 0] = "PENDING", i[i.LOADING = 1] = "LOADING", i[i.ACTIVE = 2] = "ACTIVE", i[i.FAILED = 3] = "FAILED", i[i.DISPOSED = 4] = "DISPOSED", i))(Ji || {}), Pe = class $t extends Error {
+  constructor(e, t) {
+    super(t ?? $t.Code[e]), this.code = e;
+  }
+  static {
+    k(this, "CordisError");
+  }
+};
+((i) => {
+  i.Code = {
+    INACTIVE_EFFECT: "cannot create effect on inactive context"
+  };
+})(Pe || (Pe = {}));
+var Et = class {
+  constructor(i, e) {
+    this.parent = i, this.config = e, this.uid = i.registry ? i.registry.counter : 0, this.ctx = this.context = i.extend({ scope: this }), this.proxy = new Proxy({}, {
+      get: /* @__PURE__ */ k((t, r) => Reflect.get(this.config, r), "get")
+    });
+  }
+  static {
+    k(this, "EffectScope");
+  }
+  uid;
+  ctx;
+  disposables = [];
+  error;
+  status = 0;
+  isActive = !1;
+  // Same as `this.ctx`, but with a more specific type.
+  context;
+  proxy;
+  acceptors = [];
+  tasks = /* @__PURE__ */ new Set();
+  hasError = !1;
+  get _config() {
+    return this.runtime.isReactive ? this.proxy : this.config;
+  }
+  assertActive() {
+    if (!(this.uid !== null || this.isActive))
+      throw new Pe("INACTIVE_EFFECT");
+  }
+  effect(i, e) {
+    this.assertActive();
+    const t = Ne(i) ? new i(this.ctx, e) : i(this.ctx, e);
+    let r = !1;
+    const n = typeof t == "function" ? t : t.dispose.bind(t), s = /* @__PURE__ */ k((...o) => {
+      if (!r)
+        return r = !0, W(this.disposables, s), n(...o);
+    }, "wrapped");
+    return this.disposables.push(s), typeof t == "function" ? s : (t.dispose = s, t);
+  }
+  collect(i, e) {
+    const t = j(() => (W(this.disposables, t), e()), "name", i);
+    return this.disposables.push(t), t;
+  }
+  restart() {
+    this.reset(), this.error = null, this.hasError = !1, this.status = 0, this.start();
+  }
+  _getStatus() {
+    return this.uid === null ? 4 : this.hasError ? 3 : this.tasks.size ? 1 : this.ready ? 2 : 0;
+  }
+  updateStatus(i) {
+    const e = this.status;
+    i?.(), this.status = this._getStatus(), e !== this.status && this.context.emit("internal/status", this, e);
+  }
+  ensure(i) {
+    const e = i().catch((t) => {
+      this.context.emit(this.ctx, "internal/error", t), this.cancel(t);
+    }).finally(() => {
+      this.updateStatus(() => this.tasks.delete(e)), this.context.events._tasks.delete(e);
+    });
+    this.updateStatus(() => this.tasks.add(e)), this.context.events._tasks.add(e);
+  }
+  cancel(i) {
+    this.error = i, this.updateStatus(() => this.hasError = !0), this.reset();
+  }
+  get ready() {
+    return Object.entries(this.runtime.inject).every(([i, e]) => !e.required || !I(this.ctx.get(i)));
+  }
+  reset() {
+    this.isActive = !1, this.disposables = this.disposables.splice(0).filter((i) => {
+      if (this.uid !== null && i[N.static] === this) return !0;
+      (async () => i())().catch((e) => {
+        this.context.emit(this.ctx, "internal/error", e);
+      });
+    });
+  }
+  init(i) {
+    this.config ? this.start() : this.cancel(i);
+  }
+  start() {
+    if (!this.ready || this.isActive || this.uid === null) return !0;
+    this.isActive = !0, this.updateStatus(() => this.hasError = !1);
+  }
+  accept(...i) {
+    const t = { keys: Array.isArray(i[0]) ? i.shift() : null, callback: i[0], ...i[1] };
+    return this.effect(() => (this.acceptors.push(t), t.immediate && t.callback?.(this.config), () => W(this.acceptors, t)));
+  }
+  decline(i) {
+    return this.accept(i, () => !0);
+  }
+  checkUpdate(i, e) {
+    if (e || !this.config) return [!0, !0];
+    if (e === !1) return [!1, !1];
+    const t = /* @__PURE__ */ Object.create(null), r = /* @__PURE__ */ k((f) => {
+      const u = t[f] ??= !J(this.config[f], i[f]);
+      return s ||= u, u;
+    }, "checkPropertyUpdate"), n = /* @__PURE__ */ new Set();
+    let s = !1, o = !1, a = this.runtime.isReactive || null;
+    for (const { keys: f, callback: u, passive: p } of this.acceptors) {
+      if (!f)
+        a ||= !p;
+      else if (p)
+        f?.forEach((_) => n.add(_));
+      else {
+        let _ = !1;
+        for (const g of f)
+          _ ||= r(g);
+        if (!_) continue;
+      }
+      u?.(i) && (o = !0);
+    }
+    for (const f in { ...this.config, ...i })
+      if (a !== !1 && !(f in t) && !n.has(f)) {
+        const u = r(f);
+        a === null && (o ||= u);
+      }
+    return [s, o];
+  }
+}, Yi = class extends Et {
+  constructor(i, e, t, r) {
+    super(i, t), this.runtime = e, this.dispose = j(i.scope.collect(`fork <${i.runtime.name}>`, () => {
+      this.uid = null, this.reset(), this.context.emit("internal/fork", this);
+      const n = W(e.disposables, this.dispose);
+      return W(e.children, this) && !e.children.length && i.registry.delete(e.plugin), n;
+    }), N.static, e), e.children.push(this), e.disposables.push(this.dispose), this.context.emit("internal/fork", this), this.init(r);
+  }
+  static {
+    k(this, "ForkScope");
+  }
+  dispose;
+  start() {
+    if (super.start()) return !0;
+    for (const i of this.runtime.forkables)
+      this.ensure(async () => i(this.context, this._config));
+  }
+  update(i, e) {
+    const t = this.config, r = this.runtime.isForkable ? this : this.runtime;
+    if (r.config !== t) return;
+    let n;
+    try {
+      n = se(this.runtime.plugin, i);
+    } catch (a) {
+      return this.context.emit("internal/error", a), this.cancel(a);
+    }
+    const [s, o] = r.checkUpdate(n, e);
+    this.context.emit("internal/before-update", this, i), this.config = n, r.config = n, s && this.context.emit("internal/update", this, t), o && r.restart();
+  }
+}, ct = class extends Et {
+  constructor(i, e, t, r) {
+    super(i, t), this.plugin = e, e ? (this.setup(), this.init(r)) : (this.name = "root", this.isActive = !0);
+  }
+  static {
+    k(this, "MainScope");
+  }
+  value;
+  runtime = this;
+  schema;
+  name;
+  inject = /* @__PURE__ */ Object.create(null);
+  forkables = [];
+  children = [];
+  isReusable = !1;
+  isReactive = !1;
+  get isForkable() {
+    return this.forkables.length > 0;
+  }
+  fork(i, e, t) {
+    return new Yi(i, this, e, t);
+  }
+  dispose() {
+    return this.uid = null, this.reset(), this.context.emit("internal/runtime", this), !0;
+  }
+  setup() {
+    const { name: i } = this.plugin;
+    i && i !== "apply" && (this.name = i), this.schema = this.plugin.Config || this.plugin.schema, this.inject = F.resolve(this.plugin.using || this.plugin.inject), this.isReusable = this.plugin.reusable, this.isReactive = this.plugin.reactive, this.context.emit("internal/runtime", this), this.isReusable && this.forkables.push(this.apply);
+  }
+  apply = /* @__PURE__ */ k((i, e) => {
+    if (typeof this.plugin != "function")
+      return this.plugin.apply(i, e);
+    if (Ne(this.plugin)) {
+      const t = new this.plugin(i, e), r = t[N.expose];
+      return r && i.set(r, t), t.fork && this.forkables.push(t.fork.bind(t)), t;
+    } else
+      return this.plugin(i, e);
+  }, "apply");
+  reset() {
+    super.reset();
+    for (const i of this.children)
+      i.reset();
+  }
+  start() {
+    if (super.start()) return !0;
+    !this.isReusable && this.plugin && this.ensure(async () => this.value = this.apply(this.ctx, this._config));
+    for (const i of this.children)
+      i.start();
+  }
+  update(i, e) {
+    if (this.isForkable) {
+      const a = new Error(`attempting to update forkable plugin "${this.plugin.name}", which may lead to unexpected behavior`);
+      this.context.emit(this.ctx, "internal/warning", a);
+    }
+    const t = this.config;
+    let r;
+    try {
+      r = se(this.runtime.plugin || this.context.constructor, i);
+    } catch (a) {
+      return this.context.emit("internal/error", a), this.cancel(a);
+    }
+    const [n, s] = this.checkUpdate(r, e), o = this.children.find((a) => a.config === t);
+    this.config = r, o && (this.context.emit("internal/before-update", o, i), o.config = r, n && this.context.emit("internal/update", o, t)), s && this.restart();
+  }
+};
+function Ct(i) {
+  return i && typeof i == "object" && typeof i.apply == "function";
+}
+k(Ct, "isApplicable");
+function F(i) {
+  return function(e, t) {
+    if (t.kind === "class")
+      e.inject = i;
+    else if (t.kind === "method")
+      t.addInitializer(function() {
+        const r = this[b.tracker]?.property;
+        if (!r) throw new Error("missing context tracker");
+        this[r].inject(i, (n) => {
+          e.call(ie(this, { [r]: n }));
+        });
+      });
+    else
+      throw new Error("@Inject can only be used on class or class methods");
+  };
+}
+k(F, "Inject");
+((i) => {
+  function e(t) {
+    if (!t) return {};
+    if (Array.isArray(t))
+      return Object.fromEntries(t.map((o) => [o, { required: !0 }]));
+    const { required: r, optional: n, ...s } = t;
+    return Array.isArray(r) && Object.assign(s, Object.fromEntries(r.map((o) => [o, { required: !0 }]))), Array.isArray(n) && Object.assign(s, Object.fromEntries(n.map((o) => [o, { required: !1 }]))), s;
+  }
+  i.resolve = e, k(e, "resolve");
+})(F || (F = {}));
+var Xi = class {
+  constructor(i, e) {
+    this.ctx = i, j(this, b.tracker, {
+      associate: "registry",
+      property: "ctx"
+    }), this.context = i;
+    const t = new ct(i, null, e);
+    i.scope = t, t.ctx = i, this.set(null, t);
+  }
+  static {
+    k(this, "Registry");
+  }
+  _counter = 0;
+  _internal = /* @__PURE__ */ new Map();
+  context;
+  get counter() {
+    return ++this._counter;
+  }
+  get size() {
+    return this._internal.size;
+  }
+  resolve(i, e = !1) {
+    if (i === null || typeof i == "function") return i;
+    if (Ct(i)) return i.apply;
+    if (e) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof i);
+  }
+  get(i) {
+    const e = this.resolve(i);
+    return e && this._internal.get(e);
+  }
+  has(i) {
+    const e = this.resolve(i);
+    return !!e && this._internal.has(e);
+  }
+  set(i, e) {
+    const t = this.resolve(i);
+    this._internal.set(t, e);
+  }
+  delete(i) {
+    const e = this.resolve(i), t = e && this._internal.get(e);
+    if (t)
+      return this._internal.delete(e), t.dispose(), t;
+  }
+  keys() {
+    return this._internal.keys();
+  }
+  values() {
+    return this._internal.values();
+  }
+  entries() {
+    return this._internal.entries();
+  }
+  forEach(i) {
+    return this._internal.forEach(i);
+  }
+  using(i, e) {
+    return this.inject(i, e);
+  }
+  inject(i, e) {
+    return this.plugin({ inject: i, apply: e, name: e.name });
+  }
+  plugin(i, e, t) {
+    if (this.resolve(i, !0), this.ctx.scope.assertActive(), !t)
+      try {
+        e = se(i, e);
+      } catch (n) {
+        this.context.emit(this.ctx, "internal/error", n), t = n, e = null;
+      }
+    let r = this.get(i);
+    return r ? (r.isForkable || this.context.emit(this.ctx, "internal/warning", new Error(`duplicate plugin detected: ${i.name}`)), r.fork(this.ctx, e, t)) : (r = new ct(this.ctx, i, e, t), this.set(i, r), r.fork(this.ctx, e, t));
+  }
+}, Qi = Xi, N = class ee {
+  static {
+    k(this, "Context");
+  }
+  static store = b.store;
+  static events = b.events;
+  static static = b.static;
+  static filter = b.filter;
+  static expose = b.expose;
+  static isolate = b.isolate;
+  static internal = b.internal;
+  static intercept = b.intercept;
+  static origin = "ctx";
+  static current = "ctx";
+  static is(e) {
+    return !!e?.[ee.is];
+  }
+  static {
+    ee.is[Symbol.toPrimitive] = () => /* @__PURE__ */ Symbol.for("cordis.is"), ee.prototype[ee.is] = !0;
+  }
+  /** @deprecated use `Service.traceable` instead */
+  static associate(e, t) {
+    return e;
+  }
+  constructor(e) {
+    e = se(this.constructor, e), this[b.store] = /* @__PURE__ */ Object.create(null), this[b.isolate] = /* @__PURE__ */ Object.create(null), this[b.internal] = /* @__PURE__ */ Object.create(null), this[b.intercept] = /* @__PURE__ */ Object.create(null);
+    const t = new Proxy(this, Ae.handler);
+    t.root = t, t.reflect = new Ae(t), t.registry = new Qi(t, e), t.lifecycle = new Vi(t);
+    const r = /* @__PURE__ */ k((n) => {
+      if (n) {
+        r(Object.getPrototypeOf(n));
+        for (const s of Object.getOwnPropertyNames(n)) {
+          const o = n[s].prototype?.constructor;
+          o && (t[n[s].key] = new o(t, e), j(t[n[s].key], "ctx", t));
+        }
+      }
+    }, "attach");
+    return r(this[b.internal]), t;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Context <${this.name}>`;
+  }
+  get name() {
+    let e = this.runtime;
+    for (; e && !e.name; )
+      e = e.parent.runtime;
+    return e?.name;
+  }
+  get events() {
+    return this.lifecycle;
+  }
+  /** @deprecated */
+  get state() {
+    return this.scope;
+  }
+  extend(e = {}) {
+    const t = Reflect.getOwnPropertyDescriptor(this, b.shadow)?.value, r = Object.assign(Object.create(U(this, this)), e);
+    return t ? Object.assign(Object.create(r), { [b.shadow]: t }) : r;
+  }
+  isolate(e, t) {
+    const r = Object.create(this[b.isolate]);
+    return r[e] = t ?? Symbol(e), this.extend({ [b.isolate]: r });
+  }
+  intercept(e, t) {
+    const r = Object.create(this[b.intercept]);
+    return r[e] = t, this.extend({ [b.intercept]: r });
+  }
+};
+N.prototype[N.internal] = /* @__PURE__ */ Object.create(null);
+var z = class At {
+  static {
+    k(this, "Service");
+  }
+  static setup = b.setup;
+  static invoke = b.invoke;
+  static extend = b.extend;
+  static tracker = b.tracker;
+  static provide = b.provide;
+  static immediate = b.immediate;
+  start() {
+  }
+  stop() {
+  }
+  ctx;
+  name;
+  config;
+  constructor(...e) {
+    let t, r, n, s;
+    N.is(e[0]) ? (t = e[0], typeof e[1] == "string" ? (r = e[1], n = e[2]) : s = e[1]) : s = e[0], r ??= this.constructor[b.provide], n ??= this.constructor[b.immediate];
+    let o = this;
+    const a = {
+      associate: r,
+      property: "ctx"
+    };
+    return o[b.invoke] && (o = Ce(r, Be(Object.getPrototypeOf(this), Function.prototype), a)), t ? o.ctx = t : o[b.setup](), o.name = r, o.config = s, j(o, b.tracker, a), o.ctx.provide(r), o.ctx.runtime.name = r, n && (t ? o[b.expose] = r : o.ctx.set(r, o)), o.ctx.on("ready", async () => {
+      await Promise.resolve(), await o.start(), n || o.ctx.set(r, o);
+    }), o.ctx.on("dispose", () => o.stop()), o;
+  }
+  [b.filter](e) {
+    return e[b.isolate][this.name] === this.ctx[b.isolate][this.name];
+  }
+  [b.setup]() {
+    this.ctx = new N();
+  }
+  [b.extend](e) {
+    let t;
+    return this[At.invoke] ? t = Ce(this.name, this, this[b.tracker]) : t = Object.create(this), Object.assign(t, e);
+  }
+  static [Symbol.hasInstance](e) {
+    let t = e.constructor;
+    for (; t; ) {
+      if (t = t.prototype?.constructor, t === this) return !0;
+      t = Object.getPrototypeOf(t);
+    }
+    return !1;
+  }
+}, Zi = Object.defineProperty, er = Object.getOwnPropertyNames, E = (i, e) => Zi(i, "name", { value: e, configurable: !0 }), tr = (i, e) => function() {
+  return e || (0, i[er(i)[0]])((e = { exports: {} }).exports, e), e.exports;
+}, ir = tr({
+  "src/index.ts"(i, e) {
+    var t = /* @__PURE__ */ Symbol.for("schemastery"), r = /* @__PURE__ */ Symbol.for("ValidationError");
+    globalThis.__schemastery_index__ ??= 0, globalThis.__schemastery_refs__ = void 0;
+    var n = class extends TypeError {
+      constructor(l, c) {
+        let h = "$";
+        for (const d of c.path || [])
+          typeof d == "string" ? h += "." + d : typeof d == "number" ? h += "[" + d + "]" : typeof d == "symbol" && (h += `[Symbol(${d.toString()})]`);
+        h.startsWith(".") && (h = h.slice(1)), super((h === "$" ? "" : `${h} `) + l), this.options = c;
+      }
+      static {
+        E(this, "ValidationError");
+      }
+      name = "ValidationError";
+      static is(l) {
+        return !!l?.[r];
+      }
+    };
+    Object.defineProperty(n.prototype, r, {
+      value: !0
+    });
+    var s = /* @__PURE__ */ E(function(l) {
+      const c = /* @__PURE__ */ E(function(h, d = {}) {
+        return s.resolve(h, c, d)[0];
+      }, "schema");
+      if (l.refs) {
+        const h = q(l.refs, (m) => new s(m)), d = /* @__PURE__ */ E((m) => h[m], "getRef");
+        for (const m in h) {
+          const v = h[m];
+          v.sKey = d(v.sKey), v.inner = d(v.inner), v.list = v.list && v.list.map(d), v.dict = v.dict && q(v.dict, d);
+        }
+        return h[l.uid];
+      }
+      if (Object.assign(c, l), typeof c.callback == "string")
+        try {
+          c.callback = new Function("return " + c.callback)();
+        } catch {
+        }
+      return Object.defineProperty(c, "uid", { value: globalThis.__schemastery_index__++ }), Object.setPrototypeOf(c, s.prototype), c.meta ||= {}, c.toString = c.toString.bind(c), c;
+    }, "Schema");
+    s.prototype = Object.create(Function.prototype), s.prototype[t] = !0, s.ValidationError = n, s.prototype.toJSON = /* @__PURE__ */ E(function() {
+      if (globalThis.__schemastery_refs__)
+        return globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this })), this.uid;
+      globalThis.__schemastery_refs__ = { [this.uid]: { ...this } }, globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+      const c = { uid: this.uid, refs: globalThis.__schemastery_refs__ };
+      return globalThis.__schemastery_refs__ = void 0, c;
+    }, "toJSON"), s.prototype.set = /* @__PURE__ */ E(function(c, h) {
+      return this.dict[c] = h, this;
+    }, "set"), s.prototype.push = /* @__PURE__ */ E(function(c) {
+      return this.list.push(c), this;
+    }, "push");
+    function o(l, c) {
+      const h = typeof l == "string" ? { "": l } : { ...l };
+      for (const d in c) {
+        const m = c[d];
+        m?.$description || m?.$desc ? h[d] = m.$description || m.$desc : typeof m == "string" && (h[d] = m);
+      }
+      return h;
+    }
+    E(o, "mergeDesc");
+    function a(l) {
+      return l?.$value ?? l?.$inner;
+    }
+    E(a, "getInner");
+    function f(l) {
+      return bt(l ?? {}, (c) => !c.startsWith("$"));
+    }
+    E(f, "extractKeys"), s.prototype.i18n = /* @__PURE__ */ E(function(c) {
+      const h = s(this), d = o(h.meta.description, c);
+      return Object.keys(d).length && (h.meta.description = d), h.dict && (h.dict = q(h.dict, (m, v) => m.i18n(q(c, (x) => a(x)?.[v] ?? x?.[v])))), h.list && (h.list = h.list.map((m, v) => m.i18n(q(c, (x = {}) => Array.isArray(a(x)) ? a(x)[v] : Array.isArray(x) ? x[v] : f(x))))), h.inner && (h.inner = h.inner.i18n(q(c, (m) => a(m) ? a(m) : f(m)))), h.sKey && (h.sKey = h.sKey.i18n(q(c, (m) => m?.$key))), h;
+    }, "i18n"), s.prototype.extra = /* @__PURE__ */ E(function(c, h) {
+      const d = s(this);
+      return d.meta = { ...d.meta, [c]: h }, d;
+    }, "extra");
+    for (const l of ["required", "disabled", "collapse", "hidden", "loose"])
+      Object.assign(s.prototype, {
+        [l](c = !0) {
+          const h = s(this);
+          return h.meta = { ...h.meta, [l]: c }, h;
+        }
+      });
+    s.prototype.deprecated = /* @__PURE__ */ E(function() {
+      const c = s(this);
+      return c.meta.badges ||= [], c.meta.badges.push({ text: "deprecated", type: "danger" }), c;
+    }, "deprecated"), s.prototype.experimental = /* @__PURE__ */ E(function() {
+      const c = s(this);
+      return c.meta.badges ||= [], c.meta.badges.push({ text: "experimental", type: "warning" }), c;
+    }, "experimental"), s.prototype.pattern = /* @__PURE__ */ E(function(c) {
+      const h = s(this), d = vt(c, ["source", "flags"]);
+      return h.meta = { ...h.meta, pattern: d }, h;
+    }, "pattern"), s.prototype.simplify = /* @__PURE__ */ E(function(c) {
+      if (J(c, this.meta.default, this.type === "dict")) return null;
+      if (I(c)) return c;
+      if (this.type === "object" || this.type === "dict") {
+        const h = {};
+        for (const d in c) {
+          const v = (this.type === "object" ? this.dict[d] : this.inner)?.simplify(c[d]);
+          (this.type === "dict" || !I(v)) && (h[d] = v);
+        }
+        return J(h, this.meta.default, this.type === "dict") ? null : h;
+      } else if (this.type === "array" || this.type === "tuple") {
+        const h = [];
+        return c.forEach((d, m) => {
+          const v = this.type === "array" ? this.inner : this.list[m], x = v ? v.simplify(d) : d;
+          h.push(x);
+        }), h;
+      } else if (this.type === "intersect") {
+        const h = {};
+        for (const d of this.list)
+          Object.assign(h, d.simplify(c));
+        return h;
+      } else if (this.type === "union")
+        for (const h of this.list)
+          try {
+            return s.resolve(c, h, {}), h.simplify(c);
+          } catch {
+          }
+      return c;
+    }, "simplify"), s.prototype.toString = /* @__PURE__ */ E(function(c) {
+      return O[this.type]?.(this, c) ?? `Schema<${this.type}>`;
+    }, "toString"), s.prototype.role = /* @__PURE__ */ E(function(l, c) {
+      const h = s(this);
+      return h.meta = { ...h.meta, role: l, extra: c }, h;
+    }, "role");
+    for (const l of ["default", "link", "comment", "description", "max", "min", "step"])
+      Object.assign(s.prototype, {
+        [l](c) {
+          const h = s(this);
+          return h.meta = { ...h.meta, [l]: c }, h;
+        }
+      });
+    var u = {};
+    s.extend = /* @__PURE__ */ E(function(c, h) {
+      u[c] = h;
+    }, "extend"), s.resolve = /* @__PURE__ */ E(function(c, h, d = {}, m = !1) {
+      if (!h) return [c];
+      if (d.ignore?.(c, h)) return [c];
+      if (I(c) && h.type !== "lazy") {
+        if (h.meta.required) throw new n("missing required value", d);
+        let x = h, A = h.meta.default;
+        for (; x?.type === "intersect" && I(A); )
+          x = x.list[0], A = x?.meta.default;
+        if (I(A)) return [c];
+        c = he(A);
+      }
+      const v = u[h.type];
+      if (!v) throw new n(`unsupported type "${h.type}"`, d);
+      try {
+        return v(c, h, d, m);
+      } catch (x) {
+        if (!h.meta.loose) throw x;
+        return [h.meta.default];
+      }
+    }, "resolve"), s.from = /* @__PURE__ */ E(function(c) {
+      if (I(c))
+        return s.any();
+      if (["string", "number", "boolean"].includes(typeof c))
+        return s.const(c).required();
+      if (c[t])
+        return c;
+      if (typeof c == "function")
+        switch (c) {
+          case String:
+            return s.string().required();
+          case Number:
+            return s.number().required();
+          case Boolean:
+            return s.boolean().required();
+          case Function:
+            return s.function().required();
+          default:
+            return s.is(c).required();
+        }
+      else
+        throw new TypeError(`cannot infer schema from ${c}`);
+    }, "from"), s.lazy = /* @__PURE__ */ E(function(c) {
+      const h = /* @__PURE__ */ E(() => (d.inner[t] || (d.inner = d.builder(), d.inner.meta = { ...d.meta, ...d.inner.meta }), d.inner.toJSON()), "toJSON"), d = new s({ type: "lazy", builder: c, inner: { toJSON: h } });
+      return d;
+    }, "lazy"), s.natural = /* @__PURE__ */ E(function() {
+      return s.number().step(1).min(0);
+    }, "natural"), s.percent = /* @__PURE__ */ E(function() {
+      return s.number().step(0.01).min(0).max(1).role("slider");
+    }, "percent"), s.date = /* @__PURE__ */ E(function() {
+      return s.union([
+        s.is(Date),
+        s.transform(s.string().role("datetime"), (c, h) => {
+          const d = new Date(c);
+          if (isNaN(+d)) throw new n(`invalid date "${c}"`, h);
+          return d;
+        }, !0)
+      ]);
+    }, "date"), s.regExp = /* @__PURE__ */ E(function(c = "") {
+      return s.union([
+        s.is(RegExp),
+        s.transform(s.string().role("regexp", { flag: c }), (h, d) => {
+          try {
+            return new RegExp(h, c);
+          } catch (m) {
+            throw new n(m.message, d);
+          }
+        }, !0)
+      ]);
+    }, "regExp"), s.arrayBuffer = /* @__PURE__ */ E(function(c) {
+      return s.union([
+        s.is(ArrayBuffer),
+        s.is(SharedArrayBuffer),
+        s.transform(s.any(), (h, d) => {
+          if (B.isSource(h)) return B.fromSource(h);
+          throw new n(`expected ArrayBufferSource but got ${h}`, d);
+        }, !0),
+        ...c ? [s.transform(s.string(), (h, d) => {
+          try {
+            return c === "base64" ? B.fromBase64(h) : B.fromHex(h);
+          } catch (m) {
+            throw new n(m.message, d);
+          }
+        }, !0)] : []
+      ]);
+    }, "arrayBuffer"), s.extend("lazy", (l, c, h, d) => (c.inner[t] || (c.inner = c.builder(), c.inner.meta = { ...c.meta, ...c.inner.meta }), s.resolve(l, c.inner, h, d))), s.extend("any", (l) => [l]), s.extend("never", (l, c, h) => {
+      throw new n(`expected nullable but got ${l}`, h);
+    }), s.extend("const", (l, { value: c }, h) => {
+      if (J(l, c)) return [c];
+      throw new n(`expected ${c} but got ${l}`, h);
+    });
+    function p(l, c, h, d, m = !1) {
+      const { max: v = 1 / 0, min: x = -1 / 0 } = c;
+      if (l > v) throw new n(`expected ${h} <= ${v} but got ${l}`, d);
+      if (l < x && !m) throw new n(`expected ${h} >= ${x} but got ${l}`, d);
+    }
+    E(p, "checkWithinRange"), s.extend("string", (l, { meta: c }, h) => {
+      if (typeof l != "string") throw new n(`expected string but got ${l}`, h);
+      if (c.pattern) {
+        const d = new RegExp(c.pattern.source, c.pattern.flags);
+        if (!d.test(l)) throw new n(`expect string to match regexp ${d}`, h);
+      }
+      return p(l.length, c, "string length", h), [l];
+    });
+    function y(l, c) {
+      const h = l.toString();
+      if (h.includes("e")) return l * Math.pow(10, c);
+      const d = h.indexOf(".");
+      if (d === -1) return l * Math.pow(10, c);
+      const m = h.slice(d + 1), v = h.slice(0, d);
+      return m.length <= c ? +(v + m.padEnd(c, "0")) : +(v + m.slice(0, c) + "." + m.slice(c));
+    }
+    E(y, "decimalShift");
+    function _(l, c, h) {
+      if (h = Math.abs(h), !/^\d+\.\d+$/.test(h.toString()))
+        return (l - c) % h === 0;
+      const d = h.toString().indexOf("."), m = h.toString().slice(d + 1).length;
+      return Math.abs(y(l, m) - y(c, m)) % y(h, m) === 0;
+    }
+    E(_, "isMultipleOf"), s.extend("number", (l, { meta: c }, h) => {
+      if (typeof l != "number") throw new n(`expected number but got ${l}`, h);
+      p(l, c, "number", h);
+      const { step: d } = c;
+      if (d && !_(l, c.min ?? 0, d))
+        throw new n(`expected number multiple of ${d} but got ${l}`, h);
+      return [l];
+    }), s.extend("boolean", (l, c, h) => {
+      if (typeof l == "boolean") return [l];
+      throw new n(`expected boolean but got ${l}`, h);
+    }), s.extend("bitset", (l, { bits: c, meta: h }, d) => {
+      let m = 0, v = [];
+      if (typeof l == "number") {
+        m = l;
+        for (const x in c)
+          l & c[x] && v.push(x);
+      } else if (Array.isArray(l)) {
+        v = l;
+        for (const x of v) {
+          if (typeof x != "string") throw new n(`expected string but got ${x}`, d);
+          x in c && (m |= c[x]);
+        }
+      } else
+        throw new n(`expected number or array but got ${l}`, d);
+      return m === h.default ? [m] : [m, v];
+    }), s.extend("function", (l, c, h) => {
+      if (typeof l == "function") return [l];
+      throw new n(`expected function but got ${l}`, h);
+    }), s.extend("is", (l, { constructor: c }, h) => {
+      if (typeof c == "function") {
+        if (l instanceof c) return [l];
+        throw new n(`expected ${c.name} but got ${l}`, h);
+      } else {
+        if (I(l))
+          throw new n(`expected ${c} but got ${l}`, h);
+        let d = Object.getPrototypeOf(l);
+        for (; d; ) {
+          if (d.constructor?.name === c) return [l];
+          d = Object.getPrototypeOf(d);
+        }
+        throw new n(`expected ${c} but got ${l}`, h);
+      }
+    });
+    function g(l, c, h, d) {
+      try {
+        const [m, v] = s.resolve(l[c], h, {
+          ...d,
+          path: [...d.path || [], c]
+        });
+        return v !== void 0 && (l[c] = v), m;
+      } catch (m) {
+        if (!d?.autofix) throw m;
+        return delete l[c], h.meta.default;
+      }
+    }
+    E(g, "property"), s.extend("array", (l, { inner: c, meta: h }, d) => {
+      if (!Array.isArray(l)) throw new n(`expected array but got ${l}`, d);
+      return p(l.length, h, "array length", d, !I(c.meta.default)), [l.map((m, v) => g(l, v, c, d))];
+    }), s.extend("dict", (l, { inner: c, sKey: h }, d, m) => {
+      if (!le(l)) throw new n(`expected object but got ${l}`, d);
+      const v = {};
+      for (const x in l) {
+        let A;
+        try {
+          A = s.resolve(x, h, d)[0];
+        } catch (ke) {
+          if (m) continue;
+          throw ke;
+        }
+        v[A] = g(l, x, c, d), l[A] = l[x], x !== A && delete l[x];
+      }
+      return [v];
+    }), s.extend("tuple", (l, { list: c }, h, d) => {
+      if (!Array.isArray(l)) throw new n(`expected array but got ${l}`, h);
+      const m = c.map((v, x) => g(l, x, v, h));
+      return d ? [m] : (m.push(...l.slice(c.length)), [m]);
+    });
+    function w(l, c) {
+      for (const h in c)
+        h in l || (l[h] = c[h]);
+    }
+    E(w, "merge"), s.extend("object", (l, { dict: c }, h, d) => {
+      if (!le(l)) throw new n(`expected object but got ${l}`, h);
+      const m = {};
+      for (const v in c) {
+        const x = g(l, v, c[v], h);
+        (!I(x) || v in l) && (m[v] = x);
+      }
+      return d || w(m, l), [m];
+    }), s.extend("union", (l, { list: c, toString: h }, d, m) => {
+      for (const v of c)
+        try {
+          return s.resolve(l, v, d, m);
+        } catch {
+        }
+      throw new n(`expected ${h()} but got ${JSON.stringify(l)}`, d);
+    }), s.extend("intersect", (l, { list: c, toString: h }, d, m) => {
+      if (!c.length) return [l];
+      let v;
+      for (const x of c) {
+        const A = s.resolve(l, x, d, !0)[0];
+        if (!I(A))
+          if (I(v))
+            v = A;
+          else {
+            if (typeof v != typeof A)
+              throw new n(`expected ${h()} but got ${JSON.stringify(l)}`, d);
+            if (typeof A == "object")
+              w(v ??= {}, A);
+            else if (v !== A)
+              throw new n(`expected ${h()} but got ${JSON.stringify(l)}`, d);
+          }
+      }
+      return !m && le(l) && w(v, l), [v];
+    }), s.extend("transform", (l, { inner: c, callback: h, preserve: d }, m) => {
+      const [v, x = l] = s.resolve(l, c, m, !0);
+      return d ? [h(v)] : [h(v), h(x)];
+    });
+    var O = {};
+    function C(l, c, h) {
+      O[l] = h, Object.assign(s, {
+        [l](...d) {
+          const m = new s({ type: l });
+          return c.forEach((v, x) => {
+            switch (v) {
+              case "sKey":
+                m.sKey = d[x] ?? s.string();
+                break;
+              case "inner":
+                m.inner = s.from(d[x]);
+                break;
+              case "list":
+                m.list = d[x].map(s.from);
+                break;
+              case "dict":
+                m.dict = q(d[x], s.from);
+                break;
+              case "bits": {
+                m.bits = {};
+                for (const A in d[x])
+                  typeof d[x][A] == "number" && (m.bits[A] = d[x][A]);
+                break;
+              }
+              case "callback": {
+                const A = m.callback = d[x];
+                A.toJSON ||= () => A.toString();
+                break;
+              }
+              case "constructor": {
+                const A = m.constructor = d[x];
+                typeof A == "function" && (A.toJSON ||= () => A.name);
+                break;
+              }
+              default:
+                m[v] = d[x];
+            }
+          }), l === "object" || l === "dict" ? m.meta.default = {} : l === "array" || l === "tuple" ? m.meta.default = [] : l === "bitset" && (m.meta.default = 0), m;
+        }
+      });
+    }
+    E(C, "defineMethod"), C("is", ["constructor"], ({ constructor: l }) => typeof l == "function" ? l.name : l), C("any", [], () => "any"), C("never", [], () => "never"), C("const", ["value"], ({ value: l }) => typeof l == "string" ? JSON.stringify(l) : l), C("string", [], () => "string"), C("number", [], () => "number"), C("boolean", [], () => "boolean"), C("bitset", ["bits"], () => "bitset"), C("function", [], () => "function"), C("array", ["inner"], ({ inner: l }) => `${l.toString(!0)}[]`), C("dict", ["inner", "sKey"], ({ inner: l, sKey: c }) => `{ [key: ${c.toString()}]: ${l.toString()} }`), C("tuple", ["list"], ({ list: l }) => `[${l.map((c) => c.toString()).join(", ")}]`), C("object", ["dict"], ({ dict: l }) => Object.keys(l).length === 0 ? "{}" : `{ ${Object.entries(l).map(([c, h]) => `${c}${h.meta.required ? "" : "?"}: ${h.toString()}`).join(", ")} }`), C("union", ["list"], ({ list: l }, c) => {
+      const h = l.map(({ toString: d }) => d()).join(" | ");
+      return c ? `(${h})` : h;
+    }), C("intersect", ["list"], ({ list: l }) => `${l.map((c) => c.toString(!0)).join(" & ")}`), C("transform", ["inner", "callback", "preserve"], ({ inner: l }, c) => l.toString(c)), e.exports = s;
+  }
+});
+const $ = ir();
+var Ot = /* @__PURE__ */ ((i) => (i[i.debug = -1] = "debug", i[i.log = 0] = "log", i[i.info = 1] = "info", i[i.warn = 2] = "warn", i[i.error = 3] = "error", i[i.silent = 4] = "silent", i))(Ot || {});
+const Ie = globalThis || window, Le = /* @__PURE__ */ Symbol.for("__IPE_LOGGER_COLOR_MAP__");
+Ie[Le] || (Ie[Le] = /* @__PURE__ */ new Map());
+const Se = Ie[Le];
+function oe(i) {
+  let e = 2166136261;
+  for (let t = 0; t < i.length; t++)
+    e ^= i.charCodeAt(t), e = (e >>> 0) * 16777619;
+  return e >>> 0;
+}
+const lt = [
+  [350, 360],
+  [0, 15],
+  [15, 30],
+  [200, 230],
+  [230, 250],
+  [250, 280],
+  [280, 310],
+  [310, 330],
+  [140, 160],
+  [160, 180]
+];
+function rr(i, e) {
+  const t = lt.length, r = oe(i) % t, [n, s] = lt[r], o = s - n, a = oe(i + ":" + e), f = n + a % (o || 1), u = oe(i + ":s"), p = oe(i + ":l");
+  let y, _;
+  if (e === "name")
+    y = 62 + u % 18, _ = 30 + p % 12;
+  else {
+    const g = f >= 0 && f < 50 || f > 330 && f < 360, w = f >= 200 && f <= 300;
+    y = 55 + u % 20, w ? _ = 55 + p % 8 : g ? _ = 48 + p % 6 : _ = 50 + p % 8, y < 60 && (y += 5);
+  }
+  return `hsl(${f}, ${y}%, ${_}%)`;
+}
+function ae(i, e) {
+  if (e)
+    return Se.set(i, e), e;
+  const t = Se.get(i);
+  if (t) return t;
+  const r = i.startsWith("name:") ? "name" : "group", n = rr(i, r);
+  return Se.set(i, n), n;
+}
+class ze {
+  /**
+   * Note: constructor returns a callable Proxy so that you can do `logger('group')`.
+   */
+  constructor(e = {}) {
+    this._custom = (t) => {
+      if (!this._enabled(t.level)) return ht;
+      const [r, n] = this._prefix(t.label);
+      return this._consoleMethod(t.method).bind(console, r, ...n);
+    }, this._name = e.name, this._nameColor = e.color, this._groupPath = e._groupPath ? [...e._groupPath] : [], this._dynamicLevels = { ...e._dynamicLevels }, this._levelRef = e._levelRef ?? {
+      value: e.level ?? 1
+      /* info */
+    }, this._name && ae(`name:${this._name}`, this._nameColor), this._installBuiltinLevels();
+    for (const t of Object.keys(this._dynamicLevels))
+      this._installLevelGetter(t, this._dynamicLevels[t]);
+    return sr(this);
+  }
+  // ---------- public API ----------
+  get level() {
+    return this._levelRef.value;
+  }
+  set level(e) {
+    this._levelRef.value = e;
+  }
+  /** Create a sub-logger with a group label */
+  group(e, t) {
+    return e && ae(`group:${e}`, t?.color), new ze({
+      name: this._name,
+      color: this._nameColor,
+      _groupPath: [...this._groupPath, e],
+      _dynamicLevels: this._dynamicLevels,
+      _levelRef: this._levelRef
+    });
+  }
+  /** Define a custom level, e.g. logger.defineLevel('success', { level: info, label: '✅', method: 'info' }) */
+  defineLevel(e, t) {
+    this._dynamicLevels[e] = { ...t }, this._installLevelGetter(e, t);
+  }
+  // Built-in level getters
+  get debug() {
+    return this._method("debug");
+  }
+  get log() {
+    return this._method("log");
+  }
+  get info() {
+    return this._method("info");
+  }
+  get warn() {
+    return this._method("warn");
+  }
+  get error() {
+    return this._method("error");
+  }
+  // ---------- internals ----------
+  _installBuiltinLevels() {
+  }
+  _installLevelGetter(e, t) {
+    Object.defineProperty(this, e, {
+      configurable: !0,
+      enumerable: !1,
+      get: () => this._custom(t)
+    });
+  }
+  _method(e) {
+    const t = nr[e];
+    if (!this._enabled(t.level)) return ht;
+    const [r, n] = this._prefix(t.label);
+    return this._consoleMethod(e).bind(console, r, ...n);
+  }
+  _consoleMethod(e) {
+    return (console[e] || console.log).bind(console);
+  }
+  _enabled(e) {
+    return e >= this._levelRef.value && this._levelRef.value !== 4;
+  }
+  _prefix(e) {
+    const t = [];
+    let r = "";
+    if (this._name) {
+      const n = ae(`name:${this._name}`, this._nameColor);
+      r += `%c${this._name}%c`, t.push(
+        `background:${n}; color:#fff; padding:1px 4px; border-radius:2px; font-weight:700;`,
+        ut
+      );
+    }
+    if (e && (r += ` ${e}`), this._groupPath.length) {
+      const n = this._groupPath.join("/"), s = ae(`group:${n}`);
+      r += ` %c${n}%c`, t.push(`color:${s}; text-decoration: underline;`, ut);
+    }
+    return [r, t];
+  }
+}
+const ht = () => {
+}, ut = "color:inherit; background:transparent; text-decoration:none;", nr = {
+  debug: { level: -1, label: "", method: "debug" },
+  log: { level: 0, label: "", method: "log" },
+  info: { level: 1, label: "[I]", method: "info" },
+  warn: { level: 2, label: "[W]", method: "warn" },
+  error: { level: 3, label: "[E]", method: "error" }
+};
+function sr(i) {
+  const e = function(t, r) {
+    return i.group(t, r);
+  };
+  return new Proxy(e, {
+    get(t, r, n) {
+      return i[r];
+    },
+    set(t, r, n) {
+      return i[r] = n, !0;
+    },
+    apply(t, r, n) {
+      return i.group(n[0], n[1]);
+    },
+    has(t, r) {
+      return r in i;
+    }
+  });
+}
+function or(i) {
+  return new ze(i);
+}
+class Re extends wi {
+  async clientLogin(e, t, r) {
+    r ||= {}, !r.logincontinue && !r.loginreturnurl && (r.loginreturnurl = location?.origin);
+    const n = await this.postWithToken(
+      "login",
+      {
+        action: "clientlogin",
+        username: e,
+        password: t,
+        ...r
+      },
+      {
+        tokenName: "logintoken"
+      }
+    );
+    if (n?.data?.clientlogin?.status === "PASS")
+      return n.data.clientlogin;
+    throw new bi(
+      vi.LOGIN_FAILED,
+      n.data.clientlogin.message,
+      n
+    );
+  }
+}
+class ar extends Re {
+  constructor(e, t, r) {
+    const n = _i(
+      e,
+      {
+        credentials: "include",
+        mode: "cors",
+        ...t
+      },
+      {
+        origin: location.origin,
+        ...r
+      }
+    );
+    super(n);
+  }
+}
+class cr {
+  constructor(e, t = {}) {
+    this.ctx = e, this.options = t, this._apiClients = /* @__PURE__ */ new Map(), location?.href && t?.baseURL?.toString()?.startsWith("/") && (t.baseURL = new URL(t.baseURL, location.origin));
+    const r = this.api = new Re({
+      baseURL: t.baseURL.toString(),
+      fexiosConfigs: {
+        headers: {
+          "x-api-user-agent": `InPageEdit-NEXT ${e.version}`,
+          ...t.headers
+        },
+        ...t
+      },
+      throwOnApiError: !0
+    });
+    e.set("api", r), e.set("apiService", this);
+  }
+  getClientByFileRepo(e) {
+    const t = new URL(`${e.scriptDirUrl}/api.php`, location.origin), r = t.toString();
+    if (r === this.ctx.root.config.apiConfigs.baseURL?.toString())
+      return this.ctx.api;
+    if (!this._apiClients.has(r)) {
+      const n = t.origin === location.origin, s = {
+        baseURL: t.toString(),
+        throwOnApiError: !0
+      }, o = n ? new Re(s) : new ar(s);
+      o.request.on("beforeRequest", (a) => {
+        a.headers = o.request.mergeHeaders(a.headers, {
+          "x-api-user-agent": null,
+          "x-mw-token-name": null
+        });
+      }), this._apiClients.set(r, o);
+    }
+    return this._apiClients.get(r);
+  }
+}
+const ft = (i, e = document) => e.querySelector(i), ps = (i, e = document) => e.querySelectorAll(i);
+var lr = Object.create, Ke = Object.defineProperty, hr = Object.getOwnPropertyDescriptor, Pt = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), It = (i) => {
+  throw TypeError(i);
+}, ur = (i, e, t) => e in i ? Ke(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, fr = (i, e) => Ke(i, "name", { value: e, configurable: !0 }), dr = (i) => [, , , lr(i?.[Pt("metadata")] ?? null)], pr = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], Lt = (i) => i !== void 0 && typeof i != "function" ? It("Function expected") : i, gr = (i, e, t, r, n) => ({ kind: pr[i], name: e, metadata: r, addInitializer: (s) => t._ ? It("Already initialized") : n.push(Lt(s || null)) }), mr = (i, e) => ur(e, Pt("metadata"), i[3]), yr = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, wr = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && hr(n, t));
+  fr(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = gr(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, Lt(o) && (n = o);
+  return mr(i, n), g && Ke(n, t, g), p ? u ^ 4 ? s : g : n;
+}, Rt, qe, jt;
+Rt = [F(["wiki", "wikiTitle"])];
+class fe extends (jt = z) {
+  constructor(e) {
+    super(e, "currentPage", !1), this.ctx = e, this.url = new URL(window.location.href), this.isMainPage = void 0, this.wikiTitle = void 0;
+  }
+  get logger() {
+    return this.ctx.logger("CURRENT_PAGE");
+  }
+  async start() {
+    await this.#e(), this.#i(), window.addEventListener("popstate", this.#t.bind(this)), this.logger.info("initialized", this.wikiTitle);
+  }
+  stop() {
+    window.removeEventListener("popstate", this.#t.bind(this));
+  }
+  async #e() {
+    await this.#n(), await this.#r();
+  }
+  #i() {
+    const e = /* @__PURE__ */ Symbol.for("InPageEdit.CurrentPageService.UrlChangeListenerInstalled");
+    if (window[e])
+      return;
+    const t = history.pushState, r = history.replaceState;
+    history.pushState = function(n, s, o) {
+      t.apply(this, [n, s, o]), window.dispatchEvent(new PopStateEvent("popstate", { state: n }));
+    }, history.replaceState = function(n, s, o) {
+      r.apply(this, [n, s, o]), window.dispatchEvent(new PopStateEvent("popstate", { state: n }));
+    }, window[e] = !0;
+  }
+  async #t(e) {
+    const t = this.url, r = new URL(window.location.href);
+    this.url = r, (t.pathname !== r.pathname || t.searchParams.get("title") !== r.searchParams.get("title") || t.searchParams.get("curid") !== r.searchParams.get("curid")) && (await this.#e(), this.logger.info("location changed", r, this.wikiTitle));
+  }
+  get params() {
+    return this.url.searchParams;
+  }
+  get canonicalUrl() {
+    const e = (ft('link[rel="alternate"][hreflang="x-default"]') || ft('link[rel="canonical"]'))?.href;
+    let t = null;
+    return e && (t = new URL(e, location.origin)), Reflect.defineProperty(this, "canonicalUrl", {
+      get: () => t
+    }), t;
+  }
+  async #r() {
+    const t = this.wikiTitle?.getMainDBKey() === this.ctx.wiki.mainPageName;
+    return Reflect.defineProperty(this, "isMainPage", {
+      get: () => t
+    }), t;
+  }
+  async #n() {
+    let e = null;
+    return this.canonicalUrl ? e = await this.ctx.wikiTitle.newTitleFromUrl(this.canonicalUrl) : e = await this.ctx.wikiTitle.newTitleFromUrl(this.url), Object.freeze(e), Reflect.defineProperty(this, "wikiTitle", {
+      get: () => e
+    }), e;
+  }
+  get wikiAction() {
+    return this.params.get("action") || "view";
+  }
+}
+qe = dr(jt);
+fe = wr(qe, 0, "CurrentPageService", Rt, fe);
+yr(qe, 1, fe);
+class br extends z {
+  constructor(e) {
+    super(e, "resourceLoader", !0), this.ctx = e;
+  }
+  stop() {
+    this.removeAll();
+  }
+  loadScript(e, t) {
+    if (!e)
+      return Promise.resolve(null);
+    const r = `script:${e}`, n = document.querySelector(`[data-ipe="${r}"]`);
+    return n ? Promise.resolve(n) : new Promise((o, a) => {
+      const f = document.createElement("script");
+      f.src = e, f.dataset.ipe = r, t && Object.entries(t).forEach(([u, p]) => {
+        typeof p > "u" || p === !1 || p === null ? f.removeAttribute(u) : f.setAttribute(u, p);
+      }), document.body.appendChild(f), f.onload = () => o(f), f.onerror = (u) => a(u);
+    });
+  }
+  loadStyle(e, t) {
+    if (!e)
+      return Promise.resolve(null);
+    const r = `style:${e}`, n = document.querySelector(`[data-ipe="${r}"]`);
+    return n ? Promise.resolve(n) : new Promise((o, a) => {
+      const f = document.createElement("link");
+      f.rel = "stylesheet", f.href = e, f.dataset.ipe = r, t && Object.entries(t).forEach(([p, y]) => {
+        typeof y > "u" || y === !1 || y === null ? f.removeAttribute(p) : f.setAttribute(p, y);
+      }), (document.querySelector('meta[name="ipe-styles"]') || (() => {
+        const p = document.createElement("meta");
+        return p.id = "ipe-styles", p.name = "ipe-styles", document.head.insertAdjacentElement("afterbegin", p), p;
+      })()).before(f), f.onload = () => o(f), f.onerror = (p) => a(p);
+    });
+  }
+  removeStyle(e) {
+    const t = `style:${e}`, r = document.querySelector(`[data-ipe="${t}"]`);
+    r && r.remove();
+  }
+  removeScript(e) {
+    const t = `script:${e}`, r = document.querySelector(`[data-ipe="${t}"]`);
+    r && r.remove();
+  }
+  removeAll() {
+    document.querySelectorAll("[data-ipe]").forEach((e) => {
+      e.remove();
+    });
+  }
+  resolveImportPath(e) {
+    return e.startsWith("http") || e.startsWith("//") ? e : import.meta.resolve(e);
+  }
+}
+const _e = Object.keys;
+function vr(i) {
+  return typeof i == "boolean";
+}
+function _r(i) {
+  return i && typeof i.nodeType == "number";
+}
+function He(i) {
+  return typeof i == "string";
+}
+function Dt(i) {
+  return typeof i == "number";
+}
+function Y(i) {
+  return typeof i == "object" ? i !== null : re(i);
+}
+function re(i) {
+  return typeof i == "function";
+}
+function xr(i) {
+  return !!(i && i.isComponent);
+}
+function kr(i) {
+  return Y(i) && typeof i.length == "number" && typeof i.nodeType != "number";
+}
+function je(i, e) {
+  if (i)
+    for (const t of _e(i))
+      e(i[t], t);
+}
+function Sr(i) {
+  return Y(i) && "current" in i;
+}
+const De = {
+  animationIterationCount: 0,
+  borderImageOutset: 0,
+  borderImageSlice: 0,
+  borderImageWidth: 0,
+  boxFlex: 0,
+  boxFlexGroup: 0,
+  boxOrdinalGroup: 0,
+  columnCount: 0,
+  columns: 0,
+  flex: 0,
+  flexGrow: 0,
+  flexPositive: 0,
+  flexShrink: 0,
+  flexNegative: 0,
+  flexOrder: 0,
+  gridArea: 0,
+  gridRow: 0,
+  gridRowEnd: 0,
+  gridRowSpan: 0,
+  gridRowStart: 0,
+  gridColumn: 0,
+  gridColumnEnd: 0,
+  gridColumnSpan: 0,
+  gridColumnStart: 0,
+  fontWeight: 0,
+  lineClamp: 0,
+  lineHeight: 0,
+  opacity: 0,
+  order: 0,
+  orphans: 0,
+  tabSize: 0,
+  widows: 0,
+  zIndex: 0,
+  zoom: 0,
+  // SVG-related properties
+  fillOpacity: 0,
+  floodOpacity: 0,
+  stopOpacity: 0,
+  strokeDasharray: 0,
+  strokeDashoffset: 0,
+  strokeMiterlimit: 0,
+  strokeOpacity: 0,
+  strokeWidth: 0
+};
+function $r(i, e) {
+  return i + e.charAt(0).toUpperCase() + e.substring(1);
+}
+const Er = ["Webkit", "ms", "Moz", "O"];
+_e(De).forEach((i) => {
+  Er.forEach((e) => {
+    De[$r(e, i)] = 0;
+  });
+});
+const Cr = /* @__PURE__ */ Symbol.for("jsx-dom:type");
+var Tt = /* @__PURE__ */ (function(i) {
+  return i.ShadowRoot = "ShadowRoot", i;
+})(Tt || {});
+function Ar(i) {
+  return i != null && i[Cr] === Tt.ShadowRoot;
+}
+const Or = "http://www.w3.org/2000/svg", Pr = "http://www.w3.org/1999/xlink", Ir = "http://www.w3.org/XML/1998/namespace";
+function Mt(i) {
+  return !vr(i) && i != null;
+}
+function Te(i) {
+  return Array.isArray(i) ? i.map(Te).filter(Boolean).join(" ") : Y(i) ? Symbol.iterator in i ? Te(Array.from(i)) : _e(i).filter((e) => i[e]).join(" ") : Mt(i) ? "" + i : "";
+}
+const Lr = {
+  animate: 0,
+  circle: 0,
+  clipPath: 0,
+  defs: 0,
+  desc: 0,
+  ellipse: 0,
+  feBlend: 0,
+  feColorMatrix: 0,
+  feComponentTransfer: 0,
+  feComposite: 0,
+  feConvolveMatrix: 0,
+  feDiffuseLighting: 0,
+  feDisplacementMap: 0,
+  feDistantLight: 0,
+  feFlood: 0,
+  feFuncA: 0,
+  feFuncB: 0,
+  feFuncG: 0,
+  feFuncR: 0,
+  feGaussianBlur: 0,
+  feImage: 0,
+  feMerge: 0,
+  feMergeNode: 0,
+  feMorphology: 0,
+  feOffset: 0,
+  fePointLight: 0,
+  feSpecularLighting: 0,
+  feSpotLight: 0,
+  feTile: 0,
+  feTurbulence: 0,
+  filter: 0,
+  foreignObject: 0,
+  g: 0,
+  image: 0,
+  line: 0,
+  linearGradient: 0,
+  marker: 0,
+  mask: 0,
+  metadata: 0,
+  path: 0,
+  pattern: 0,
+  polygon: 0,
+  polyline: 0,
+  radialGradient: 0,
+  rect: 0,
+  stop: 0,
+  svg: 0,
+  switch: 0,
+  symbol: 0,
+  text: 0,
+  textPath: 0,
+  tspan: 0,
+  use: 0,
+  view: 0
+}, Rr = /^(a(ll|t|u)|base[FP]|c(al|lipPathU|on)|di|ed|ex|filter[RU]|g(lyphR|r)|ke|l(en|im)|ma(rker[HUW]|s)|n|pat|pr|point[^e]|re[^n]|s[puy]|st[^or]|ta|textL|vi|xC|y|z)/;
+function jr(i) {
+  const e = document.createDocumentFragment();
+  return xe(i.children, e), e;
+}
+function Dr(i, e, t) {
+  e = {
+    ...e,
+    children: t
+  };
+  const r = new i(e), n = r.render();
+  return "ref" in e && We(e.ref, r), n;
+}
+function P(i, e) {
+  let { children: t, ...r } = e;
+  !r.namespaceURI && Lr[i] === 0 && (r = {
+    ...r,
+    namespaceURI: Or
+  });
+  let n;
+  if (He(i)) {
+    if (n = r.namespaceURI ? document.createElementNS(r.namespaceURI, i) : document.createElement(i), Nr(r, n), xe(t, n), n instanceof window.HTMLSelectElement && r.value != null)
+      if (r.multiple === !0 && Array.isArray(r.value)) {
+        const s = r.value.map((o) => String(o));
+        n.querySelectorAll("option").forEach(
+          (o) => o.selected = s.includes(o.value)
+        );
+      } else
+        n.value = r.value;
+    We(r.ref, n);
+  } else if (re(i))
+    Y(i.defaultProps) && (r = {
+      ...i.defaultProps,
+      ...r
+    }), n = xr(i) ? Dr(i, r, t) : i({
+      ...r,
+      children: t
+    });
+  else
+    throw new TypeError(`Invalid JSX element type: ${i}`);
+  return n;
+}
+function We(i, e) {
+  Sr(i) ? i.current = e : re(i) && i(e);
+}
+function xe(i, e) {
+  if (kr(i))
+    Tr(i, e);
+  else if (He(i) || Dt(i))
+    $e(document.createTextNode(i), e);
+  else if (i === null)
+    $e(document.createComment(""), e);
+  else if (_r(i))
+    $e(i, e);
+  else if (Ar(i)) {
+    const t = e.attachShadow(i.attr);
+    xe(i.children, t), We(i.ref, t);
+  }
+}
+function Tr(i, e) {
+  for (const t of [...i])
+    xe(t, e);
+  return e;
+}
+function $e(i, e) {
+  e instanceof window.HTMLTemplateElement ? e.content.appendChild(i) : e.appendChild(i);
+}
+function ce(i, e) {
+  return i.replace(/[A-Z]/g, (t) => e + t.toLowerCase());
+}
+function Nt(i, e) {
+  e == null || e === !1 || (Array.isArray(e) ? e.forEach((t) => Nt(i, t)) : He(e) ? i.setAttribute("style", e) : Y(e) && je(e, (t, r) => {
+    r.indexOf("-") === 0 ? i.style.setProperty(r, t) : Dt(t) && De[r] !== 0 ? i.style[r] = t + "px" : i.style[r] = t;
+  }));
+}
+function Mr(i, e, t) {
+  switch (i) {
+    case "xlinkActuate":
+    case "xlinkArcrole":
+    case "xlinkHref":
+    case "xlinkRole":
+    case "xlinkShow":
+    case "xlinkTitle":
+    case "xlinkType":
+      dt(t, Pr, ce(i, ":"), e);
+      return;
+    case "xmlnsXlink":
+      X(t, ce(i, ":"), e);
+      return;
+    case "xmlBase":
+    case "xmlLang":
+    case "xmlSpace":
+      dt(t, Ir, ce(i, ":"), e);
+      return;
+  }
+  switch (i) {
+    case "htmlFor":
+      X(t, "for", e);
+      return;
+    case "dataset":
+      je(e, (r, n) => {
+        r != null && (t.dataset[n] = r);
+      });
+      return;
+    case "innerHTML":
+    case "innerText":
+    case "textContent":
+      Mt(e) && (t[i] = e);
+      return;
+    case "dangerouslySetInnerHTML":
+      Y(e) && (t.innerHTML = e.__html);
+      return;
+    case "value":
+      if (e == null || t instanceof window.HTMLSelectElement)
+        return;
+      if (t instanceof window.HTMLTextAreaElement) {
+        t.value = e;
+        return;
+      }
+      break;
+    case "spellCheck":
+      t.spellcheck = e;
+      return;
+    case "class":
+    case "className":
+      re(e) ? e(t) : X(t, "class", Te(e));
+      return;
+    case "ref":
+    case "namespaceURI":
+      return;
+    case "style":
+      Nt(t, e);
+      return;
+    case "on":
+    case "onCapture":
+      je(e, (r, n) => {
+        t.addEventListener(n, r, i === "onCapture");
+      });
+      return;
+  }
+  if (re(e)) {
+    if (i[0] === "o" && i[1] === "n") {
+      let r = i.toLowerCase();
+      const n = r.endsWith("capture");
+      if (r === "ondoubleclick" ? r = "ondblclick" : n && r === "ondoubleclickcapture" && (r = "ondblclickcapture"), !n && t[r] === null)
+        t[r] = e;
+      else if (n)
+        t.addEventListener(
+          r.substring(2, r.length - 7),
+          e,
+          !0
+        );
+      else {
+        let s;
+        r in window ? s = r.substring(2) : s = r[2] + i.slice(3), t.addEventListener(s, e);
+      }
+    }
+  } else Y(e) ? t[i] = e : e === !0 ? X(t, i, "") : e !== !1 && e != null && (t instanceof SVGElement && !Rr.test(i) ? X(t, ce(i, "-"), e) : X(t, i, e));
+}
+function X(i, e, t) {
+  i.setAttribute(e, t);
+}
+function dt(i, e, t, r) {
+  i.setAttributeNS(e, t, r);
+}
+function Nr(i, e) {
+  for (const t of _e(i))
+    Mr(t, i[t], e);
+  return e;
+}
+var Ge = /* @__PURE__ */ ((i) => (i.Init = "modal.init", i.BeforeShow = "modal.beforeShow", i.Show = "modal.show", i.BeforeClose = "modal.beforeClose", i.Close = "modal.close", i.Destroy = "modal.destroy", i.ToastShow = "toast.show", i.ToastClose = "toast.close", i))(Ge || {});
+let Br = 0;
+const pt = (i) => `${i}-${++Br}`;
+function Z(i) {
+  return i instanceof Node ? i : document.createTextNode(String(i));
+}
+function K(i, e) {
+  if (!i) throw new Error(`${e ?? "Element"} not found`);
+  return i;
+}
+function gt(i) {
+  const e = [
+    "a[href]",
+    "button:not([disabled])",
+    "input:not([disabled])",
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+    '[tabindex]:not([tabindex="-1"])'
+  ].join(",");
+  return Array.from(i.querySelectorAll(e)).filter(
+    (t) => !!(t.offsetWidth || t.offsetHeight || t.getClientRects().length)
+  );
+}
+function D(i, e = {}) {
+  const t = document.createElement(i);
+  if (e.className && (t.className = e.className), e.html != null && (t.innerHTML = e.html), e.text != null && (t.textContent = e.text), e.attrs)
+    for (const [r, n] of Object.entries(e.attrs)) t.setAttribute(r, n);
+  return t;
+}
+const Ur = typeof navigator < "u" && /Mac|iPhone|iPad|iPod/i.test(navigator.platform), Bt = ["ctrl", "alt", "shift", "meta"];
+function Fr(i) {
+  if (!i) return null;
+  const e = String(i).trim().toLowerCase().split(/[+\-\s]+/g).filter(Boolean), t = [];
+  let r = null;
+  const n = (o) => {
+    t.includes(o) || t.push(o);
+  };
+  for (const o of e) {
+    let a = o;
+    if (a === "control" || a === "ctrl") {
+      n("ctrl");
+      continue;
+    }
+    if (a === "alt" || a === "option") {
+      n("alt");
+      continue;
+    }
+    if (a === "shift") {
+      n("shift");
+      continue;
+    }
+    if (a === "meta" || a === "cmd" || a === "command" || a === "super") {
+      n("meta");
+      continue;
+    }
+    if (a === "mod") {
+      n(Ur ? "meta" : "ctrl");
+      continue;
+    }
+    a === "esc" && (a = "escape"), a === "return" && (a = "enter"), (a === "space" || a === "spacebar") && (a = "space"), r = a;
+  }
+  const s = Bt.filter((o) => t.includes(o));
+  return !r || r === "" ? s.length ? s.join("+") : null : s.length ? `${s.join("+")}+${r}` : r;
+}
+function zr(i) {
+  const e = [];
+  i.ctrlKey && e.push("ctrl"), i.altKey && e.push("alt"), i.shiftKey && e.push("shift"), i.metaKey && e.push("meta");
+  let t = i.key;
+  t === " " && (t = "space");
+  const r = (t.length, t.toLowerCase()), n = Bt.filter((s) => e.includes(s));
+  return n.length ? `${n.join("+")}+${r}` : r;
+}
+class Kr {
+  constructor() {
+    this.zBase = 1e3, this.stack = [];
+  }
+  push(e) {
+    this.stack.push(e), this.syncZ();
+  }
+  remove(e) {
+    this.stack = this.stack.filter((t) => t !== e), this.syncZ();
+  }
+  top() {
+    return this.stack[this.stack.length - 1];
+  }
+  closeAll(e, t) {
+    const r = new Set((Array.isArray(t) ? t : t ? [t] : []).map(String)), n = new Set((Array.isArray(e) ? e : e ? [e] : []).map(String));
+    [...this.stack].reverse().forEach((s) => {
+      const o = s.modalId, a = n.size ? n.has(s.pluginName) : !0, f = r.has(o);
+      a && !f && s.close();
+    });
+  }
+  removeAll() {
+    [...this.stack].forEach((e) => e.destroy()), this.stack = [];
+  }
+  syncZ() {
+    this.stack.forEach((e, t) => e.setZIndex(this.zBase + t * 2));
+  }
+  lockBodyScroll() {
+    document.body.classList.add("ipe-modal-no-scroll");
+  }
+  unlockBodyScroll() {
+    document.body.classList.remove("ipe-modal-no-scroll");
+  }
+}
+const T = new Kr();
+class de {
+  constructor(e = {}) {
+    this.backdropId = pt("ipe-modal-backdrop"), this.modalId = pt("ipe-modal"), this.numberId = this.modalId.split("-")[1], this._isDestroyed = !1, this.pluginName = "normalModal", this.buttonElsLeft = [], this.buttonElsRight = [], this.keyMap = /* @__PURE__ */ new Map(), this.isOpen = !1, this.isToast = !1, this.isDragging = !1, this.dragStartX = 0, this.dragStartY = 0, this.modalStartX = 0, this.modalStartY = 0, this.Event = Ge, this._hooks = [], this.startCloseTimer = (t) => {
+      this.stopCloseTimer(), this.closeTimer = window.setTimeout(() => this.close(), t);
+    }, this.stopCloseTimer = () => {
+      this.closeTimer && window.clearTimeout(this.closeTimer), this.closeTimer = void 0;
+    }, this.onDragMove = (t) => {
+      if (!this.isDragging) return;
+      t.preventDefault();
+      const r = t.clientX - this.dragStartX, n = t.clientY - this.dragStartY, s = this.get$modal(), o = this.modalStartX + r, a = this.modalStartY + n;
+      s.style.left = `${o}px`, s.style.top = `${a}px`;
+    }, this.onDragEnd = () => {
+      if (!this.isDragging) return;
+      this.isDragging = !1, document.removeEventListener("pointermove", this.onDragMove), document.removeEventListener("pointerup", this.onDragEnd);
+      const t = this.get$modal(), r = this.get$window();
+      t.classList.remove("is-dragging"), r.style.animation = "none", requestAnimationFrame(() => {
+        this.applyAnimation(!0);
+      });
+    }, this.options = { ...de.DEFAULT_OPTIONS, ...e }, this.options.backdrop === !1 && e.bodyScroll === void 0 && (this.options.bodyScroll = !0);
+  }
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
+  static {
+    this.DEFAULT_OPTIONS = {
+      className: "",
+      sizeClass: "auto",
+      center: !0,
+      fitScreen: !1,
+      closeIcon: !0,
+      bodyScroll: !1,
+      outSideClose: !0,
+      backdrop: !0,
+      animation: {
+        show: "ipe-modal-fade-in",
+        hide: "ipe-modal-fade-out"
+      },
+      animationSpeed: 200
+    };
+  }
+  static extends(e = {}) {
+    return class extends this {
+      constructor(t = {}) {
+        super({ ...e, ...t });
+      }
+    };
+  }
+  // ------------------------------ lifecycle ------------------------------ //
+  init() {
+    if (this.$modal) return this;
+    const e = this.options.backdrop !== !1;
+    let t;
+    e && (t = D("div", {
+      className: "ipe-modal-backdrop",
+      attrs: { id: this.backdropId, "data-modal-id": this.modalId }
+    }));
+    const r = D("div", {
+      className: "ipe-modal-modal",
+      attrs: { id: this.modalId, role: "dialog", "aria-modal": "true", tabindex: "-1" }
+    });
+    if (r.modal = this, !e) {
+      r.classList.add("no-backdrop");
+      const g = window.pageYOffset || document.documentElement.scrollTop, w = window.pageXOffset || document.documentElement.scrollLeft, O = window.innerWidth;
+      r.style.top = `${g + 60}px`, this.once("modal.show", () => {
+        r.style.left = `${w + O / 2 - r.offsetWidth / 2}px`;
+      });
+    }
+    const n = D("div", {
+      className: `ipe-modal-modal__window size--${this.options.sizeClass || "auto"} plugin--${this.pluginName}`
+    });
+    n.modal = this;
+    const s = D("div", { className: "ipe-modal-modal__header" }), o = `${this.modalId}-title`, a = D("h2", {
+      className: "ipe-modal-modal__title",
+      attrs: { id: o, role: "heading", "aria-level": "2" }
+    });
+    r.setAttribute("aria-labelledby", o);
+    const f = D("div", { className: "ipe-modal-modal__icons" });
+    if (this.options.closeIcon) {
+      const g = D("button", {
+        className: "ipe-modal-modal__close",
+        attrs: { type: "button", "aria-label": "Close" },
+        html: "&times;"
+      });
+      g.addEventListener("click", () => {
+        let w = !0;
+        typeof this.options.onClickClose == "function" ? this.options.onClickClose(this) === !1 && (w = !1) : this.options.onClickClose === !1 && (w = !1), w && this.close();
+      }), f.appendChild(g);
+    }
+    s.append(a, f), this.options.draggable && e && (this.options.draggable = !1), this.options.draggable && (s.style.cursor = "move", s.style.userSelect = "none", s.addEventListener("pointerdown", this.onDragStart.bind(this)), r.classList.add("is-draggable"));
+    const u = D("div", { className: "ipe-modal-modal__content" }), p = D("div", { className: "ipe-modal-modal__footer" }), y = D("div", {
+      className: "ipe-modal-modal__buttons ipe-modal-modal__buttons--left"
+    }), _ = D("div", {
+      className: "ipe-modal-modal__buttons ipe-modal-modal__buttons--right"
+    });
+    return p.append(y, _), n.append(s, u, p), r.appendChild(n), this.$backdrop = t, this.$modal = r, this.$window = n, this.$header = s, this.$title = a, this.$icons = f, this.$content = u, this.$footer = p, this.$buttonsLeft = y, this.$buttonsRight = _, this.options.title && this.setTitle(this.options.title), this.options.content && this.setContent(this.options.content), this.options.buttons?.length ? this.setButtons(this.options.buttons) : p.style.display = "none", this.options.center && this.$modal.classList.add("is-centered"), this.options.fitScreen && this.$modal.classList.add("is-fullscreen"), this.options.iconButtons && this.$header.classList.add("has-icon-buttons"), this.options.className && this.$window.classList.add(...this.options.className.split(/[\s\.#+]+/g).filter(Boolean)), typeof this.options.fixedHeight == "number" ? this.$window.style.height = `${Math.max(0, this.options.fixedHeight)}px` : this.options.fixedHeight === !0 && this.$window.classList.add("is-fixed-height"), t && t.addEventListener("pointerdown", (g) => {
+      this.options.outSideClose && g.target === t && this.close();
+    }), this.options.draggable && n.addEventListener("pointerdown", (g) => {
+      g.target && n.contains(g.target) && this.bringToFront();
+    }), this.onKeyDown = this.onKeyDown.bind(this), this.emit(
+      "modal.init"
+      /* Init */
+    ), this;
+  }
+  show() {
+    if (this.$modal || this.init(), !this.$modal) throw new Error("Failed to initialize modal");
+    if (this.isOpen) return this;
+    {
+      const r = this.emit("modal.beforeShow", !0), n = this.options.beforeShow ? this.options.beforeShow(this) !== !1 : !0;
+      if (!r || !n) return this;
+    }
+    this.lastFocused = document.activeElement ?? null, this.$backdrop && document.body.appendChild(this.$backdrop), document.body.appendChild(this.$modal), this.shouldLockBodyOnOpen() && T.lockBodyScroll(), requestAnimationFrame(() => {
+      this.$backdrop?.classList.add("is-open"), this.$modal.classList.add("is-open"), this.applyAnimation(!0), this.focusFirst();
+    }), document.addEventListener("keydown", this.onKeyDown), T.push(this), this.isOpen = !0, this.options.onShow?.(this), this.emit(
+      "modal.show"
+      /* Show */
+    );
+    const e = typeof this.options.closeAfter == "number" ? this.options.closeAfter : this.options.closeAfter?.time, t = typeof this.options.closeAfter == "number" ? !0 : this.options.closeAfter?.resetOnHover;
+    return e && (this.startCloseTimer(e), t && (this.$window?.addEventListener("mouseenter", this.stopCloseTimer), this.$window?.addEventListener("mouseleave", () => this.startCloseTimer(e)))), this;
+  }
+  close() {
+    if (!this.isOpen) return this;
+    {
+      const s = this.emit("modal.beforeClose", !0), o = this.options.beforeClose ? this.options.beforeClose(this) !== !1 : !0;
+      if (!s || !o) return this;
+    }
+    if (this.isToast) {
+      this.applyAnimation(!1), this.emit(
+        "modal.close"
+        /* Close */
+      ), this.emit(
+        "toast.close"
+        /* ToastClose */
+      );
+      const s = this.isAnimationDisabled() ? 0 : this.options.animationSpeed ?? 200;
+      let o = !1;
+      const a = () => {
+        o || (o = !0, this.destroy(), this.options.onClose?.(this));
+      }, f = (u, p) => {
+        const y = () => {
+          u.removeEventListener(p, y), a();
+        };
+        u.addEventListener(p, y, { once: !0 });
+      };
+      return s > 0 && this.$window ? (f(this.$window, "transitionend"), f(this.$window, "animationend"), window.setTimeout(a, s + 20)) : window.setTimeout(a, s), this;
+    }
+    this.applyAnimation(!1), this.$backdrop?.classList.remove("is-open"), this.$modal?.classList.remove("is-open"), this.emit(
+      "modal.close"
+      /* Close */
+    );
+    const e = this.isAnimationDisabled() ? 0 : this.options.animationSpeed ?? 200;
+    let t = !1;
+    const r = () => {
+      t || (t = !0, this.destroy(), this.options.onClose?.(this));
+    }, n = (s, o) => {
+      const a = () => {
+        s.removeEventListener(o, a), r();
+      };
+      s.addEventListener(o, a, { once: !0 });
+    };
+    return e > 0 && this.$window ? (n(this.$window, "transitionend"), n(this.$window, "animationend"), window.setTimeout(r, e + 20)) : window.setTimeout(r, e), this;
+  }
+  /** Immediately removes DOM and listeners */
+  destroy() {
+    if (this._isDestroyed) return this;
+    if (this.stopCloseTimer(), document.removeEventListener("keydown", this.onKeyDown), this.isDragging && this.onDragEnd(), this.$window?.removeEventListener("mouseenter", this.stopCloseTimer), this.isToast) {
+      this.$window?.parentElement && this.$window.parentElement.removeChild(this.$window);
+      const e = V.indexOf(this);
+      e !== -1 && V.splice(e, 1);
+    } else
+      this.$backdrop?.parentElement && this.$backdrop.parentElement.removeChild(this.$backdrop), this.$modal?.parentElement && this.$modal.parentElement.removeChild(this.$modal), T.remove(this), this.shouldUnlockBodyOnClose() && T.unlockBodyScroll();
+    return this.isOpen = !1, this.lastFocused?.focus?.(), this.emit(
+      "modal.destroy"
+      /* Destroy */
+    ), this._isDestroyed = !0, this;
+  }
+  // ------------------------------ getters ------------------------------- //
+  get$backdrop() {
+    return this.$backdrop;
+  }
+  get$modal() {
+    return K(this.$modal, "modal");
+  }
+  get$window() {
+    return K(this.$window, "window");
+  }
+  get$header() {
+    return K(this.$header, "header");
+  }
+  get$title() {
+    return K(this.$title, "title");
+  }
+  get$content() {
+    return K(this.$content, "content");
+  }
+  get$icons() {
+    return K(this.$icons, "icons");
+  }
+  get$buttons(e) {
+    return e === "leftButtons" ? K(this.$buttonsLeft, "leftButtons") : e === "rightButtons" ? K(this.$buttonsRight, "rightButtons") : K(this.$footer, "buttons");
+  }
+  // ------------------------------ content ------------------------------- //
+  setTitle(e) {
+    const t = this.get$title();
+    return t.innerHTML = "", t.append(Z(e)), this;
+  }
+  setContent(e, t = "replace") {
+    const r = this.get$content();
+    return t === "replace" ? (r.innerHTML = "", r.append(Z(e))) : t === "append" ? r.append(Z(e)) : r.prepend(Z(e)), this;
+  }
+  setIcons(e) {
+    const t = this.get$icons();
+    t.innerHTML = "";
+    for (const r of e) {
+      const n = D("button", {
+        className: `ipe-modal-modal__icon ${r.className}`,
+        attrs: { type: "button" }
+      });
+      n.addEventListener("click", r.method), t.appendChild(n);
+    }
+    return this;
+  }
+  setButtons(e, t) {
+    const r = this.$buttonsLeft, n = this.$buttonsRight;
+    [r, n].forEach((o) => o.innerHTML = ""), this.buttonElsLeft = [], this.buttonElsRight = [], this.keyMap.clear();
+    const s = t ?? this.$footer;
+    if (s === this.$footer)
+      e.forEach((o) => this.addButton(o)), e.length === 0 && (this.$footer.style.display = "none");
+    else {
+      s.innerHTML = "";
+      for (const o of e) {
+        const a = this.generateButton(o);
+        s.appendChild(a);
+      }
+    }
+    return this;
+  }
+  generateButton(e) {
+    const t = e.type ?? "button", r = t === "link" ? D("a") : D("button", { attrs: { type: "button" } });
+    e.id && (r.id = e.id), r.className = `ipe-modal-btn ${e.className ?? ""}`.trim();
+    const n = Z(e.label ?? "OK");
+    if (r.append(n), t === "link" && e.href && (r.href = e.href), e.method && r.addEventListener("click", (s) => {
+      if (r._ipe_tmpDisabled) {
+        s.preventDefault(), s.stopPropagation();
+        return;
+      }
+      e.method.call(r, s, this);
+    }), typeof e.closeAfter == "number" && e.closeAfter >= 0 && r.addEventListener("click", () => {
+      window.setTimeout(() => this.close(), e.closeAfter);
+    }), typeof e.enableAfter == "number" && e.enableAfter > 0) {
+      t === "button" && r.setAttribute("disabled", "true"), r._ipe_tmpDisabled = !0, r.setAttribute("aria-disabled", "true");
+      const s = () => {
+        t === "button" && r.removeAttribute("disabled"), delete r._ipe_tmpDisabled, r.removeAttribute("aria-disabled");
+      };
+      window.setTimeout(s, e.enableAfter);
+    }
+    if (e.keyPress) {
+      const s = String(e.keyPress).split(/[\,\|]+/g).map((o) => o.trim()).filter(Boolean);
+      for (const o of s) {
+        const a = Fr(o);
+        a && this.keyMap.set(a, r);
+      }
+    }
+    return r;
+  }
+  /** Dynamically add button(s) into footer. Supports insertion index per side. */
+  addButton(e, t) {
+    this.$footer && (this.$footer.style.display = "");
+    const r = e.side ?? "right", n = r === "left" ? this.$buttonsLeft : this.$buttonsRight, s = r === "left" ? this.buttonElsLeft : this.buttonElsRight, o = this.generateButton(e), a = Math.max(0, Math.min(t ?? s.length, s.length));
+    return a >= n.children.length ? n.appendChild(o) : n.insertBefore(o, n.children[a]), s.splice(a, 0, o), this;
+  }
+  /** Remove button by element / id / global index (left first, then right). */
+  removeButton(e) {
+    const t = this.buttonElsLeft, r = this.buttonElsRight, n = [...t, ...r];
+    let s = null;
+    if (e === "*")
+      return n.forEach((a) => {
+        this.keyMap.delete(a.id), a.parentElement?.removeChild(a);
+      }), this.$footer && (this.$footer.style.display = "none"), this;
+    if (typeof e == "number" ? s = n[e] ?? null : typeof e == "string" ? s = n.find((a) => a.id === e) ?? null : e instanceof HTMLElement && (s = n.find((a) => a === e) ?? null), !s) return this;
+    for (const [a, f] of this.keyMap.entries()) f === s && this.keyMap.delete(a);
+    let o = t.indexOf(s);
+    return o !== -1 ? (t.splice(o, 1), s.parentElement?.removeChild(s)) : (o = r.indexOf(s), o !== -1 && (r.splice(o, 1), s.parentElement?.removeChild(s))), t.length === 0 && r.length === 0 && this.$footer && (this.$footer.style.display = "none"), this;
+  }
+  changePreviewState() {
+    return this.get$modal().classList.toggle("is-fullscreen"), this;
+  }
+  setModalHeight(e, t = "height") {
+    const r = this.get$window(), n = Math.max(0, window.innerHeight - e);
+    return r.style[t] = `${n}px`, n;
+  }
+  setOptions(e, t) {
+    return typeof e == "string" ? this.options[e] = t : Object.assign(this.options, e), this;
+  }
+  setPluginName(e) {
+    return this.$window && (this.$window.className = this.$window.className.replace(
+      `plugin--${this.pluginName}`,
+      `plugin--${e}`
+    )), this.pluginName = e, this;
+  }
+  // ------------------------------ helpers ------------------------------- //
+  applyAnimation(e) {
+    const t = this.get$modal(), r = this.get$window(), n = this.$backdrop, s = this.options.modalAnimation ?? this.options.animation, o = typeof s == "string" ? s : s && (e ? s.show : s.hide), a = this.options.backdropAnimation ?? this.options.animation, f = typeof a == "string" ? a : a && (e ? a.show : a.hide);
+    !o || o === !1 ? (t.style.transition = "none", r.style.animation = "none", r.style.removeProperty("--ipe-modal-anim")) : (t.style.removeProperty("transition"), r.style.setProperty("--ipe-modal-anim", o)), n && (!f || f === !1 ? n.style.transition = "none" : n.style.removeProperty("transition"));
+  }
+  on(e, t) {
+    return this._hooks.push({ type: e, listener: t }), () => this.off(e, t);
+  }
+  off(e, t) {
+    return this._hooks = this._hooks.filter(
+      (r) => r.type !== e && (t ? r.listener !== t : !0)
+    ), this;
+  }
+  once(e, t) {
+    const r = this.on(e, (n) => (r(), t(n)));
+    return r;
+  }
+  emit(e, t) {
+    const r = this._hooks.filter((a) => a.type === e);
+    let n = !0;
+    for (const a of r) {
+      const f = new CustomEvent(e, { detail: this, cancelable: t }), u = a.listener(f);
+      if (f.defaultPrevented && (n = !1), u === !1 && (n = !1), !n) break;
+    }
+    const s = this.$modal ?? document.body, o = new CustomEvent(e, { detail: this, cancelable: t });
+    return (!s.dispatchEvent(o) || o.defaultPrevented) && (n = !1), n;
+  }
+  focusFirst() {
+    const e = this.get$modal(), t = gt(e);
+    t.length ? t[0].focus() : e.focus({ preventScroll: !0 });
+  }
+  onKeyDown(e) {
+    if (T.top() !== this) return;
+    if (e.key === "Escape") {
+      e.preventDefault(), this.close();
+      return;
+    }
+    const t = this.get$modal();
+    if (!t.contains(document.activeElement)) return;
+    if (e.key === "Tab") {
+      const a = gt(t);
+      if (!a.length) return;
+      const f = a[0], u = a[a.length - 1], p = document.activeElement;
+      e.shiftKey && p === f ? (e.preventDefault(), u.focus()) : !e.shiftKey && p === u && (e.preventDefault(), f.focus());
+    }
+    const r = e.ctrlKey || e.altKey || e.metaKey, n = e.target;
+    if (!r && (n && ["INPUT", "TEXTAREA"].includes(n.tagName) || n.contentEditable === "true"))
+      return;
+    const s = zr(e), o = this.keyMap.get(s);
+    if (o) {
+      e.preventDefault(), o.click();
+      return;
+    }
+  }
+  setZIndex(e) {
+    this.$backdrop && (this.$backdrop.style.zIndex = String(e)), this.$modal && (this.$modal.style.zIndex = String(e + 1));
+  }
+  /** Bring this modal to the top of the stack. */
+  bringToFront() {
+    return T.remove(this), T.push(this), this;
+  }
+  isAnimationDisabled() {
+    const e = this.options.modalAnimation ?? this.options.animation;
+    return e === !1 || e == null;
+  }
+  shouldLockBodyOnOpen() {
+    return this.options.backdrop === !1 || this.options.bodyScroll !== !1 ? !1 : !T.stack.some(
+      (e) => e !== this && e.options.backdrop !== !1 && e.options.bodyScroll === !1
+    );
+  }
+  shouldUnlockBodyOnClose() {
+    return this.options.backdrop === !1 || this.options.bodyScroll !== !1 ? !1 : !T.stack.some(
+      (e) => e !== this && e.options.backdrop !== !1 && e.options.bodyScroll === !1
+    );
+  }
+  // ------------------------------ drag handlers ------------------------------- //
+  onDragStart(e) {
+    if (this.options.backdrop !== !1 || !this.options.draggable) return;
+    e.preventDefault(), this.isDragging = !0, this.bringToFront(), this.dragStartX = e.clientX, this.dragStartY = e.clientY;
+    const t = this.get$modal(), r = t.getBoundingClientRect();
+    this.modalStartX = r.left + window.pageXOffset, this.modalStartY = r.top + window.pageYOffset, t.style.transform = "none", t.style.left = `${this.modalStartX}px`, t.style.top = `${this.modalStartY}px`, document.addEventListener("pointermove", this.onDragMove), document.addEventListener("pointerup", this.onDragEnd), t.classList.add("is-dragging");
+  }
+  // ------------------------------ toast ------------------------------- //
+  /** Show as toast (no backdrop, container stack). */
+  showToast(e) {
+    this.$window || this.init();
+    const t = qr(e.position ?? "top right"), r = this.get$window();
+    this.isToast = !0, r.style.pointerEvents = "auto", this.applyAnimation(!0), t.appendChild(r);
+    const n = (typeof this.options.closeAfter == "number" ? this.options.closeAfter : this.options.closeAfter?.time) ?? 3e3, s = (typeof this.options.closeAfter == "number" ? !0 : this.options.closeAfter?.resetOnHover) ?? !0;
+    return n > 0 && (this.startCloseTimer(n), s && (r.addEventListener("mouseenter", this.stopCloseTimer), r.addEventListener("mouseleave", () => this.startCloseTimer(n)))), this.isOpen = !0, this.options.onShow?.(this), V.push(this), this.emit(
+      "toast.show"
+      /* ToastShow */
+    ), this.emit(
+      "modal.show"
+      /* Show */
+    ), this;
+  }
+  // ------------------------------ static helpers --------------------------- //
+  static show(e, t) {
+    return new this(e).init().show();
+  }
+  static createObject(e, t) {
+    return new this(e);
+  }
+  static close(e) {
+    if (!e) {
+      const s = T.top();
+      return s?.close(), s;
+    }
+    const t = typeof e == "string" ? e : e.id, r = T.stack.find((s) => s.modalId === t);
+    if (r)
+      return r.close(), r;
+    const n = V.find((s) => s.modalId === t);
+    return n?.close(), n;
+  }
+  static closeAll(e, t) {
+    const r = new Set((Array.isArray(t) ? t : t ? [t] : []).map(String)), n = new Set((Array.isArray(e) ? e : e ? [e] : []).map(String));
+    return T.closeAll(e, t), [...V].forEach((s) => {
+      const o = s.modalId, a = n.size ? n.has(s.pluginName) : !0, f = r.has(o);
+      a && !f && s.close();
+    }), T.top() ?? new de();
+  }
+  static removeAll() {
+    T.removeAll(), [...V].forEach((e) => e.destroy());
+  }
+  static dialog(e, t) {
+    const r = new this({
+      sizeClass: "dialog",
+      buttons: [
+        {
+          label: "OK",
+          className: "is-primary is-ghost",
+          method: (n, s) => {
+            t?.(n, s), n.defaultPrevented || r.close();
+          },
+          keyPress: "Enter"
+        }
+      ],
+      ...e
+    });
+    return r.init().show();
+  }
+  static confirm(e, t) {
+    e.title ??= "Confirm", e.content ??= "Are you sure you want to perform this action?";
+    const r = e.okBtn ?? { label: "OK", className: "is-primary is-ghost" }, n = e.cancelBtn ?? { label: "Cancel", className: "is-danger is-ghost" };
+    return new this({
+      sizeClass: "dialog",
+      ...e,
+      buttons: [
+        {
+          label: n.label,
+          className: n.className,
+          keyPress: "n",
+          method: (s, o) => {
+            t?.(!1, o, s), o.close();
+          }
+        },
+        {
+          label: r.label,
+          className: r.className,
+          keyPress: "y",
+          method: (s, o) => {
+            t?.(!0, o, s), s.defaultPrevented || o.close();
+          }
+        }
+      ]
+    }).init().show();
+  }
+  static getDefaultNotifyIcon(e) {
+    switch (e) {
+      case "success":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "currentColor",
+            class: "icon icon-tabler icons-tabler-filled icon-tabler-circle-check",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M17 3.34a10 10 0 1 1 -14.995 8.984l-.005 -.324l.005 -.324a10 10 0 0 1 14.995 -8.336zm-1.293 5.953a1 1 0 0 0 -1.32 -.083l-.094 .083l-3.293 3.292l-1.293 -1.292l-.094 -.083a1 1 0 0 0 -1.403 1.403l.083 .094l2 2l.094 .083a1 1 0 0 0 1.226 0l.094 -.083l4 -4l.083 -.094a1 1 0 0 0 -.083 -1.32z" })
+            ]
+          }
+        );
+      case "error":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "currentColor",
+            class: "icon icon-tabler icons-tabler-filled icon-tabler-alert-triangle",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M12 1.67c.955 0 1.845 .467 2.39 1.247l.105 .16l8.114 13.548a2.914 2.914 0 0 1 -2.307 4.363l-.195 .008h-16.225a2.914 2.914 0 0 1 -2.582 -4.2l.099 -.185l8.11 -13.538a2.914 2.914 0 0 1 2.491 -1.403zm.01 13.33l-.127 .007a1 1 0 0 0 0 1.986l.117 .007l.127 -.007a1 1 0 0 0 0 -1.986l-.117 -.007zm-.01 -7a1 1 0 0 0 -.993 .883l-.007 .117v4l.007 .117a1 1 0 0 0 1.986 0l.007 -.117v-4l-.007 -.117a1 1 0 0 0 -.993 -.883z" })
+            ]
+          }
+        );
+      case "warning":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "currentColor",
+            class: "icon icon-tabler icons-tabler-filled icon-tabler-alert-circle",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M12 2c5.523 0 10 4.477 10 10a10 10 0 0 1 -19.995 .324l-.005 -.324l.004 -.28c.148 -5.393 4.566 -9.72 9.996 -9.72zm.01 13l-.127 .007a1 1 0 0 0 0 1.986l.117 .007l.127 -.007a1 1 0 0 0 0 -1.986l-.117 -.007zm-.01 -8a1 1 0 0 0 -.993 .883l-.007 .117v4l.007 .117a1 1 0 0 0 1.986 0l.007 -.117v-4l-.007 -.117a1 1 0 0 0 -.993 -.883z" })
+            ]
+          }
+        );
+      case "info":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "currentColor",
+            class: "icon icon-tabler icons-tabler-filled icon-tabler-info-circle",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M12 2c5.523 0 10 4.477 10 10a10 10 0 0 1 -19.995 .324l-.005 -.324l.004 -.28c.148 -5.393 4.566 -9.72 9.996 -9.72zm0 9h-1l-.117 .007a1 1 0 0 0 0 1.986l.117 .007v3l.007 .117a1 1 0 0 0 .876 .876l.117 .007h1l.117 -.007a1 1 0 0 0 .876 -.876l.007 -.117l-.007 -.117a1 1 0 0 0 -.764 -.857l-.112 -.02l-.117 -.006v-3l-.007 -.117a1 1 0 0 0 -.876 -.876l-.117 -.007zm.01 -3l-.127 .007a1 1 0 0 0 0 1.986l.117 .007l.127 -.007a1 1 0 0 0 0 -1.986l-.117 -.007z" })
+            ]
+          }
+        );
+      case "dialog":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            class: "icon icon-tabler icons-tabler-outline icon-tabler-message-dots",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M12 11v.01" }),
+              /* @__PURE__ */ P("path", { d: "M8 11v.01" }),
+              /* @__PURE__ */ P("path", { d: "M16 11v.01" }),
+              /* @__PURE__ */ P("path", { d: "M18 4a3 3 0 0 1 3 3v8a3 3 0 0 1 -3 3h-5l-5 3v-3h-2a3 3 0 0 1 -3 -3v-8a3 3 0 0 1 3 -3z" })
+            ]
+          }
+        );
+      case "confirm":
+        return /* @__PURE__ */ P(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "24",
+            height: "24",
+            viewBox: "0 0 24 24",
+            fill: "currentColor",
+            class: "icon icon-tabler icons-tabler-filled icon-tabler-copy-check",
+            children: [
+              /* @__PURE__ */ P("path", { stroke: "none", d: "M0 0h24v24H0z", fill: "none" }),
+              /* @__PURE__ */ P("path", { d: "M18.333 6a3.667 3.667 0 0 1 3.667 3.667v8.666a3.667 3.667 0 0 1 -3.667 3.667h-8.666a3.667 3.667 0 0 1 -3.667 -3.667v-8.666a3.667 3.667 0 0 1 3.667 -3.667zm-3.333 -4c1.094 0 1.828 .533 2.374 1.514a1 1 0 1 1 -1.748 .972c-.221 -.398 -.342 -.486 -.626 -.486h-10c-.548 0 -1 .452 -1 1v9.998c0 .32 .154 .618 .407 .805l.1 .065a1 1 0 1 1 -.99 1.738a3 3 0 0 1 -1.517 -2.606v-10c0 -1.652 1.348 -3 3 -3zm1.293 9.293l-3.293 3.292l-1.293 -1.292a1 1 0 0 0 -1.414 1.414l2 2a1 1 0 0 0 1.414 0l4 -4a1 1 0 0 0 -1.414 -1.414" })
+            ]
+          }
+        );
+      default:
+        return null;
+    }
+  }
+  static notify(e, t, r) {
+    if (t?.overrideOther && [...V].forEach((a) => a.close()), typeof t.title > "u") {
+      const a = e || "Notification";
+      t.title = a[0].toUpperCase() + a.slice(1).toLowerCase();
+    }
+    const n = t.icon ?? this.getDefaultNotifyIcon(e);
+    n && (n instanceof Element && n.classList.add("ipe-modal-notify-icon"), t.title = /* @__PURE__ */ P(jr, { children: [
+      n,
+      t.title
+    ] })), e === "confirm" && (typeof t.closeAfter > "u" && (t.closeAfter = 0), t.okBtn || (t.okBtn = { label: "OK" })), t.okBtn && (typeof t.okBtn != "object" && (t.okBtn = { label: "OK" }), t.okBtn.label ??= "OK", t.okBtn.className ??= "is-primary is-text ok-btn", t.okBtn.method = (a, f) => {
+      r?.(!0, f, a), f.close();
+    }), t.cancelBtn && (typeof t.cancelBtn != "object" && (t.cancelBtn = { label: "Cancel" }), t.cancelBtn.label ??= "Cancel", t.cancelBtn.className ??= "is-danger is-text cancel-btn", t.cancelBtn.method = (a, f) => {
+      r?.(!1, f, a), f.close();
+    }), t.buttons = [t.cancelBtn, t.okBtn, ...t.buttons ?? []].filter(
+      Boolean
+    );
+    const s = `is-notify type-${e || "default"} ${t.className ?? ""}`, o = new this({
+      ...t,
+      className: s,
+      sizeClass: "auto",
+      center: !1,
+      fitScreen: !1,
+      closeIcon: !0,
+      outSideClose: !1,
+      bodyScroll: !0,
+      buttons: t.buttons ?? []
+    });
+    return o.setPluginName("toast"), o.showToast({
+      position: t.position ?? "top right"
+    });
+  }
+}
+const V = [];
+function qr(i = "top right") {
+  const e = "ipe-modal-toast-container", t = `${e}-${i.replace(/[\s-\.|\/]+/g, "-")}`;
+  let r = document.getElementById(t);
+  return r || (r = D("div", {
+    className: `${e} ${i}`,
+    attrs: { id: t, "data-position": i }
+  }), document.body.appendChild(r)), r;
+}
+class R extends de {
+  constructor(e = {}) {
+    e.className ||= "", e.className += " theme-ipe", e.modalAnimation ||= {
+      show: "ipe-modal-fade-in",
+      hide: "ipe-modal-fade-out"
+    }, super(e);
+  }
+  setLoadingState(e) {
+    if (this.get$window().classList.toggle("loading", e), e) {
+      const t = this.get$window().querySelectorAll(
+        "input:not([disabled]),button:not([disabled])"
+      );
+      this._tmpDisabledActiveInputs = t, t.forEach((r) => {
+        r.disabled = !0;
+      }), this.get$content().append(
+        /* @__PURE__ */ M(
+          "div",
+          {
+            id: "ipe-modalLoadingWrapper",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              bottom: 0,
+              display: "flex",
+              justifyContent: "center",
+              alignItems: "center",
+              backgroundColor: "rgba(255, 255, 255, 0.5)",
+              zIndex: 2e3
+            },
+            children: /* @__PURE__ */ M(Ei, { style: { width: "80%", maxWidth: "800px" } })
+          }
+        )
+      );
+    } else {
+      this.get$window().querySelector("#ipe-modalLoadingWrapper")?.remove();
+      const t = this._tmpDisabledActiveInputs;
+      t && t.forEach((r) => {
+        r.disabled = !1;
+      });
+    }
+  }
+}
+class Hr {
+  constructor(e) {
+    this.ctx = e, this.IPEModal = R, this.IPEModalEvent = Ge, this.show = R.show.bind(R), this.createObject = R.createObject.bind(R), this.close = R.close.bind(R), this.closeAll = R.closeAll.bind(R), this.removeAll = R.removeAll.bind(R), this.dialog = R.dialog.bind(R), this.confirm = R.confirm.bind(R), this.notify = R.notify.bind(R), e.set("modal", this), e.on("dispose", () => {
+      R.closeAll();
+    });
+  }
+}
+const Ut = (i) => {
+  if (!i)
+    return new URLSearchParams();
+  if (i instanceof URLSearchParams)
+    return i;
+  if (typeof i != "object" || i?.constructor !== Object)
+    throw new TypeError("only plain object is supported");
+  const e = new URLSearchParams();
+  for (const [t, r] of Object.entries(i))
+    if (r != null) {
+      if (Array.isArray(r)) {
+        for (const n of r)
+          e.append(t, n?.toString());
+        continue;
+      }
+      if (typeof r == "object" && r !== null && r.constructor === Object) {
+        for (const [n, s] of Object.entries(r))
+          s != null && e.set(`${t}[${n}]`, s?.toString());
+        continue;
+      }
+      e.set(t, r?.toString());
+    }
+  return e;
+}, Ft = (i, e, t) => {
+  const r = typeof i == "string" ? new URL(i, window?.location?.origin) : new URL(i), n = new URLSearchParams(r.search), s = Ut(e);
+  for (const [o, a] of s.entries())
+    n.set(o, a);
+  return r.search = n.toString(), r.hash = "", r;
+};
+var Wr = Object.create, Ve = Object.defineProperty, Gr = Object.getOwnPropertyDescriptor, zt = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), Kt = (i) => {
+  throw TypeError(i);
+}, Vr = (i, e, t) => e in i ? Ve(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, Jr = (i, e) => Ve(i, "name", { value: e, configurable: !0 }), Yr = (i) => [, , , Wr(i?.[zt("metadata")] ?? null)], Xr = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], qt = (i) => i !== void 0 && typeof i != "function" ? Kt("Function expected") : i, Qr = (i, e, t, r, n) => ({ kind: Xr[i], name: e, metadata: r, addInitializer: (s) => t._ ? Kt("Already initialized") : n.push(qt(s || null)) }), Zr = (i, e) => Vr(e, zt("metadata"), i[3]), en = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, tn = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && Gr(n, t));
+  Jr(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = Qr(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, qt(o) && (n = o);
+  return Zr(i, n), g && Ve(n, t, g), p ? u ^ 4 ? s : g : n;
+}, Ht, Je, Wt;
+Ht = [F(["api", "storage"])];
+class pe extends (Wt = z) {
+  constructor(e) {
+    super(e, "wiki", !1), this.ctx = e, this._data = {}, this.CACHE_VERSION = 4, this.CACHE_TTL = {
+      siteinfo: 1e3 * 60 * 60 * 24 * 3,
+      // 3 days
+      userinfo: 1e3 * 60 * 30
+      // 30 minutes
+    }, this.QUERY_DATA = {
+      siteinfo: {
+        meta: "siteinfo|filerepoinfo",
+        siprop: "general|specialpagealiases|namespacealiases|namespaces|magicwords",
+        friprop: "canUpload|displayname|initialCapital|local|name|rootUrl|scriptDirUrl|thumbUrl|url"
+      },
+      userinfo: { meta: "userinfo", uiprop: "groups|rights|blockinfo|options" }
+    }, this.CACHE_DB = void 0, this.mwConfig = {
+      get: ((t, r) => window?.mw?.config?.get?.(t, r) ?? r),
+      has: ((t) => window?.mw?.config?.exists?.(t) ?? !1),
+      get values() {
+        return window?.mw?.config?.values || {};
+      }
+    }, this.CACHE_DB = e.storage.createDatabase(
+      "wiki-metadata",
+      1 / 0,
+      this.CACHE_VERSION
+    );
+  }
+  get logger() {
+    return this.ctx.logger("WIKI_METADATA");
+  }
+  get api() {
+    return this.ctx.api;
+  }
+  async start() {
+    await Promise.all(
+      Object.keys(this.QUERY_DATA).map((e) => this.initData(e))
+    ), this.ctx.on("clear-cache", this.onClearCache.bind(this)), this.ctx.set("getUrl", this.getUrl.bind(this)), this.ctx.set("getSciprtUrl", this.getSciprtUrl.bind(this)), this.ctx.set("getMainpageUrl", this.getMainpageUrl.bind(this)), this.ctx.inject(["preferences", "$"], (e) => {
+      const t = e.$;
+      e.preferences.registerCustomConfig(
+        "WikiMetadataService",
+        $.object({
+          WikiMetadataService: $.const(
+            /* @__PURE__ */ M("div", { children: [
+              /* @__PURE__ */ M("h3", { children: t`Wiki Informations` }),
+              /* @__PURE__ */ M("ul", { children: [
+                /* @__PURE__ */ M("li", { children: [
+                  /* @__PURE__ */ M("strong", { children: [
+                    t`Site`,
+                    ":"
+                  ] }),
+                  " ",
+                  this.general.sitename,
+                  " (",
+                  this.landingPageUrl,
+                  ")"
+                ] }),
+                /* @__PURE__ */ M("li", { children: [
+                  /* @__PURE__ */ M("strong", { children: t`User` }),
+                  ": ",
+                  this.userInfo.name,
+                  " (ID: ",
+                  this.userInfo.id,
+                  ")"
+                ] }),
+                /* @__PURE__ */ M("li", { children: [
+                  /* @__PURE__ */ M("strong", { children: t`Groups` }),
+                  ": ",
+                  this.userGroups.join(", ") || "None"
+                ] })
+              ] }),
+              /* @__PURE__ */ M("div", { children: [
+                /* @__PURE__ */ M("p", { style: { fontStyle: "italic" }, children: t`If the information shown above is incorrect (for example, the user is not you), click the button below.` }),
+                /* @__PURE__ */ M(
+                  "button",
+                  {
+                    className: "btn danger",
+                    onClick: async (r) => {
+                      r.preventDefault(), await e.serial("clear-cache") || window.location.reload();
+                    },
+                    children: [
+                      "🧹 ",
+                      t`Clear caches & Reload`
+                    ]
+                  }
+                )
+              ] })
+            ] })
+          ).role("raw-html")
+        }).description("WikiMetadataService"),
+        "about"
+      );
+    }), this.logger.info("All initialized", this._data);
+  }
+  async initData(e, t = !1) {
+    const r = t ? null : await this.fetchFromCache(e);
+    if (r)
+      return this._data[e] = r, this.logger.debug("Using cached", e, r), r;
+    {
+      const n = await this.fetchFromApi(e);
+      return this.saveToCache(e, n), this._data[e] = n, this.logger.debug("Fetched from API", e, n), n;
+    }
+  }
+  getCacheKey(e) {
+    return `${e}:${new URL(this.ctx.api.config.baseURL).pathname.replace(/^\//, "")}`;
+  }
+  async fetchFromApi(e) {
+    return this.api.get({
+      action: "query",
+      ...this.QUERY_DATA[e]
+    }).then(({ data: t }) => {
+      if (typeof t?.query != "object" || t.query === null)
+        throw new Error("Invalid query data", { cause: t });
+      return e === "siteinfo" ? t.query : t.query?.[e] || t.query;
+    }).catch((t) => (this.logger.error("Failed to fetch", t), Promise.reject(t)));
+  }
+  async fetchFromCache(e) {
+    const t = this.getCacheKey(e);
+    return await this.CACHE_DB.get(t, this.CACHE_TTL[e]);
+  }
+  async saveToCache(e, t) {
+    const r = this.getCacheKey(e);
+    return this.CACHE_DB.set(r, t);
+  }
+  async invalidateCache(e) {
+    const t = this.getCacheKey(e);
+    return this.CACHE_DB.delete(t);
+  }
+  async onClearCache() {
+    await this.CACHE_DB.clear();
+  }
+  // ====== shortcuts ======
+  get _raw() {
+    return this._data;
+  }
+  // siteInfo
+  get siteInfo() {
+    return this._data.siteinfo;
+  }
+  get general() {
+    return this.siteInfo.general;
+  }
+  get specialPageAliases() {
+    return this.siteInfo.specialpagealiases;
+  }
+  get namespaceAliases() {
+    return this.siteInfo.namespacealiases;
+  }
+  get namespaces() {
+    return this.siteInfo.namespaces;
+  }
+  get namespaceMap() {
+    const e = Object.values(this.namespaces).map((t) => ({
+      id: t.id,
+      canonical: t.canonical,
+      aliases: this.namespaceAliases.filter((r) => r.id === t.id).map((r) => r.alias)
+    })).sort((t, r) => t.id - r.id);
+    return Reflect.defineProperty(this, "namespaceMap", {
+      get: () => e
+    }), e;
+  }
+  get magicWords() {
+    return this.siteInfo.magicwords;
+  }
+  // userInfo
+  get userInfo() {
+    return this._data.userinfo;
+  }
+  get userOptions() {
+    return this.userInfo.options;
+  }
+  get isUserBlocked() {
+    return this.userInfo.blockedbyid && this.userInfo.blockexpiry && new Date(this.userInfo.blockexpiry).getTime() > Date.now();
+  }
+  get userGroups() {
+    return this.userInfo.groups;
+  }
+  get userRights() {
+    return this.userInfo.rights;
+  }
+  // fileRepoInfo
+  get fileRepos() {
+    return this.siteInfo.repos || [];
+  }
+  /**
+   * Base URL, without trailing slash
+   * @example "https://mediawiki.org"
+   */
+  get baseUrl() {
+    const e = this.general.server;
+    return e.startsWith("//") ? `${window?.location?.protocol || "https:"}//${e.slice(2)}` : e;
+  }
+  /**
+   * Home page URL of this wiki
+   * @description Generally same as the Mainpage URL,
+   *              but after MediaWiki 1.34,
+   *              it can be set to the website root directory.
+   * @example "https://mediawiki.org/wiki/Main_Page" (In most cases)
+   * @example "https://mediawiki.org/" ($wgMainPageIsDomainRoot = true)
+   */
+  get landingPageUrl() {
+    return this.general.base;
+  }
+  get mainPageName() {
+    return this.general.mainpage;
+  }
+  /**
+   * Exact Mainpage URL of this wiki
+   * @example "https://mediawiki.org/wiki/Main_Page"
+   */
+  get mainPageUrl() {
+    return this.getUrl(this.mainPageName);
+  }
+  /**
+   * Article path, with the $1 placeholder
+   * @example "/wiki/$1"
+   */
+  get articlePath() {
+    return this.general.articlepath;
+  }
+  /**
+   * Script path, without trailing slash
+   * @example "/w"
+   */
+  get scriptPath() {
+    return this.general.scriptpath;
+  }
+  /**
+   * Article base URL, with the $1 placeholder
+   * @example "https://mediawiki.org/wiki/$1"
+   */
+  get articleBaseUrl() {
+    return `${this.baseUrl}${this.articlePath}`;
+  }
+  /**
+   * Script base URL, without trailing slash
+   * @example "https://mediawiki.org/w"
+   */
+  get scriptBaseUrl() {
+    return `${this.baseUrl}${this.scriptPath}`;
+  }
+  // utils
+  getSciprtUrl(e = "index") {
+    return `${this.scriptBaseUrl}/${e.replace(/\.php$/, "")}.php`;
+  }
+  /** Get mainpage URL */
+  getMainpageUrl(e) {
+    return Ft(this.siteInfo.general.base, e).toString();
+  }
+  getUrl(e, t) {
+    const r = Ut(t);
+    let n;
+    return typeof e == "string" && e !== "" ? n = new URL(`${this.articleBaseUrl.replace("$1", e)}`) : typeof e == "number" ? (r.set("curid", e.toString()), n = new URL(this.getSciprtUrl("index"))) : n = new URL(this.getSciprtUrl("index")), n.search = r.toString(), n.toString();
+  }
+  hasRight(e) {
+    return this.userRights.includes(e);
+  }
+  hasAnyRight(...e) {
+    return e.some((t) => this.hasRight(t));
+  }
+  hasEveryRights(...e) {
+    return e.every((t) => this.hasRight(t));
+  }
+  inGroup(e) {
+    return this.userGroups.includes(e);
+  }
+  inAnyGroup(...e) {
+    return this.userGroups.some((t) => e.includes(t));
+  }
+  getBlockInfo() {
+    return this.isUserBlocked ? {
+      blockid: this.userInfo.blockid,
+      blockedby: this.userInfo.blockedbyid,
+      blockedbyid: this.userInfo.blockedbyid,
+      blockreason: this.userInfo.blockreason,
+      blockedtimestamp: this.userInfo.blockedtimestamp,
+      blockexpiry: this.userInfo.blockexpiry
+    } : null;
+  }
+}
+Je = Yr(Wt);
+pe = tn(Je, 0, "WikiMetadataService", Ht, pe);
+en(Je, 1, pe);
+const rn = (() => {
+  const i = /* @__PURE__ */ Symbol.for("IPE.GlobalMemoryStorage");
+  return i in globalThis || (globalThis[i] = xi()), globalThis[i];
+})();
+class nn {
+  constructor(e, t, r = 1 / 0, n, s = "localStorage") {
+    this.dbName = e, this.storeName = t, this.ttl = r, this.version = n, this.engine = s, typeof r != "number" && (this.ttl = Number(r)), (isNaN(this.ttl) || this.ttl <= 0) && (this.ttl = 1 / 0), this.engine === "localStorage" && "localStorage" in window ? this.db = window.localStorage : this.engine === "sessionStorage" && "sessionStorage" in window ? this.db = window.sessionStorage : this.db = rn;
+  }
+  // Key builder
+  makeKey(e) {
+    return `${this.dbName ? this.dbName + ":" : ""}${this.storeName ? this.storeName + "/" : ""}${e}`;
+  }
+  // Internal load & validation
+  load(e) {
+    const t = this.getRaw(e);
+    if (t === null) return null;
+    let r;
+    try {
+      r = JSON.parse(t);
+    } catch {
+      return this.deleteSync(e), null;
+    }
+    const n = r;
+    return typeof n.time != "number" || !("value" in n) ? (this.deleteSync(e), null) : typeof this.version < "u" && typeof this.version < "u" && n.version !== this.version ? (this.deleteSync(e), null) : n;
+  }
+  getRaw(e) {
+    const t = this.makeKey(e);
+    return this.db.getItem(t);
+  }
+  setRaw(e, t) {
+    const r = this.makeKey(e);
+    try {
+      this.db.setItem(r, t);
+    } catch {
+    }
+  }
+  deleteSync(e) {
+    const t = this.makeKey(e);
+    this.db.removeItem(t);
+  }
+  isExpired(e, t = this.ttl) {
+    return e ? Date.now() - e.time > t : !1;
+  }
+  async get(e, t = this.ttl, r) {
+    const n = this.load(e), s = this.isExpired(n, t);
+    if (!n || s) {
+      if (typeof r == "function") {
+        const o = await r();
+        return await this.set(e, o), o;
+      }
+      return null;
+    }
+    return n.value;
+  }
+  async set(e, t) {
+    const r = Date.now();
+    if (typeof e == "string") {
+      const o = e, a = t;
+      if (a === null || typeof a > "u") {
+        await this.delete(o);
+        return;
+      }
+      const f = { time: r, value: a, version: this.version };
+      return this.setRaw(o, JSON.stringify(f)), f;
+    }
+    const n = e, s = {};
+    for (const [o, a] of Object.entries(n)) {
+      if (a === null || typeof a > "u") {
+        this.deleteSync(o);
+        continue;
+      }
+      const f = { time: r, value: a, version: this.version };
+      this.setRaw(o, JSON.stringify(f)), s[o] = f;
+    }
+    return s;
+  }
+  async has(e, t = this.ttl) {
+    const r = this.load(e);
+    return r !== null && !this.isExpired(r, t);
+  }
+  async delete(e) {
+    this.deleteSync(e);
+  }
+  async updatedAt(e) {
+    const t = this.load(e);
+    return t ? t.time : 0;
+  }
+  async clear() {
+    const e = this.makeKey(""), t = [];
+    for (let r = 0; r < this.db.length; r++) {
+      const n = this.db.key(r);
+      n && n.startsWith(e) && t.push(n);
+    }
+    for (const r of t) this.db.removeItem(r);
+    return this;
+  }
+  // Async generators
+  async *keys() {
+    const e = this.makeKey("");
+    for (let t = 0; t < this.db.length; t++) {
+      const r = this.db.key(t);
+      r && r.startsWith(e) && (yield r.slice(e.length));
+    }
+  }
+  async *values() {
+    for await (const e of this.keys()) {
+      const t = this.load(e);
+      if (t) {
+        if (this.isExpired(t)) {
+          this.deleteSync(e);
+          continue;
+        }
+        yield t;
+      }
+    }
+  }
+  async *entries() {
+    for await (const e of this.keys()) {
+      const t = this.load(e);
+      if (t) {
+        if (this.isExpired(t)) {
+          this.deleteSync(e);
+          continue;
+        }
+        yield [e, t];
+      }
+    }
+  }
+}
+var L;
+((i) => {
+  i.cache = /* @__PURE__ */ new Map(), i.defaults = Object.freeze({ iterBatch: 100, retry: { attempts: 3, baseDelayMs: 16 } }), i.sleep = (u) => new Promise((p) => setTimeout(p, u));
+  function e(u) {
+    const p = u?.name ?? "";
+    return p === "AbortError" || p === "InvalidStateError" || p === "TransactionInactiveError" || p === "UnknownError";
+  }
+  i.shouldReconnect = e;
+  async function t(u, p, y) {
+    const _ = Math.max(1, u.attempts);
+    for (let g = 0; g < _; g++)
+      try {
+        return await p(g);
+      } catch (w) {
+        if (g === _ - 1) throw w;
+        await y?.(w, g);
+        const O = u.baseDelayMs * Math.pow(2, g) + Math.floor(Math.random() * 10);
+        await (0, i.sleep)(O);
+      }
+    throw new Error("withRetry exhausted unexpectedly");
+  }
+  i.withRetry = t;
+  function r(u, p, y) {
+    return new Promise((_, g) => {
+      const w = indexedDB.open(u, p);
+      w.onupgradeneeded = () => {
+        try {
+          const O = w.result, C = w.transaction;
+          y?.(O, C);
+        } catch (O) {
+          g(O);
+        }
+      }, w.onerror = () => g(w.error), w.onblocked = () => {
+      }, w.onsuccess = () => {
+        const O = w.result;
+        O.onversionchange = () => {
+          try {
+            O.close();
+          } finally {
+            i.cache.delete(u);
+          }
+        }, _(O);
+      };
+    });
+  }
+  async function n(u, p, y) {
+    let _ = !u.objectStoreNames.contains(p), g = [];
+    if (!_ && y?.indexes?.length) {
+      const C = u.transaction(p, "readonly"), l = C.objectStore(p), c = new Set(Array.from(l.indexNames));
+      g = (y.indexes || []).filter((h) => !c.has(h.name)), await new Promise((h, d) => {
+        C.oncomplete = () => h(), C.onabort = () => d(C.error), C.onerror = () => d(C.error);
+      });
+    }
+    if (!_ && g.length === 0) return u;
+    const w = u.version + 1;
+    u.close();
+    const O = await r(u.name, w, (C, l) => {
+      let c;
+      C.objectStoreNames.contains(p) ? c = l.objectStore(p) : c = C.createObjectStore(p, {
+        keyPath: y?.keyPath ?? void 0,
+        autoIncrement: !!y?.autoIncrement
+      });
+      for (const h of g)
+        c.indexNames.contains(h.name) || c.createIndex(h.name, h.keyPath, h.options);
+    });
+    return O.onversionchange = () => {
+      try {
+        O.close();
+      } finally {
+        i.cache.delete(O.name);
+      }
+    }, O;
+  }
+  async function s(u, p, y) {
+    let _ = i.cache.get(u);
+    return _ ? (_ = _.then((g) => n(g, p, y)), i.cache.set(u, _)) : (_ = (async () => {
+      const g = await r(u);
+      return n(g, p, y);
+    })(), i.cache.set(u, _)), _;
+  }
+  i.getDB = s;
+  async function o(u) {
+    const p = i.cache.get(u);
+    if (i.cache.delete(u), p)
+      try {
+        (await p).close();
+      } catch {
+      }
+  }
+  i.closeConnection = o;
+  function a(u) {
+    return new Promise((p, y) => {
+      u.onsuccess = () => p(u.result), u.onerror = () => y(u.error);
+    });
+  }
+  i.asyncRequest = a;
+  function f(u) {
+    return new Promise((p, y) => {
+      u.oncomplete = () => p(), u.onabort = () => y(u.error ?? new DOMException("Aborted", "AbortError")), u.onerror = () => y(u.error ?? new DOMException("TransactionError", "UnknownError"));
+    });
+  }
+  i.waitTx = f;
+})(L || (L = {}));
+class sn {
+  constructor(e, t, r = {}) {
+    this.dbName = e, this.storeName = t, this.options = r;
+  }
+  get _iterBatch() {
+    return this.options.iterBatch ?? L.defaults.iterBatch;
+  }
+  get _retryCfg() {
+    const e = this.options.retry ?? L.defaults.retry;
+    return { attempts: e.attempts ?? 3, baseDelayMs: e.baseDelayMs ?? 16 };
+  }
+  async _withStore(e, t) {
+    const r = this._retryCfg;
+    return L.withRetry(
+      r,
+      async () => {
+        const n = await L.getDB(this.dbName, this.storeName, this.options.ensure);
+        try {
+          const s = n.transaction(this.storeName, e), o = s.objectStore(this.storeName), a = await t(o);
+          return await L.waitTx(s), a;
+        } catch (s) {
+          throw s;
+        }
+      },
+      async (n) => {
+        L.shouldReconnect(n) && await L.closeConnection(this.dbName);
+      }
+    );
+  }
+  async get(e) {
+    return this._withStore("readonly", async (t) => {
+      const r = await L.asyncRequest(t.get(e));
+      return r === void 0 ? void 0 : r;
+    });
+  }
+  async set(e, t) {
+    return await this._withStore("readwrite", async (r) => {
+      const n = this.options.ensure?.keyPath != null ? r.put(t) : r.put(t, e);
+      await L.asyncRequest(n);
+    }), this;
+  }
+  async delete(e) {
+    return this._withStore("readwrite", async (t) => {
+      const r = await L.asyncRequest(t.get(e)) !== void 0;
+      return await L.asyncRequest(t.delete(e)), r;
+    });
+  }
+  async clear() {
+    await this._withStore("readwrite", async (e) => {
+      await L.asyncRequest(e.clear());
+    });
+  }
+  async has(e) {
+    return await this.get(e) !== void 0;
+  }
+  async count() {
+    return this._withStore("readonly", async (e) => await L.asyncRequest(e.count()) ?? 0);
+  }
+  async *_iterateEntries() {
+    let e = null, t = !1;
+    const r = Math.max(1, this._iterBatch);
+    for (; !t; ) {
+      const n = await this._withStore("readonly", async (s) => {
+        const o = [], a = e === null ? void 0 : IDBKeyRange.lowerBound(e, !0);
+        return await new Promise((f, u) => {
+          const p = s.openCursor(a);
+          p.onerror = () => u(p.error), p.onsuccess = () => {
+            const y = p.result;
+            if (!y) {
+              t = !0, f();
+              return;
+            }
+            o.push([y.key, y.value]), e = y.key, o.length >= r ? f() : y.continue();
+          };
+        }), o;
+      });
+      for (const s of n) yield s;
+      if (n.length === 0) break;
+    }
+  }
+  entries() {
+    return this._iterateEntries();
+  }
+  async *keys() {
+    for await (const [e] of this.entries()) yield e;
+  }
+  async *values() {
+    for await (const [, e] of this.entries()) yield e;
+  }
+  [Symbol.asyncIterator]() {
+    return this.entries()[Symbol.asyncIterator]();
+  }
+  async forEach(e) {
+    for await (const [t, r] of this.entries())
+      await e(r, t, this);
+  }
+  async getMany(e) {
+    const t = /* @__PURE__ */ new Map();
+    for await (const r of e) t.set(r, void 0);
+    return await this._withStore("readonly", async (r) => {
+      await Promise.all(
+        t.keys().map(async (n) => {
+          const s = await L.asyncRequest(r.get(n));
+          t.set(n, s === void 0 ? void 0 : s);
+        })
+      );
+    }), t;
+  }
+  async setMany(e) {
+    const t = this.options.ensure?.keyPath != null;
+    return await this._withStore("readwrite", async (r) => {
+      for await (const [n, s] of e) {
+        const o = t ? r.put(s) : r.put(s, n);
+        await L.asyncRequest(o);
+      }
+    }), this;
+  }
+  async deleteMany(e) {
+    let t = 0;
+    return await this._withStore("readwrite", async (r) => {
+      for await (const n of e)
+        await L.asyncRequest(r.get(n)) !== void 0 && t++, await L.asyncRequest(r.delete(n));
+    }), t;
+  }
+  async disconnect() {
+    await L.closeConnection(this.dbName);
+  }
+}
+class on {
+  constructor(e, t, r = 1 / 0, n) {
+    this.dbName = e, this.storeName = t, this.ttl = r, this.version = n, this.db = new sn(e, t), this.keys = this.db.keys.bind(this.db), this.values = this.db.values.bind(this.db), this.entries = this.db.entries.bind(this.db), typeof this.ttl != "number" && (this.ttl = Number(this.ttl)), (isNaN(this.ttl) || this.ttl <= 0) && (this.ttl = 1 / 0), this._clearExpiredEntries().catch(() => {
+    });
+  }
+  async _clearExpiredEntries() {
+    if (this.ttl === 1 / 0) return;
+    const e = Date.now(), t = [];
+    for await (const [r, n] of this.db.entries())
+      typeof n.time == "number" && e - n.time > this.ttl && t.push(r);
+    t.length > 0 && await this.db.deleteMany(t);
+  }
+  async get(e, t = this.ttl, r) {
+    const n = await this.loadFromDB(e), s = this.checkIfExpired(n, t);
+    if (!n || s) {
+      if (typeof r == "function") {
+        const o = await r();
+        return await this.set(e, o), o;
+      }
+      return null;
+    }
+    return n.value;
+  }
+  async set(e, t) {
+    const r = Date.now();
+    if (typeof e == "string") {
+      const f = e, u = t;
+      if (u === null || typeof u > "u")
+        return this.delete(f);
+      const p = {
+        time: r,
+        value: u,
+        version: this.version
+      };
+      return await this.db.set(f, p), p;
+    }
+    const n = e, s = [], o = [], a = {};
+    for (const [f, u] of Object.entries(n))
+      if (u === null || typeof u > "u")
+        o.push(f);
+      else {
+        const p = { time: r, value: u, version: this.version };
+        s.push([f, p]), a[f] = p;
+      }
+    return s.length > 0 && await this.db.setMany(s), o.length > 0 && await this.db.deleteMany(o), a;
+  }
+  async has(e, t = this.ttl) {
+    const r = await this.loadFromDB(e), n = this.checkIfExpired(r, t);
+    return r !== null && !n;
+  }
+  async delete(e) {
+    await this.db.delete(e);
+  }
+  async updatedAt(e) {
+    const t = await this.loadFromDB(e);
+    return t ? t.time : 0;
+  }
+  async loadFromDB(e) {
+    const t = await this.db.get(e);
+    if (t === void 0)
+      return null;
+    if (typeof t.time != "number" || typeof t.value > "u") {
+      try {
+        await this.delete(e);
+      } catch {
+      }
+      return null;
+    }
+    if (typeof this.version < "u" && typeof this.version < "u" && t.version !== this.version) {
+      try {
+        await this.delete(e);
+      } catch {
+      }
+      return null;
+    }
+    return t;
+  }
+  checkIfExpired(e, t = this.ttl) {
+    return e ? Date.now() - e.time > t : !1;
+  }
+  /**
+   * [DANGER] Use with caution!
+   * Delete all data from the database.
+   */
+  async clear() {
+    return await this.db.clear(), this;
+  }
+}
+class an extends z {
+  constructor(e, t) {
+    super(e, "storage", !1), this.config = t, this.kv = this.createDatabase("key-val", 0, 1, "indexedDB"), this.simpleKV = this.createDatabase("~", 0, 1, "localStorage"), this.memoryKV = this.createDatabase("~", 0, 1, "memory");
+  }
+  createDatabase(e, t, r, n = "indexedDB") {
+    const s = "indexedDB" in window && window.indexedDB !== null;
+    switch (n === "indexedDB" && !s && (n = "localStorage"), n) {
+      case "indexedDB":
+        return new on(this.config.dbName, e, t, r);
+      case "localStorage":
+      case "sessionStorage":
+      case "memory":
+        return new nn(this.config.dbName, e, t, r, n);
+      default:
+        throw new Error(`Unsupported storage engine: ${n}`);
+    }
+  }
+}
+function Gt(i) {
+  return function(e) {
+    return e.PreferencesSchema = i, e;
+  };
+}
+var cn = Object.create, Ye = Object.defineProperty, ln = Object.getOwnPropertyDescriptor, Vt = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), Jt = (i) => {
+  throw TypeError(i);
+}, hn = (i, e, t) => e in i ? Ye(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, un = (i, e) => Ye(i, "name", { value: e, configurable: !0 }), fn = (i) => [, , , cn(i?.[Vt("metadata")] ?? null)], dn = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], Yt = (i) => i !== void 0 && typeof i != "function" ? Jt("Function expected") : i, pn = (i, e, t, r, n) => ({ kind: dn[i], name: e, metadata: r, addInitializer: (s) => t._ ? Jt("Already initialized") : n.push(Yt(s || null)) }), gn = (i, e) => hn(e, Vt("metadata"), i[3]), mn = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, yn = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && ln(n, t));
+  un(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = pn(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, Yt(o) && (n = o);
+  return gn(i, n), g && Ye(n, t, g), p ? u ^ 4 ? s : g : n;
+}, Xt, Xe, Qt;
+Xt = [F(["preferences"]), Gt(
+  $.object({
+    theme: $.union([
+      $.const("auto").description("Follow system"),
+      $.const("light").description("Light mode"),
+      $.const("dark").description("Dark mode"),
+      $.const("fandom").description("Follow Fandom")
+    ]).default("auto").description("Theme preference")
+  }).description("Theme settings").extra("category", "general")
+)];
+class ge extends (Qt = z) {
+  constructor(e) {
+    super(e, "theme", !1), this.ctx = e, this._mediaQueryList = null, this._observer = null, this._handleSystemThemeChange = this._onSystemThemeChange.bind(this), this._handleBodyClassChange = this._onBodyClassChange.bind(this);
+  }
+  async start() {
+    this._mediaQueryList = window.matchMedia("(prefers-color-scheme: dark)"), this._mediaQueryList.addEventListener("change", this._handleSystemThemeChange), this._observer = new MutationObserver(this._handleBodyClassChange), await this.applyTheme(), this.ctx.on("preferences/changed", async ({ changes: e }) => {
+      "theme" in e && await this.applyTheme();
+    });
+  }
+  stop() {
+    this._mediaQueryList && this._mediaQueryList.removeEventListener("change", this._handleSystemThemeChange), this._observer?.disconnect();
+  }
+  async _onSystemThemeChange() {
+    await this.applyTheme();
+  }
+  async _onBodyClassChange() {
+    await this.applyTheme();
+  }
+  async applyTheme() {
+    const e = await this.ctx.preferences.get("theme") || "auto";
+    this.updateFandomObserver(e);
+    const t = this.getTheme(e);
+    this.applyThemeClass(t), this.ctx.emit("theme/changed", { ctx: this.ctx, theme: t });
+  }
+  // don't run observer unless using fandom option
+  updateFandomObserver(e) {
+    e === "fandom" ? this._observer?.observe(document.body, {
+      attributes: !0,
+      attributeFilter: ["class"]
+    }) : this._observer?.disconnect();
+  }
+  getTheme(e) {
+    if (e === "auto")
+      return this._mediaQueryList?.matches ? "dark" : "light";
+    if (e === "fandom") {
+      const t = document.body;
+      return t.classList.contains("theme-fandomdesktop-dark") || t.classList.contains("theme-fandommobile-dark") ? "dark" : "light";
+    }
+    return e;
+  }
+  applyThemeClass(e) {
+    const t = document.body;
+    e === "dark" ? (t.classList.add("ipe-theme-dark"), t.setAttribute("data-ipe-theme", "dark")) : (t.classList.remove("ipe-theme-dark"), t.setAttribute("data-ipe-theme", "light"));
+  }
+  get currentTheme() {
+    return document.body.classList.contains("ipe-theme-dark") ? "dark" : "light";
+  }
+}
+Xe = fn(Qt);
+ge = yn(Xe, 0, "ThemeService", Xt, ge);
+mn(Xe, 1, ge);
+class wn extends z {
+  constructor(e) {
+    super(e, "wikiPage", !0), this.ctx = e, this.WikiPage = ki(this.ctx.api);
+  }
+  static {
+    this.inject = ["api"];
+  }
+  async createInstance(e, t = !1) {
+    return await this.WikiPage.newFromApi(e);
+  }
+  async newFromTitle(e, t = !1, r, n = !1) {
+    return this.createInstance({ titles: e.toString(), converttitles: t, rvsection: r }, n);
+  }
+  async newFromPageId(e, t, r = !1) {
+    return this.createInstance({ pageids: e, rvsection: t }, r);
+  }
+  async newFromRevision(e, t, r = !1) {
+    return await this.createInstance({ revids: e, rvsection: t }, r);
+  }
+  newBlankPage(e = {}) {
+    return this.WikiPage.newBlankPage(e);
+  }
+}
+class Qe extends z {
+  constructor(e) {
+    super(e, "wikiTitle", !0), this.ctx = e, this.logger = this.ctx.logger("WikiTitleService"), this._cachedTitles = /* @__PURE__ */ new Map(), this.wiki = this.ctx.wiki, this.wikiBaseUrl = this.wiki.baseUrl, this.wikiArticlePath = this.wiki.articlePath.replace("$1", ""), this.wikiArticleBaseUrl = this.wiki.articleBaseUrl.replace("$1", ""), this.wikiIndexPhpUrl = this.wiki.getSciprtUrl("index.php"), this.Title = Si(this.ctx.wiki.siteInfo);
+  }
+  static {
+    this.inject = ["wiki", "wikiPage"];
+  }
+  newTitle(e, t) {
+    return typeof e == "string" ? new this.Title(e, t) : e;
+  }
+  newMainPageTitle() {
+    return this.newTitle(this.ctx.wiki.mainPageName);
+  }
+  async newTitleFromUrl(e) {
+    const t = this.parseWikiLink(e);
+    return t?.title ? t.title : t?.pageId ? this.newTitleFromPageId(t.pageId) : null;
+  }
+  async newTitleFromAnyId(e, t = !1) {
+    const { title: r, pageId: n, revId: s } = e ?? {};
+    if (typeof r == "string")
+      return this.newTitle(r);
+    let o, a;
+    if (s ? (o = parseInt(s.toString(), 10), a = "revid") : n && (o = parseInt(n.toString(), 10), a = "pageid"), !o || !a || isNaN(o) || o <= 0)
+      throw new Error("Invalid id or kind", { cause: e });
+    if (!t && this._cachedTitles.has(`${a}:${o}`))
+      return await this._cachedTitles.get(`${a}:${o}`);
+    const { promise: f, resolve: u, reject: p } = wt();
+    this._cachedTitles.set(`${a}:${o}`, f);
+    try {
+      const { wikiPage: y } = this.ctx;
+      let _ = null;
+      if (a === "pageid")
+        _ = await y.newFromPageId(o);
+      else if (a === "revid")
+        _ = await y.newFromRevision(o);
+      else
+        throw new Error(`Invalid kind: ${a}`);
+      u(this.newTitle(_.title));
+    } catch (y) {
+      this._cachedTitles.delete(`${a}:${o}`), p(y);
+    }
+    return f;
+  }
+  async newTitleFromPageId(e) {
+    return this.newTitleFromAnyId({ pageId: e });
+  }
+  async newTitleFromRevision(e) {
+    return this.newTitleFromAnyId({ revId: e });
+  }
+  /**
+   * Resolve **special** special pages to it's real target
+   *
+   * If target is self or cannot be resolved, return null
+   * @example
+   * ```
+   * Special:MyPage -> User:<username>
+   * Special:Edit/Page_Title -> Page_Title
+   * Special:NewSection/Page_Title -> Page_Title (section=new)
+   * ```
+   */
+  resolveSpecialPageTarget(e) {
+    const t = typeof e == "string" ? this.newTitle(e) : e;
+    if (!t || t.getNamespaceId() !== -1)
+      return null;
+    let r, n, s = "view";
+    const o = t.getMainDBKey().split("/").slice(1).join("/") || "";
+    if (t.isSpecial("edit") && o)
+      r = o, s = "edit";
+    else if (t.isSpecial("talkpage") && o) {
+      const a = t.newTitle(o).getTalkPage();
+      if (!a)
+        return null;
+      r = a.getPrefixedDBKey();
+    } else if (t.isSpecial("mypage"))
+      r = t.newTitle(this.ctx.wiki.userInfo.name, 2).getPrefixedDBKey() + (o ? `/${o}` : "");
+    else if (t.isSpecial("mytalk"))
+      r = t.newTitle(this.ctx.wiki.userInfo.name, 3).getPrefixedDBKey() + (o ? `/${o}` : "");
+    else if (t.isSpecial("newsection") && o)
+      r = o, n = "new", s = "edit";
+    else
+      return null;
+    return {
+      title: new this.Title(r),
+      section: n,
+      action: s
+    };
+  }
+  isWikiLink(e) {
+    return e.startsWith(this.wikiArticleBaseUrl) || e.startsWith(this.wikiIndexPhpUrl) || // Some servers allow index.php to be omitted
+    e.startsWith(`${this.wikiBaseUrl}/?`) || // It's the landing page
+    e === this.ctx.wiki.landingPageUrl;
+  }
+  static {
+    this.REG_SKIPPED_HREF = /^(#|javascript:|vbscript:|file:)/i;
+  }
+  validateHrefAttr(e) {
+    return typeof e != "string" ? !1 : !Qe.REG_SKIPPED_HREF.test(e);
+  }
+  parseWikiLink(e) {
+    if (!e || typeof e == "string" && !this.validateHrefAttr(e))
+      return null;
+    const t = Ft(e);
+    if (!this.isWikiLink(t.toString()))
+      return null;
+    const r = t.searchParams, n = t.hash.replace("#", ""), s = r.get("action") || "view", o = r.get("title") || "", a = parseInt(r.get("curid") || "0", 10), f = parseInt(r.get("oldid") || "0", 10);
+    let u = o || (() => {
+      try {
+        return decodeURIComponent(t.pathname.substring(this.wikiArticlePath.length));
+      } catch (g) {
+        return this.logger.error("parseLink", t, g), "";
+      }
+    })();
+    u.endsWith("index.php") && (u = "");
+    let p, y, _;
+    if (f)
+      _ = f;
+    else if (a)
+      y = a;
+    else if (u)
+      p = this.newTitle(u);
+    else if (t.origin + t.pathname === this.ctx.wiki.landingPageUrl)
+      p = this.newMainPageTitle();
+    else
+      return null;
+    return {
+      title: p,
+      pageId: y,
+      revId: _,
+      url: t,
+      params: r,
+      hash: n,
+      action: s
+    };
+  }
+}
+const Zt = (i) => typeof i == "function";
+async function bn(i) {
+  return Zt(i) ? await i() : i;
+}
+function gs(i) {
+  return Zt(i) ? i() : i;
+}
+var vn = Object.create, Ze = Object.defineProperty, _n = Object.getOwnPropertyDescriptor, ei = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), ti = (i) => {
+  throw TypeError(i);
+}, xn = (i, e, t) => e in i ? Ze(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, kn = (i, e) => Ze(i, "name", { value: e, configurable: !0 }), Sn = (i) => [, , , vn(i?.[ei("metadata")] ?? null)], $n = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], ii = (i) => i !== void 0 && typeof i != "function" ? ti("Function expected") : i, En = (i, e, t, r, n) => ({ kind: $n[i], name: e, metadata: r, addInitializer: (s) => t._ ? ti("Already initialized") : n.push(ii(s || null)) }), Cn = (i, e) => xn(e, ei("metadata"), i[3]), An = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, On = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && _n(n, t));
+  kn(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = En(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, ii(o) && (n = o);
+  return Cn(i, n), g && Ze(n, t, g), p ? u ^ 4 ? s : g : n;
+}, ri, et, ni;
+ri = [F(["storage", "wiki"])];
+class me extends (ni = z) {
+  constructor(e) {
+    super(e, "preferences", !0), this.ctx = e, this.db = void 0, this.customRegistries = [], this.categoryDefinitions = [], this._defaultPreferences = {}, e.set("prefs", this), this.db = e.storage.createDatabase(`preferences:${e.wiki.userInfo.id}`, 1 / 0);
+    try {
+      this._migrageFromLegacyMasterDB();
+    } catch {
+    }
+  }
+  get logger() {
+    return this.ctx.logger("PREFERENCES");
+  }
+  async start() {
+  }
+  async get(e, t) {
+    if (!e)
+      return this.getAll();
+    t ??= () => {
+      const n = this.defaultOf(e);
+      return this.logger.debug(e, `(fallback value: ${n})`), n;
+    };
+    const r = await this.db.get(e, void 0);
+    return r !== null ? r : await bn(t);
+  }
+  /**
+   * 获取全部注册的配置项以及最终生效的值
+   * 未保存的配置项将使用默认值
+   */
+  async getAll() {
+    const e = this.loadDefaultConfigs();
+    for await (const [t, r] of this.db.entries())
+      t !== "_touched" && t in e && (e[t] = r.value);
+    return e;
+  }
+  async set(e, t) {
+    return (await this.setMany({ [e]: t }))[e];
+  }
+  async setMany(e) {
+    const t = this.loadDefaultConfigs(), r = {};
+    for (const [n, s] of Object.entries(e))
+      s === t[n] || s === void 0 ? r[n] = void 0 : r[n] = s;
+    return await this.db.set(r), this.ctx.emit("preferences/changed", { ctx: this.ctx, input: e, changes: r }), r;
+  }
+  defaultOf(e) {
+    return this._defaultPreferences[e] ??= this.loadDefaultConfigs()[e];
+  }
+  /**
+   * Get exportable configurations
+   * - exclude values that are the same as the default value
+   * - exclude invalid or undefined values
+   * - sort by keys
+   */
+  async getExportableRecord(e) {
+    e ??= await this.getAll();
+    const t = this.loadDefaultConfigs(), r = {};
+    return Object.entries(t).sort(([n], [s]) => n.localeCompare(s)).forEach(([n, s]) => {
+      const o = e[n];
+      o !== void 0 && o !== s && (r[n] = o);
+    }), r;
+  }
+  loadDefaultConfigs() {
+    const e = {};
+    return this.getConfigRegistries().forEach((t) => {
+      try {
+        const r = t.schema({});
+        Object.entries(r).forEach(([n, s]) => {
+          e[n] = s;
+        });
+      } catch {
+      }
+    }), Object.entries(e).forEach(([t, r]) => {
+      this._defaultPreferences[t] = r;
+    }), e;
+  }
+  registerCustomConfig(e, t, r) {
+    const n = {
+      name: e,
+      schema: t,
+      category: r || "general"
+    }, s = this.customRegistries.findIndex((o) => o.name === e);
+    return s >= 0 ? this.customRegistries[s] = n : this.customRegistries.push(n), this;
+  }
+  getConfigRegistries(e) {
+    return Array.from(this.ctx.registry.entries()).map(([t]) => t === null ? {
+      name: "@root",
+      schema: be?.PreferencesSchema || null
+    } : {
+      name: t.name,
+      schema: t?.PreferencesSchema || null
+    }).filter((t) => t.schema !== null).map((t) => ({
+      ...t,
+      category: t.schema.meta.category || "general"
+    })).concat(this.customRegistries).filter((t) => !e || t.category === e);
+  }
+  getAllSchema() {
+    return new $(
+      $.intersect(this.getConfigRegistries().map((e) => e.schema))
+    );
+  }
+  defineCategory(e) {
+    const t = this.categoryDefinitions.findIndex((r) => r.name === e.name);
+    return t < 0 ? this.categoryDefinitions.push(e) : this.categoryDefinitions[t] = e, this.categoryDefinitions.sort((r, n) => (r.index ?? 0) - (n.index ?? 0)), this;
+  }
+  getConfigCategories() {
+    return this.categoryDefinitions;
+  }
+  async _migrageFromLegacyMasterDB() {
+    const e = this.ctx.storage.createDatabase("preferences", 1 / 0);
+    let t = 0;
+    for await (const [r, n] of e.entries())
+      r !== "_touched" && (await this.db.set(r, n.value), t++);
+    return t && this.logger.info(`Migrated ${t} preferences from master DB`), await e.clear(), await e?.db?.disconnect?.(), t;
+  }
+}
+et = Sn(ni);
+me = On(et, 0, "PreferencesService", ri, me);
+An(et, 1, me);
+var tt = /* @__PURE__ */ ((i) => (i.ANALYTICS_API_BASE = "https://analytics.ipe.wiki/api/v6", i.ANALYTICS_DASH_URL = "https://analytics.ipe.wiki", i.GITHUB_URL = "https://github.com/inpageedit/inpageedit-next", i.GITHUB_OWNER = "inpageedit", i.GITHUB_REPO = "inpageedit-next", i.HOME_URL = "https://www.ipe.wiki/", i.UPDATE_LOGS_URL = "https://www.ipe.wiki/changelogs/", i.PLUGIN_REGISTRY_URL = "https://registry.ipe.wiki/registry.v1.json", i.I18N_INDEX_URL = "https://registry.ipe.wiki/i18n/index.json", i.QQ_GROUP_ID = "1026023666", i))(tt || {});
+const si = "", oi = "", Pn = /\\\{/g, In = /\\\}/g, Ln = new RegExp(si, "g"), Rn = new RegExp(oi, "g");
+function mt(i) {
+  const e = i ? { ...i } : void 0;
+  return (r, ...n) => jn(e, r, ...n);
+}
+function jn(i, e, ...t) {
+  if (!e) return "";
+  let r = String(e).replace(Pn, si).replace(In, oi), n = {}, s = [];
+  t.length === 1 && Array.isArray(t[0]) ? s = t[0] : t.length === 1 && Dn(t[0]) ? n = t[0] : t.length > 0 && (s = t);
+  const o = /* @__PURE__ */ Object.create(null);
+  if (s && s.length)
+    for (let a = 0; a < s.length; a++)
+      o[`$${a + 1}`] = s[a];
+  if (n && Object.keys(n).length)
+    for (const a of Object.keys(n)) o[a] = n[a];
+  if (i && Object.keys(i).length)
+    for (const a of Object.keys(i))
+      typeof o[a] > "u" && (o[a] = i[a]);
+  return r = r.replace(/\{\{\s*([\s\S]*?)\s*\}\}/g, (a, f) => {
+    const u = String(f).trim();
+    if (!u) return "";
+    try {
+      const p = Tn(u, o);
+      return p == null ? "" : String(p);
+    } catch {
+      return "";
+    }
+  }), r.replace(Ln, "{").replace(Rn, "}");
+}
+function Dn(i) {
+  return typeof i == "object" && i !== null && i.constructor === Object;
+}
+const Tn = Mn();
+function Mn() {
+  const i = /* @__PURE__ */ new Set([
+    "eval",
+    "Object",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Date",
+    "Math",
+    "JSON",
+    "undefined",
+    "null",
+    "true",
+    "false",
+    "NaN",
+    "Infinity",
+    "isNaN",
+    "isFinite",
+    "parseInt",
+    "parseFloat"
+  ]), e = new Function(
+    "__expr__",
+    "ctx",
+    `
+    try {
+      with (ctx) {
+        return (eval(__expr__));
+      }
+    } catch (e) {
+      throw e;
+    }
+  `
+  );
+  return (t, r) => {
+    const n = new Proxy(r, {
+      has: (s, o) => typeof o == "symbol" ? o in s : !(typeof o == "string" && (i.has(o) || o === "__expr__")),
+      get: (s, o) => {
+        if (o in s)
+          return s[o];
+      }
+    });
+    return e(t, n);
+  };
+}
+function ai(i) {
+  return i.charAt(0).toLowerCase() + i.slice(1);
+}
+function te(i) {
+  return ai(i).replace(/_/g, "-").replace(/.[A-Z]+/g, (e) => e[0] + "-" + e.slice(1).toLowerCase());
+}
+function ms(i) {
+  return ai(i).replace(/-/g, "_").replace(/.[A-Z]+/g, (e) => e[0] + "_" + e.slice(1).toLowerCase());
+}
+function H(i, e) {
+  let t = i[0] ?? "";
+  for (let r = 0; r < e.length; r++)
+    t += String(e[r]) + (i[r + 1] ?? "");
+  return t;
+}
+class Nn {
+  constructor(e, t) {
+    this.languages = /* @__PURE__ */ new Map(), this.currentLanguage = "en", this.missingKeys = /* @__PURE__ */ new Map(), this.usedKeys = /* @__PURE__ */ new Set();
+    const r = t?.language || "en";
+    this.currentLanguage = r, this.interpolate = mt(t?.globals), e && Object.keys(e).length && this.setLanguageData(r, e);
+  }
+  setGlobals(e) {
+    return this.interpolate = mt(e), this;
+  }
+  set(e, t) {
+    const r = this.currentLanguage, n = this.ensureLanguageMap(r);
+    if (typeof e == "string" && typeof t == "string")
+      n.set(e, t);
+    else if (typeof e == "object") {
+      const s = this.toStringRecord(e);
+      for (const [o, a] of Object.entries(s))
+        n.set(o, a);
+    }
+    return this;
+  }
+  setLanguageData(e, t) {
+    e = te(e).toLowerCase();
+    const r = this.ensureLanguageMap(e), n = this.toStringRecord(t);
+    for (const [s, o] of Object.entries(n))
+      r.set(s, o);
+    return this;
+  }
+  setLanguage(e) {
+    return e = te(e).toLowerCase(), this.currentLanguage = e, this;
+  }
+  getLanguage() {
+    return this.currentLanguage;
+  }
+  hasLanguage(e) {
+    e = te(e).toLowerCase();
+    const t = this.languages.get(e);
+    return t && Object.keys(t).length > 0;
+  }
+  toStringRecord(e, t) {
+    const r = {};
+    for (const [n, s] of Object.entries(e)) {
+      const o = t ? `${t}.${n}` : n;
+      if (s && typeof s == "object" && !Array.isArray(s)) {
+        const a = this.toStringRecord(s, o);
+        for (const [f, u] of Object.entries(a))
+          r[f] = String(u);
+      } else
+        r[o] = String(s);
+    }
+    return r;
+  }
+  has(e) {
+    const t = this.resolveLanguageOrder(this.currentLanguage);
+    for (const r of t)
+      if (this.languages.get(r)?.has(e)) return !0;
+    return !1;
+  }
+  get(e) {
+    this.recordUsedKey(e);
+    const t = this.resolveLanguageOrder(this.currentLanguage), r = [];
+    for (const n of t) {
+      const o = this.languages.get(n)?.get(e);
+      if (typeof o < "u")
+        return r.length && this.recordMissing(e, r), o;
+      r.push(n);
+    }
+    r.length && this.recordMissing(e, r);
+  }
+  translate(e, ...t) {
+    if (!e)
+      return "";
+    if (this.currentLanguage === "qqx")
+      return `⧼${e}⧽`;
+    const r = this.get(e);
+    return typeof r > "u" ? this.interpolate(e, ...t) : this.interpolate(r, ...t);
+  }
+  $(...e) {
+    if (Array.isArray(e[0]) && e[0]?.raw) {
+      const n = e[0], s = e.slice(1), o = H(n, s);
+      return this.translate(o);
+    }
+    const r = e;
+    return (n, ...s) => {
+      const o = H(n, s);
+      return this.translate(o, ...r);
+    };
+  }
+  /**
+   * [payload as template] Return the raw message without interpolation
+   * @example
+   * ```
+   * i18n.rawMsg('Hello, {{ name }}')
+   * // good:    "你好，{{ name }}"
+   * // missing: "Hello, {{ name }}"
+   * ```
+   */
+  translateRaw(e) {
+    return e ? this.currentLanguage === "qqx" ? `⧼${e}⧽` : this.get(e) ?? e : "";
+  }
+  $raw(...e) {
+    if (Array.isArray(e[0]) && e[0]?.raw) {
+      const r = e[0], n = e.slice(1), s = H(r, n);
+      return this.translateRaw(s);
+    }
+    return (r, ...n) => {
+      const s = H(r, n);
+      return this.translateRaw(s);
+    };
+  }
+  message(e, ...t) {
+    if (!e)
+      return "";
+    if (this.currentLanguage === "qqx")
+      return `⧼${e}⧽`;
+    const r = this.get(e);
+    return typeof r > "u" ? `(${e})` : this.interpolate(r, ...t);
+  }
+  $$(...e) {
+    if (Array.isArray(e[0]) && e[0]?.raw) {
+      const n = e[0], s = e.slice(1), o = H(n, s);
+      return this.message(o);
+    }
+    const r = e;
+    return (n, ...s) => {
+      const o = H(n, s);
+      return this.message(o, ...r);
+    };
+  }
+  /**
+   * [payload as key] Return the raw message without interpolation
+   * @example
+   * ```
+   * i18n.rawMsg('greeting')
+   * // good:    "你好，{{ name }}"
+   * // missing: "(greeting)"
+   * ```
+   */
+  messageRaw(e) {
+    return e ? this.currentLanguage === "qqx" ? `⧼${e}⧽` : this.get(e) ?? `(${e})` : "";
+  }
+  $$raw(...e) {
+    if (Array.isArray(e[0]) && e[0].raw) {
+      const r = e[0], n = e.slice(1), s = H(r, n);
+      return this.messageRaw(s);
+    }
+    return (r, ...n) => {
+      const s = H(r, n);
+      return this.messageRaw(s);
+    };
+  }
+  getAvailableLanguages() {
+    return Array.from(this.languages.keys());
+  }
+  ensureLanguageMap(e) {
+    let t = this.languages.get(e);
+    return t || (t = /* @__PURE__ */ new Map(), this.languages.set(e, t)), t;
+  }
+  resolveLanguageOrder(e) {
+    const t = e;
+    return t === "en" ? ["en"] : [t, "en"];
+  }
+  /**
+   * 获取缺失键报告：
+   * { foo: ['zh', 'zh-hans', 'en'] }
+   */
+  getMissingReport() {
+    return Object.fromEntries(this.missingKeys.entries());
+  }
+  /**
+   * 清空缺失键记录
+   */
+  clearMissingReport() {
+    this.missingKeys.clear();
+  }
+  recordMissing(e, t) {
+    if (!t.length) return;
+    const r = this.missingKeys.get(e) || [];
+    for (const n of t)
+      r.includes(n) || r.push(n);
+    this.missingKeys.set(e, r);
+  }
+  recordUsedKey(e) {
+    this.usedKeys.add(e);
+  }
+  getUsedKeys() {
+    return Array.from(this.usedKeys);
+  }
+  generateBlankKeyRecord() {
+    const e = {};
+    for (const t of this.getUsedKeys())
+      e[t] = "";
+    return e;
+  }
+}
+var Bn = Object.create, it = Object.defineProperty, Un = Object.getOwnPropertyDescriptor, ci = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), li = (i) => {
+  throw TypeError(i);
+}, Fn = (i, e, t) => e in i ? it(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, zn = (i, e) => it(i, "name", { value: e, configurable: !0 }), Kn = (i) => [, , , Bn(i?.[ci("metadata")] ?? null)], qn = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], hi = (i) => i !== void 0 && typeof i != "function" ? li("Function expected") : i, Hn = (i, e, t, r, n) => ({ kind: qn[i], name: e, metadata: r, addInitializer: (s) => t._ ? li("Already initialized") : n.push(hi(s || null)) }), Wn = (i, e) => Fn(e, ci("metadata"), i[3]), Gn = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, Vn = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && Un(n, t));
+  zn(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = Hn(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, hi(o) && (n = o);
+  return Wn(i, n), g && it(n, t, g), p ? u ^ 4 ? s : g : n;
+}, ui, rt, fi;
+const yt = new $(
+  $.object({
+    manifest_version: $.const(1).required(),
+    base_language: $.string().required(),
+    last_modified: $.string().required(),
+    languages: $.dict(
+      $.object({
+        file: $.string().required(),
+        fallback: $.string(),
+        iso_name: $.string(),
+        endonym: $.string(),
+        data: $.transform(
+          $.dict($.any()).default({}),
+          (i) => Object.keys(i).length > 0 ? i : void 0
+        )
+      })
+    ).required()
+  })
+);
+ui = [F(["wiki", "preferences"]), Gt(
+  $.object({
+    "i18n.index_url": $.string().description("I18n index URL (DO NOT CHANGE THIS) ").default(
+      tt.I18N_INDEX_URL
+    )
+  }).description("").extra("category", "general")
+)];
+class ye extends (fi = z) {
+  constructor(e) {
+    super(e, "i18n", !1), this.ctx = e, this.logger = void 0, this._indexUrl = void 0, this._indexCache = null, this.manager = void 0, this.i18nIndexDB = void 0, this.i18nDataDB = void 0, this.$ = void 0, this.$raw = void 0, this.$$ = void 0, this.$$raw = void 0, this.logger = this.ctx.logger("I18nService"), this.manager = new Nn(
+      {},
+      {
+        language: "",
+        globals: {
+          userName: this.ctx.wiki.userInfo.name || "",
+          userId: this.ctx.wiki.userInfo.id || 0,
+          siteName: this.ctx.wiki.siteInfo.general.sitename || ""
+        }
+      }
+    ), this.i18nIndexDB = e.storage.createDatabase(
+      "i18n-index",
+      1e3 * 60 * 60 * 24 * 3,
+      // 3 days
+      this.ctx.version,
+      "indexedDB"
+    ), this.i18nDataDB = e.storage.createDatabase(
+      "i18n-data",
+      1e3 * 60 * 60 * 24 * 3,
+      // 3 days
+      this.ctx.version,
+      "indexedDB"
+    ), this.$ = this.manager.$.bind(this.manager), this.$raw = this.manager.$raw.bind(this.manager), this.$$ = this.manager.$$.bind(this.manager), this.$$raw = this.manager.$$raw.bind(this.manager);
+  }
+  async start() {
+    this.ctx.preferences.registerCustomConfig(
+      "language",
+      $.object({
+        language: $.union([
+          "@user",
+          "@site",
+          $.string().description("Custom language code")
+        ]).description("UI language").default("@user")
+      }).description("UI language")
+    ), this.ctx.on("clear-cache", this.onClearCache.bind(this));
+    const e = this._indexUrl = await this.ctx.preferences.get("i18n.index_url") || "";
+    if (!e) {
+      this.logger.error("I18n index URL is not set"), this.setupShortcuts();
+      return;
+    }
+    let t = null;
+    try {
+      t = await this.getI18nIndex(e);
+    } catch (s) {
+      this.logger.error("Failed to fetch i18n index", s), this.setupShortcuts();
+      return;
+    }
+    this._indexCache = t, Object.entries(t.languages).forEach(([s, o]) => {
+      o.data && Object.keys(o.data).length > 0 && this.manager.setLanguageData(s, o.data);
+    });
+    const r = await this.ctx.preferences.get("language"), n = this.normalizeLanguageCode(r);
+    this.logger.debug("Settings", { prefer: r, normalized: n });
+    try {
+      await this.switchLanguage(n), this.logger.info(`Initialized for language: ${this.language}`);
+    } catch (s) {
+      this.logger.error("Failed to fetch i18n index", s), this.manager.setLanguage("en");
+    }
+    this.ctx.preferences.registerCustomConfig(
+      "language",
+      $.object({
+        language: $.union([
+          $.const("@user").description(this.$`Same as your personal language`),
+          $.const("@site").description(this.$`Same as the site language`),
+          ...this.getAvailableLanguageCodes().map(
+            ({ code: s, endonym: o, iso_name: a }) => $.const(s).description(o || a || s)
+          )
+        ]).default("@user")
+      }).description(this.$`InPageEdit UI language`)
+    ), this.setupShortcuts(), this.ctx.on("preferences/changed", async ({ changes: s }) => {
+      if (!("language" in s)) return;
+      const o = this.normalizeLanguageCode(await this.ctx.preferences.get("language"));
+      o && o !== this.language && await this.switchLanguage(o);
+    });
+  }
+  setupShortcuts() {
+    if (!this.manager) throw new Error("I18nManager is not initialized");
+    this.ctx.set("$", this.manager.$.bind(this.manager)), this.ctx.set("$raw", this.manager.$raw.bind(this.manager)), this.ctx.set("$$", this.manager.$$.bind(this.manager)), this.ctx.set("$$raw", this.manager.$$raw.bind(this.manager));
+  }
+  normalizeLanguageCode(e) {
+    return !e || typeof e != "string" ? "en" : (e === "@user" && (e = this.ctx.wiki.userInfo.options.language || "en"), e === "@site" && (e = this.ctx.wiki.siteInfo.general.lang || "en"), te(String(e)).toLowerCase());
+  }
+  get language() {
+    return this.manager.getLanguage();
+  }
+  /**
+   * 主动设置偏好值（会触发 preferences/changed，从而热切换）
+   */
+  async setLanguagePreference(e) {
+    await this.ctx.preferences.set("language", e);
+  }
+  /**
+   * 直接切换到具体语言（不修改偏好值）
+   */
+  async switchLanguage(e) {
+    const t = this.normalizeLanguageCode(e);
+    await this.ensureLanguageLoaded(t), this.manager.setLanguage(t), this.ctx.emit("i18n/changed", { ctx: this.ctx, language: t });
+  }
+  /**
+   * 为指定语言注册（或合并）消息。
+   * - 推荐加命名空间避免冲突：{ myPlugin: { key: 'value' } }
+   * - 若 language 为当前语言，将立即可用；必要时你可以手动触发 UI 刷新或监听 i18n/changed。
+   */
+  async registerMessages(e, t, r) {
+    const n = r?.namespace ? { [r.namespace]: t } : t;
+    this.manager.setLanguageData(e, n), e === this.language && this.ctx.emit("i18n/changed", { ctx: this.ctx, language: this.language });
+  }
+  /**
+   * 列出可用语言与文件（来源于 index.json）
+   */
+  getAvailableLanguageCodes() {
+    if (!this._indexCache) throw new Error("I18n index is not loaded");
+    return Object.entries(this._indexCache.languages).filter(([e, t]) => !t.fallback).reduce(
+      (e, [t, r]) => (e.push({ code: t, ...r }), e),
+      []
+    );
+  }
+  findLanguageMeta(e, t) {
+    const r = te(String(t)).toLowerCase(), n = e.languages[r];
+    if (n)
+      return {
+        code: r,
+        ...n
+      };
+    {
+      const s = e.languages.en;
+      if (s)
+        return {
+          code: "en",
+          ...s
+        };
+    }
+  }
+  async getI18nIndex(e, t = !1) {
+    if (!t) {
+      const n = await this.i18nIndexDB.get(e);
+      if (n)
+        try {
+          return yt(n);
+        } catch (s) {
+          this.logger.error("Failed to parse cached i18n index", s), this.i18nIndexDB.delete(e);
+        }
+    }
+    const r = await this.fetchI18nIndex(e);
+    return this.i18nIndexDB.set(e, r), r;
+  }
+  async fetchI18nIndex(e) {
+    const t = await fetch(e).then((r) => r.json());
+    return yt(t);
+  }
+  async ensureLanguageLoaded(e) {
+    if (!this.manager || !this._indexCache) throw new Error("I18nManager is not initialized");
+    if (this.manager.hasLanguage(e))
+      return this.logger.debug("Language already loaded", e);
+    const t = await this.getLanguageData(e);
+    this.manager.setLanguageData(e, t), this.logger.debug("Language data ensured", e, t);
+  }
+  async getLanguageData(e, t = !1) {
+    if (!this._indexCache) throw new Error("I18n index is not loaded");
+    const r = this.findLanguageMeta(this._indexCache, e);
+    if (!r) return {};
+    const n = `${this._indexUrl}#${r.file}`;
+    if (!t) {
+      const o = await this.i18nDataDB.get(n);
+      if (o && Object.keys(o).length > 0)
+        return this.logger.debug("Using cached language data", e, o), o;
+    }
+    const s = r.data || await fetch(new URL(r.file, this._indexUrl).toString()).then((o) => o.json());
+    return this.i18nDataDB.set(n, s), this.logger.debug("Language data fetched", e, r.file, s), s;
+  }
+  /**
+   * 获取缺失键报告，形如：
+   * { foo: ['zh', 'zh-hans', 'en'] }
+   */
+  getMissingReport() {
+    return this.manager.getMissingReport();
+  }
+  /**
+   * 清空缺失键记录
+   */
+  clearMissingReport() {
+    this.manager.clearMissingReport();
+  }
+  async onClearCache() {
+    await this.i18nIndexDB.clear(), await this.i18nDataDB.clear();
+  }
+}
+rt = Kn(fi);
+ye = Vn(rt, 0, "I18nService", ui, ye);
+Gn(rt, 1, ye);
+const Jn = new TextEncoder();
+function Yn(i) {
+  if (typeof i == "string") return Jn.encode(i);
+  if (i instanceof ArrayBuffer) return new Uint8Array(i);
+  if (ArrayBuffer.isView(i))
+    return new Uint8Array(i.buffer, i.byteOffset, i.byteLength);
+  throw new TypeError("Unsupported input type");
+}
+function Xn(i) {
+  let e = "";
+  for (let t = 0; t < i.length; t++) {
+    const r = i[t].toString(16).padStart(2, "0");
+    e += r;
+  }
+  return e;
+}
+function Qn(i, e) {
+  return i << e | i >>> 32 - e;
+}
+const Zn = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+], es = new Array(64).fill(0).map((i, e) => Math.floor(Math.abs(Math.sin(e + 1)) * 2 ** 32) >>> 0);
+function ts(i) {
+  const e = Yn(i), t = (56 - (e.length + 1) % 64 + 64) % 64, r = e.length + 1 + t + 8, n = new Uint8Array(r);
+  n.set(e, 0), n[e.length] = 128;
+  const s = e.length, o = s << 3 >>> 0, a = s >>> 29 >>> 0, f = new DataView(n.buffer);
+  f.setUint32(r - 8, o, !0), f.setUint32(r - 4, a, !0);
+  let u = 1732584193, p = 4023233417, y = 2562383102, _ = 271733878;
+  const g = new Uint32Array(16);
+  for (let C = 0; C < n.length; C += 64) {
+    for (let m = 0; m < 16; m++) g[m] = f.getUint32(C + m * 4, !0);
+    let l = u, c = p, h = y, d = _;
+    for (let m = 0; m < 64; m++) {
+      let v, x;
+      m < 16 ? (v = c & h | ~c & d, x = m) : m < 32 ? (v = d & c | ~d & h, x = (5 * m + 1) % 16) : m < 48 ? (v = c ^ h ^ d, x = (3 * m + 5) % 16) : (v = h ^ (c | ~d), x = 7 * m % 16);
+      const A = d, ke = l + v + es[m] + g[x] >>> 0;
+      d = h, h = c, c = c + Qn(ke, Zn[m]) >>> 0, l = A;
+    }
+    u = u + l >>> 0, p = p + c >>> 0, y = y + h >>> 0, _ = _ + d >>> 0;
+  }
+  const w = new Uint8Array(16), O = new DataView(w.buffer);
+  return O.setUint32(0, u, !0), O.setUint32(4, p, !0), O.setUint32(8, y, !0), O.setUint32(12, _, !0), w;
+}
+var is = Object.create, nt = Object.defineProperty, rs = Object.getOwnPropertyDescriptor, di = (i, e) => (e = Symbol[i]) ? e : /* @__PURE__ */ Symbol.for("Symbol." + i), pi = (i) => {
+  throw TypeError(i);
+}, ns = (i, e, t) => e in i ? nt(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, ss = (i, e) => nt(i, "name", { value: e, configurable: !0 }), os = (i) => [, , , is(i?.[di("metadata")] ?? null)], as = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], gi = (i) => i !== void 0 && typeof i != "function" ? pi("Function expected") : i, cs = (i, e, t, r, n) => ({ kind: as[i], name: e, metadata: r, addInitializer: (s) => t._ ? pi("Already initialized") : n.push(gi(s || null)) }), ls = (i, e) => ns(e, di("metadata"), i[3]), hs = (i, e, t, r) => {
+  for (var n = 0, s = i[e >> 1], o = s && s.length; n < o; n++) s[n].call(t);
+  return r;
+}, us = (i, e, t, r, n, s) => {
+  var o, a, f, u = e & 7, p = !1, y = 0, _ = i[y] || (i[y] = []), g = u && (n = n.prototype, u < 5 && (u > 3 || !p) && rs(n, t));
+  ss(n, t);
+  for (var w = r.length - 1; w >= 0; w--)
+    f = cs(u, t, a = {}, i[3], _), o = (0, r[w])(n, f), a._ = 1, gi(o) && (n = o);
+  return ls(i, n), g && nt(n, t, g), p ? u ^ 4 ? s : g : n;
+}, mi, st, yi;
+mi = [F(["wiki", "wikiTitle", "wikiPage", "apiService"])];
+class we extends (yi = z) {
+  constructor(e) {
+    super(e, "wikiFile", !0), this.ctx = e;
+  }
+  get fileRepos() {
+    return this.ctx.wiki.fileRepos || [];
+  }
+  get defaultFileRepo() {
+    return this.fileRepos[0];
+  }
+  get localFileRepo() {
+    return this.fileRepos.find((e) => e.local);
+  }
+  get writableFileRepo() {
+    return this.fileRepos.find((e) => e.canUpload);
+  }
+  getFileName(e) {
+    if (e = this.ctx.wikiTitle.newTitle(e, 6), ![6, -2].includes(e.getNamespaceId()))
+      throw new Error("Not a file title");
+    return e.getMainDBKey().split("/").pop() || "";
+  }
+  getHashPath(e, t = 2) {
+    const r = this.getFileName(e), n = Xn(ts(r));
+    let s = [];
+    for (let o = 1; o <= t; o++)
+      s.push(n.slice(0, o));
+    return s.push(r), s.join("/");
+  }
+  getFileUrl(e, t) {
+    if (t = t || this.defaultFileRepo, !t)
+      throw new Error("No file repository found");
+    const r = this.getHashPath(e);
+    return new URL(`${t.rootUrl}/${r}`, location.origin).toString();
+  }
+  async upload(e, t) {
+    if (t = t || this.writableFileRepo, !t?.canUpload)
+      throw new Error("No writable file repository found");
+    if (!e.file && !e.url && !e.chunk && !e.filekey)
+      throw new Error('At least one of "file", "url", "chunk", or "filekey" is required');
+    return this.ctx.apiService.getClientByFileRepo(t).postWithToken(
+      "csrf",
+      {
+        action: "upload",
+        ...e
+      },
+      { fexiosOptions: { timeout: 0 } }
+    );
+  }
+}
+st = os(yi);
+we = us(st, 0, "WikiFileService", mi, we);
+hs(st, 1, we);
+class be extends N {
+  constructor(e) {
+    super({
+      name: "InPageEdit"
+    }), this.version = "0.16.0", this.Endpoints = tt, this.schema = $, this.config = $i(be.DEFAULT_CONFIG, e), this.logger = or({
+      name: "IPE",
+      color: "#33aaff",
+      level: this.config.logLevel
+    }), this.#e();
+  }
+  static {
+    this.DEFAULT_CONFIG = {
+      apiConfigs: {},
+      legacyPreferences: {},
+      logLevel: Ot.info,
+      storageNamespace: "InPageEdit",
+      autoloadStyles: !0,
+      autoInstallCorePlugins: !0
+    };
+  }
+  async #e() {
+    await this.#i(), this.config.autoInstallCorePlugins && this.#r(), this.#n();
+  }
+  async #i() {
+    this.plugin(ye), this.plugin(cr, this.config.apiConfigs), this.plugin(fe), this.plugin(br), this.plugin(Hr), this.plugin(me), this.plugin(an, { dbName: this.config.storageNamespace }), this.plugin(ge), this.plugin(we), this.plugin(pe), this.plugin(wn), this.plugin(Qe), this.#t([
+      "i18n",
+      "$",
+      "$$",
+      "api",
+      "currentPage",
+      "resourceLoader",
+      "modal",
+      "preferences",
+      "storage",
+      "theme",
+      "wikiPage",
+      "wikiTitle",
+      // WikiMetadataService
+      "wiki",
+      "getUrl",
+      "getSciprtUrl",
+      "getMainpageUrl"
+    ]);
+  }
+  #t(e) {
+    if (!Array.isArray(e) || e.length === 0) return this;
+    for (const t of e) {
+      const r = this[be.internal][t];
+      r?.type === "service" && (r.builtin = !0);
+    }
+    return this;
+  }
+  // TODO: 这里不应该硬编码，暂时先这样
+  async #r() {
+    [
+      import("./index-NWWeW3tX.js").then(({ PluginAnalytics: t }) => t),
+      import("./index-BPTMltVf.js").then(
+        ({ PluginInArticleLinks: t }) => t
+      ),
+      import("./index-bQ0CVu3l.js").then(({ PluginPluginStore: t }) => t),
+      import("./index-BYlcHc-O.js").then(
+        ({ PluginPreferencesUI: t }) => t
+      ),
+      import("./index-B32tFyLB.js").then(({ PluginQuickEdit: t }) => t),
+      import("./index-CVCy0wPP.js").then(({ PluginQuickMove: t }) => t),
+      import("./index-DZa9mxN4.js").then(
+        ({ PluginQuickPreview: t }) => t
+      ),
+      import("./index-Dm2vgYkZ.js").then(({ PluginQuickDiff: t }) => t),
+      import("./index-1tsXE6ax.js").then(
+        ({ PluginQuickRedirect: t }) => t
+      ),
+      import("./index-CAtPo7xJ.js").then(({ PluginQuickUpload: t }) => t),
+      import("./index-ygc4AMy4.js").then(({ PluginQuickUsage: t }) => t),
+      import("./index-C4qm_X_A.js").then(({ PluginToolbox: t }) => t)
+    ].forEach(async (t) => {
+      this.plugin(await t);
+    });
+  }
+  // TODO: 应该抽象到 PluginTheme 中去，暂时先硬编码
+  async #n() {
+    this.inject(["resourceLoader"], (e) => {
+      this.config.autoloadStyles && e.resourceLoader.loadStyle(import.meta.resolve("./style.css"));
+    });
+  }
+  async withInject(e) {
+    const { promise: t, resolve: r } = wt();
+    return this.inject(e, (n) => {
+      r(n);
+    }), t;
+  }
+}
+export {
+  Ot as $,
+  cr as A,
+  Pe as C,
+  tt as E,
+  Yi as F,
+  be as I,
+  ct as M,
+  de as N,
+  Ge as P,
+  Gt as R,
+  $ as S,
+  ge as T,
+  we as W,
+  F as a,
+  Et as b,
+  Ji as c,
+  z as d,
+  Vi as e,
+  or as f,
+  gs as g,
+  ps as h,
+  ms as i,
+  an as j,
+  fe as k,
+  R as l,
+  ze as m,
+  Hr as n,
+  me as o,
+  te as p,
+  ft as q,
+  br as r,
+  b as s,
+  pe as t,
+  wn as u,
+  Qe as v
+};
+//# sourceMappingURL=index-QnWieXQc.js.map