@inpageedit/core 0.14.1 → 0.14.3

package/dist/Preferences-C10tZMl1.js

@@ -0,0 +1,2701 @@
+const He = () => {
+  let e, t;
+  return { promise: new Promise((n, s) => {
+    e = n, t = s;
+  }), resolve: e, reject: t };
+};
+Promise.withResolvers || (Promise.withResolvers = He);
+var Fe = Object.defineProperty, x = (e, t) => Fe(e, "name", { value: t, configurable: !0 });
+function We() {
+}
+x(We, "noop");
+function j(e) {
+  return e == null;
+}
+x(j, "isNullable");
+function Ke(e) {
+  return !j(e);
+}
+x(Ke, "isNonNullable");
+function te(e) {
+  return e && typeof e == "object" && !Array.isArray(e);
+}
+x(te, "isPlainObject");
+function Ae(e, t) {
+  return Object.fromEntries(Object.entries(e).filter(([r, n]) => t(r, n)));
+}
+x(Ae, "filterKeys");
+function q(e, t) {
+  return Object.fromEntries(Object.entries(e).map(([r, n]) => [r, t(n, r)]));
+}
+x(q, "mapValues");
+function ve(e, t, r) {
+  if (!t) return { ...e };
+  const n = {};
+  for (const s of t)
+    (r || e[s] !== void 0) && (n[s] = e[s]);
+  return n;
+}
+x(ve, "pick");
+function ze(e, t) {
+  if (!t) return { ...e };
+  const r = { ...e };
+  for (const n of t)
+    Reflect.deleteProperty(r, n);
+  return r;
+}
+x(ze, "omit");
+function P(e, t, r) {
+  return Object.defineProperty(e, t, { writable: !0, value: r, enumerable: !1 });
+}
+x(P, "defineProperty");
+function Ye(e, t) {
+  return t.every((r) => e.includes(r));
+}
+x(Ye, "contain");
+function Ge(e, t) {
+  return e.filter((r) => t.includes(r));
+}
+x(Ge, "intersection");
+function Je(e, t) {
+  return e.filter((r) => !t.includes(r));
+}
+x(Je, "difference");
+function Ve(e, t) {
+  return Array.from(/* @__PURE__ */ new Set([...e, ...t]));
+}
+x(Ve, "union");
+function Qe(e) {
+  return [...new Set(e)];
+}
+x(Qe, "deduplicate");
+function M(e, t) {
+  const r = e?.indexOf(t);
+  return r >= 0 ? (e.splice(r, 1), !0) : !1;
+}
+x(M, "remove");
+function Xe(e) {
+  return Array.isArray(e) ? e : j(e) ? [] : [e];
+}
+x(Xe, "makeArray");
+function F(e, t) {
+  return arguments.length === 1 ? (r) => F(e, r) : e in globalThis && t instanceof globalThis[e] || Object.prototype.toString.call(t).slice(8, -1) === e;
+}
+x(F, "is");
+function Z(e) {
+  return F("ArrayBuffer", e) || F("SharedArrayBuffer", e);
+}
+x(Z, "isArrayBufferLike");
+function _e(e) {
+  return Z(e) || ArrayBuffer.isView(e);
+}
+x(_e, "isArrayBufferSource");
+var N;
+((e) => {
+  e.is = Z, e.isSource = _e;
+  function t(o) {
+    return ArrayBuffer.isView(o) ? o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength) : o;
+  }
+  e.fromSource = t, x(t, "fromSource");
+  function r(o) {
+    if (typeof Buffer < "u")
+      return Buffer.from(o).toString("base64");
+    let u = "";
+    const l = new Uint8Array(o);
+    for (let h = 0; h < l.byteLength; h++)
+      u += String.fromCharCode(l[h]);
+    return btoa(u);
+  }
+  e.toBase64 = r, x(r, "toBase64");
+  function n(o) {
+    return typeof Buffer < "u" ? t(Buffer.from(o, "base64")) : Uint8Array.from(atob(o), (u) => u.charCodeAt(0));
+  }
+  e.fromBase64 = n, x(n, "fromBase64");
+  function s(o) {
+    return typeof Buffer < "u" ? Buffer.from(o).toString("hex") : Array.from(new Uint8Array(o), (u) => u.toString(16).padStart(2, "0")).join("");
+  }
+  e.toHex = s, x(s, "toHex");
+  function i(o) {
+    if (typeof Buffer < "u") return t(Buffer.from(o, "hex"));
+    const u = o.length % 2 === 0 ? o : o.slice(0, o.length - 1), l = [];
+    for (let h = 0; h < u.length; h += 2)
+      l.push(parseInt(`${u[h]}${u[h + 1]}`, 16));
+    return Uint8Array.from(l).buffer;
+  }
+  e.fromHex = i, x(i, "fromHex");
+})(N || (N = {}));
+N.fromBase64;
+N.toBase64;
+N.fromHex;
+N.toHex;
+function ne(e, t = /* @__PURE__ */ new Map()) {
+  if (!e || typeof e != "object") return e;
+  if (F("Date", e)) return new Date(e.valueOf());
+  if (F("RegExp", e)) return new RegExp(e.source, e.flags);
+  if (Z(e)) return e.slice(0);
+  if (ArrayBuffer.isView(e)) return e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength);
+  const r = t.get(e);
+  if (r) return r;
+  if (Array.isArray(e)) {
+    const s = [];
+    return t.set(e, s), e.forEach((i, o) => {
+      s[o] = Reflect.apply(ne, null, [i, t]);
+    }), s;
+  }
+  const n = Object.create(Object.getPrototypeOf(e));
+  t.set(e, n);
+  for (const s of Reflect.ownKeys(e)) {
+    const i = { ...Reflect.getOwnPropertyDescriptor(e, s) };
+    "value" in i && (i.value = Reflect.apply(ne, null, [i.value, t])), Reflect.defineProperty(n, s, i);
+  }
+  return n;
+}
+x(ne, "clone");
+function K(e, t, r) {
+  if (e === t || !r && j(e) && j(t)) return !0;
+  if (typeof e != typeof t || typeof e != "object" || !e || !t) return !1;
+  function n(s, i) {
+    return s(e) ? s(t) ? i(e, t) : !1 : s(t) ? !1 : void 0;
+  }
+  return x(n, "check"), n(Array.isArray, (s, i) => s.length === i.length && s.every((o, u) => K(o, i[u]))) ?? n(F("Date"), (s, i) => s.valueOf() === i.valueOf()) ?? n(F("RegExp"), (s, i) => s.source === i.source && s.flags === i.flags) ?? n(Z, (s, i) => {
+    if (s.byteLength !== i.byteLength) return !1;
+    const o = new Uint8Array(s), u = new Uint8Array(i);
+    for (let l = 0; l < o.length; l++)
+      if (o[l] !== u[l]) return !1;
+    return !0;
+  }) ?? Object.keys({ ...e, ...t }).every((s) => K(e[s], t[s], r));
+}
+x(K, "deepEqual");
+function Ze(e) {
+  return e.charAt(0).toUpperCase() + e.slice(1);
+}
+x(Ze, "capitalize");
+function et(e) {
+  return e.charAt(0).toLowerCase() + e.slice(1);
+}
+x(et, "uncapitalize");
+function tt(e) {
+  return e.replace(/[_-][a-z]/g, (t) => t.slice(1).toUpperCase());
+}
+x(tt, "camelCase");
+function de(e, t, r) {
+  const n = [];
+  let s = 0;
+  for (let i = 0; i < e.length; i++) {
+    const o = e.charCodeAt(i);
+    if (o >= 65 && o <= 90) {
+      if (s === 1) {
+        const u = e.charCodeAt(i + 1);
+        u >= 97 && u <= 122 && n.push(r), n.push(o + 32);
+      } else
+        s !== 0 && n.push(r), n.push(o + 32);
+      s = 1;
+    } else o >= 97 && o <= 122 ? (n.push(o), s = 2) : t.includes(o) ? (s !== 0 && n.push(r), s = 0) : n.push(o);
+  }
+  return String.fromCharCode(...n);
+}
+x(de, "tokenize");
+function rt(e) {
+  return de(e, [45, 95], 45);
+}
+x(rt, "paramCase");
+function nt(e) {
+  return de(e, [45, 95], 95);
+}
+x(nt, "snakeCase");
+function it(e) {
+  return typeof e != "string" ? `[${e.toString()}]` : /^[a-z_$][\w$]*$/i.test(e) ? `.${e}` : `[${JSON.stringify(e)}]`;
+}
+x(it, "formatProperty");
+function je(e) {
+  return e.replace(/\/$/, "");
+}
+x(je, "trimSlash");
+function st(e) {
+  return e.startsWith("/") || (e = "/" + e), je(e);
+}
+x(st, "sanitize");
+var Oe;
+((e) => {
+  e.millisecond = 1, e.second = 1e3, e.minute = e.second * 60, e.hour = e.minute * 60, e.day = e.hour * 24, e.week = e.day * 7;
+  let t = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function r(g) {
+    t = g;
+  }
+  e.setTimezoneOffset = r, x(r, "setTimezoneOffset");
+  function n() {
+    return t;
+  }
+  e.getTimezoneOffset = n, x(n, "getTimezoneOffset");
+  function s(g = /* @__PURE__ */ new Date(), w) {
+    return typeof g == "number" && (g = new Date(g)), w === void 0 && (w = t), Math.floor((g.valueOf() / e.minute - w) / 1440);
+  }
+  e.getDateNumber = s, x(s, "getDateNumber");
+  function i(g, w) {
+    const _ = new Date(g * e.day);
+    return w === void 0 && (w = t), new Date(+_ + w * e.minute);
+  }
+  e.fromDateNumber = i, x(i, "fromDateNumber");
+  const o = /\d+(?:\.\d+)?/.source, u = 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 l(g) {
+    const w = u.exec(g);
+    return w ? (parseFloat(w[1]) * e.week || 0) + (parseFloat(w[2]) * e.day || 0) + (parseFloat(w[3]) * e.hour || 0) + (parseFloat(w[4]) * e.minute || 0) + (parseFloat(w[5]) * e.second || 0) : 0;
+  }
+  e.parseTime = l, x(l, "parseTime");
+  function h(g) {
+    const w = l(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();
+  }
+  e.parseDate = h, x(h, "parseDate");
+  function d(g) {
+    const w = Math.abs(g);
+    return w >= e.day - e.hour / 2 ? Math.round(g / e.day) + "d" : w >= e.hour - e.minute / 2 ? Math.round(g / e.hour) + "h" : w >= e.minute - e.second / 2 ? Math.round(g / e.minute) + "m" : w >= e.second ? Math.round(g / e.second) + "s" : g + "ms";
+  }
+  e.format = d, x(d, "format");
+  function R(g, w = 2) {
+    return g.toString().padStart(w, "0");
+  }
+  e.toDigits = R, x(R, "toDigits");
+  function b(g, w = /* @__PURE__ */ new Date()) {
+    return g.replace("yyyy", w.getFullYear().toString()).replace("yy", w.getFullYear().toString().slice(2)).replace("MM", R(w.getMonth() + 1)).replace("dd", R(w.getDate())).replace("hh", R(w.getHours())).replace("mm", R(w.getMinutes())).replace("ss", R(w.getSeconds())).replace("SSS", R(w.getMilliseconds(), 3));
+  }
+  e.template = b, x(b, "template");
+})(Oe || (Oe = {}));
+var ot = Object.defineProperty, k = (e, t) => ot(e, "name", { value: t, configurable: !0 }), m = {
+  // internal symbols
+  shadow: Symbol.for("cordis.shadow"),
+  receiver: Symbol.for("cordis.receiver"),
+  original: Symbol.for("cordis.original"),
+  // context symbols
+  store: Symbol.for("cordis.store"),
+  events: Symbol.for("cordis.events"),
+  static: Symbol.for("cordis.static"),
+  filter: Symbol.for("cordis.filter"),
+  expose: Symbol.for("cordis.expose"),
+  isolate: Symbol.for("cordis.isolate"),
+  internal: Symbol.for("cordis.internal"),
+  intercept: Symbol.for("cordis.intercept"),
+  // service symbols
+  setup: Symbol.for("cordis.setup"),
+  invoke: Symbol.for("cordis.invoke"),
+  extend: Symbol.for("cordis.extend"),
+  tracker: Symbol.for("cordis.tracker"),
+  provide: Symbol.for("cordis.provide"),
+  immediate: Symbol.for("cordis.immediate")
+}, ct = function* () {
+}.constructor, Re = async function* () {
+}.constructor;
+function ye(e) {
+  return !(!e.prototype || e instanceof ct || Re !== Function && e instanceof Re);
+}
+k(ye, "isConstructor");
+function ee(e, t) {
+  const r = e.Config || e.schema;
+  return r && e.schema !== !1 && (t = r(t)), t ?? {};
+}
+k(ee, "resolveConfig");
+function Le(e) {
+  return [Map, Set, Date, Promise].some((t) => e instanceof t);
+}
+k(Le, "isUnproxyable");
+function ge(e, t) {
+  if (e === Object.prototype) return t;
+  const r = Object.create(ge(Object.getPrototypeOf(e), t));
+  for (const n of Reflect.ownKeys(e))
+    Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(e, n));
+  return r;
+}
+k(ge, "joinPrototype");
+function me(e) {
+  return e && (typeof e == "object" || typeof e == "function");
+}
+k(me, "isObject");
+function B(e, t, r) {
+  if (!me(t)) return t;
+  if (Object.hasOwn(t, m.shadow))
+    return Object.getPrototypeOf(t);
+  const n = t[m.tracker];
+  return n ? ae(e, t, n, r) : t;
+}
+k(B, "getTraceable");
+function X(e, t) {
+  return t ? new Proxy(e, {
+    get: /* @__PURE__ */ k((r, n, s) => n in t && n !== "constructor" ? Reflect.get(t, n, s) : Reflect.get(r, n, s), "get"),
+    set: /* @__PURE__ */ k((r, n, s, i) => n in t && n !== "constructor" ? Reflect.set(t, n, s, i) : Reflect.set(r, n, s, i), "set")
+  }) : e;
+}
+k(X, "withProps");
+function ie(e, t, r) {
+  return X(e, Object.defineProperty(/* @__PURE__ */ Object.create(null), t, {
+    value: r,
+    writable: !1
+  }));
+}
+k(ie, "withProp");
+function fe(e, t, r, n) {
+  if (!r) return n;
+  const s = Reflect.getOwnPropertyDescriptor(t, r)?.value;
+  return s ? ie(n, r, e.extend({ [m.shadow]: s })) : n;
+}
+k(fe, "createShadow");
+function Te(e, t, r, n) {
+  return new Proxy(t, {
+    apply: /* @__PURE__ */ k((s, i, o) => (i === r && (i = n), o = o.map((u) => typeof u != "function" || u[m.original] ? u : new Proxy(u, {
+      get: /* @__PURE__ */ k((l, h, d) => {
+        if (h === m.original) return l;
+        const R = Reflect.get(l, h, d);
+        return h === "toString" && R === Function.prototype.toString ? function(...b) {
+          return Reflect.apply(R, this === d ? l : this, b);
+        } : R;
+      }, "get"),
+      apply: /* @__PURE__ */ k((l, h, d) => Reflect.apply(l, B(e, h), d.map((R) => B(e, R))), "apply"),
+      construct: /* @__PURE__ */ k((l, h, d) => Reflect.construct(l, h.map((R) => B(e, R)), d), "construct")
+    })), B(e, Reflect.apply(s, i, o))), "apply")
+  });
+}
+k(Te, "createShadowMethod");
+function ae(e, t, r, n) {
+  e[m.shadow] && (e = Object.getPrototypeOf(e));
+  const s = new Proxy(t, {
+    get: /* @__PURE__ */ k((i, o, u) => {
+      if (o === m.original) return i;
+      if (o === r.property) return e;
+      if (typeof o == "symbol")
+        return Reflect.get(i, o, u);
+      if (r.associate && e[m.internal][`${r.associate}.${o}`])
+        return Reflect.get(e, `${r.associate}.${o}`, ie(e, m.receiver, u));
+      const l = fe(e, i, r.property, u), h = Reflect.get(i, o, l), d = h?.[m.tracker];
+      return d ? ae(e, h, d) : !n && typeof h == "function" ? Te(e, h, u, l) : h;
+    }, "get"),
+    set: /* @__PURE__ */ k((i, o, u, l) => {
+      if (o === m.original || o === r.property) return !1;
+      if (typeof o == "symbol")
+        return Reflect.set(i, o, u, l);
+      if (r.associate && e[m.internal][`${r.associate}.${o}`])
+        return Reflect.set(e, `${r.associate}.${o}`, u, ie(e, m.receiver, l));
+      const h = fe(e, i, r.property, l);
+      return Reflect.set(i, o, u, h);
+    }, "set"),
+    apply: /* @__PURE__ */ k((i, o, u) => be(s, i, o, u), "apply")
+  });
+  return s;
+}
+k(ae, "createTraceable");
+function be(e, t, r, n) {
+  return t[m.invoke] ? t[m.invoke].apply(e, n) : Reflect.apply(t, r, n);
+}
+k(be, "applyTraceable");
+function ue(e, t, r) {
+  const n = /* @__PURE__ */ k(function(...s) {
+    const i = ae(n.ctx, n, r);
+    return be(i, n, this, s);
+  }, "self");
+  return P(n, "name", e), Object.setPrototypeOf(n, t);
+}
+k(ue, "createCallable");
+var at = class z {
+  constructor(t) {
+    this.ctx = t, P(this, m.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(t, r) {
+    let n = t[m.internal][r];
+    for (; n?.type === "alias"; )
+      r = n.name, n = t[m.internal][r];
+    return [r, n];
+  }
+  static checkInject(t, r, n) {
+    if (t = t[m.shadow] ?? t, ["prototype", "then", "registry", "lifecycle"].includes(r) || r[0] === "$" || r[0] === "_" || !t.runtime.plugin || t.bail(t, "internal/inject", r)) return;
+    const s = n.stack.split(`
+`);
+    s.splice(1, 1), n.stack = s.join(`
+`), t.emit(t, "internal/warning", n);
+  }
+  static handler = {
+    get: /* @__PURE__ */ k((t, r, n) => {
+      if (typeof r != "string") return Reflect.get(t, r, n);
+      if (Reflect.has(t, r))
+        return B(n, Reflect.get(t, r, n), !0);
+      const [s, i] = z.resolveInject(t, r), o = new Error(`property ${s} is not registered, declare it as \`inject\` to suppress this warning`);
+      return i ? i.type === "accessor" ? i.get.call(n, n[m.receiver]) : (i.builtin || z.checkInject(n, s, o), n.reflect.get(s)) : (z.checkInject(n, s, o), Reflect.get(t, s, n));
+    }, "get"),
+    set: /* @__PURE__ */ k((t, r, n, s) => {
+      if (typeof r != "string") return Reflect.set(t, r, n, s);
+      const [i, o] = z.resolveInject(t, r);
+      return o ? o.type === "accessor" ? o.set ? o.set.call(s, n, s[m.receiver]) : !1 : (s.reflect.set(i, n), !0) : Reflect.set(t, i, n, s);
+    }, "set"),
+    has: /* @__PURE__ */ k((t, r) => {
+      if (typeof r != "string") return Reflect.has(t, r);
+      if (Reflect.has(t, r)) return !0;
+      const [, n] = z.resolveInject(t, r);
+      return !!n;
+    }, "has")
+  };
+  get(t) {
+    if (this.ctx[m.internal][t]?.type !== "service") return;
+    const n = this.ctx[m.isolate][t], s = this.ctx[m.store][n]?.value;
+    return B(this.ctx, s);
+  }
+  set(t, r) {
+    this.provide(t);
+    const n = this.ctx[m.isolate][t], s = this.ctx[m.store][n]?.value;
+    r ??= void 0;
+    let i = /* @__PURE__ */ k(() => {
+    }, "dispose");
+    if (s === r) return i;
+    if (!j(r) && !j(s))
+      throw new Error(`service ${t} has been registered`);
+    const o = this.ctx;
+    j(r) || (i = o.effect(() => () => {
+      o.set(t, void 0);
+    })), Le(r) && o.emit(o, "internal/warning", new Error(`service ${t} is an unproxyable object, which may lead to unexpected behavior`));
+    const u = Object.create(o);
+    return u[m.filter] = (l) => o[m.isolate][t] === l[m.isolate][t], o.emit(u, "internal/before-service", t, r), o[m.store][n] = { value: r, source: o }, o.emit(u, "internal/service", t, s), i;
+  }
+  provide(t, r, n) {
+    const s = this.ctx.root[m.internal];
+    if (t in s) return;
+    const i = Symbol(t);
+    s[t] = { type: "service", builtin: n }, this.ctx.root[m.isolate][t] = i, me(r) && (this.ctx[m.store][i] = { value: r, source: null }, P(r, m.tracker, {
+      associate: t,
+      property: "ctx"
+    }));
+  }
+  _accessor(t, r) {
+    const n = this.ctx.root[m.internal];
+    return t in n ? () => {
+    } : (n[t] = { type: "accessor", ...r }, () => delete this.ctx.root[m.isolate][t]);
+  }
+  accessor(t, r) {
+    this.ctx.scope.effect(() => this._accessor(t, r));
+  }
+  alias(t, r) {
+    const n = this.ctx.root[m.internal];
+    if (!(t in n))
+      for (const s of r)
+        n[s] ||= { type: "alias", name: t };
+  }
+  _mixin(t, r) {
+    const n = Array.isArray(r) ? r.map((o) => [o, o]) : Object.entries(r), s = typeof t == "string" ? (o) => o[t] : () => t, i = n.map(([o, u]) => this._accessor(u, {
+      get(l) {
+        const h = s(this);
+        if (j(h)) return h;
+        const d = l ? X(l, h) : h, R = Reflect.get(h, o, d);
+        return typeof R != "function" ? R : R.bind(d ?? h);
+      },
+      set(l, h) {
+        const d = s(this), R = h ? X(h, d) : d;
+        return Reflect.set(d, o, l, R);
+      }
+    }));
+    return () => i.forEach((o) => o());
+  }
+  mixin(t, r) {
+    this.ctx.scope.effect(() => this._mixin(t, r));
+  }
+  trace(t) {
+    return B(this.ctx, t);
+  }
+  bind(t) {
+    return new Proxy(t, {
+      apply: /* @__PURE__ */ k((r, n, s) => r.apply(this.trace(n), s.map((i) => this.trace(i))), "apply")
+    });
+  }
+}, le = at;
+function he(e) {
+  return e !== null && e !== !1 && e !== void 0;
+}
+k(he, "isBailed");
+var ft = class {
+  constructor(e) {
+    this.ctx = e, P(this, m.tracker, {
+      associate: "lifecycle",
+      property: "ctx"
+    }), P(this.on("internal/listener", function(r, n, s) {
+      const i = s.prepend ? "unshift" : "push";
+      if (r === "ready")
+        return this.lifecycle.isActive ? (this.scope.ensure(async () => n()), () => !1) : void 0;
+      if (r === "dispose")
+        return this.scope.disposables[i](n), P(n, "name", "event <dispose>"), () => M(this.scope.disposables, n);
+      if (r === "fork")
+        return this.scope.runtime.forkables[i](n), this.scope.collect("event <fork>", () => M(this.scope.runtime.forkables, n));
+    }), I.static, e.scope);
+    for (const r of ["info", "error", "warning"])
+      P(this.on(`internal/${r}`, (n, ...s) => {
+        this._hooks[`internal/${r}`].length > 1;
+      }), I.static, e.scope);
+    P(this.on("internal/before-service", function(r) {
+      for (const n of this.registry.values()) {
+        if (!n.inject[r]?.required) continue;
+        const s = n.isReusable ? n.children : [n];
+        for (const i of s)
+          this[m.filter](i.ctx) && (i.updateStatus(), i.reset());
+      }
+    }, { global: !0 }), I.static, e.scope), P(this.on("internal/service", function(r) {
+      for (const n of this.registry.values()) {
+        if (!n.inject[r]?.required) continue;
+        const s = n.isReusable ? n.children : [n];
+        for (const i of s)
+          this[m.filter](i.ctx) && i.start();
+      }
+    }, { global: !0 }), I.static, e.scope);
+    const t = /* @__PURE__ */ k((r, n) => {
+      if (!r.runtime.plugin) return !1;
+      for (const s in r.runtime.inject)
+        if (n === le.resolveInject(r.ctx, s)[0]) return !0;
+      return t(r.parent.scope, n);
+    }, "checkInject");
+    P(this.on("internal/inject", function(r) {
+      return t(this.scope, r);
+    }, { global: !0 }), I.static, e.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(e, t) {
+    return t = B(this.ctx, t), e.slice().filter((r) => {
+      const n = t?.[I.filter];
+      return r.global || !n || n.call(t, r.ctx);
+    });
+  }
+  *dispatch(e, t) {
+    const r = typeof t[0] == "object" || typeof t[0] == "function" ? t.shift() : null, n = t.shift();
+    n !== "internal/event" && this.emit("internal/event", e, n, t, r);
+    for (const s of this.filterHooks(this._hooks[n] || [], r))
+      yield s.callback.apply(r, t);
+  }
+  async parallel(...e) {
+    await Promise.all(this.dispatch("emit", e));
+  }
+  emit(...e) {
+    Array.from(this.dispatch("emit", e));
+  }
+  async serial(...e) {
+    for await (const t of this.dispatch("serial", e))
+      if (he(t)) return t;
+  }
+  bail(...e) {
+    for (const t of this.dispatch("bail", e))
+      if (he(t)) return t;
+  }
+  register(e, t, r, n) {
+    const s = n.prepend ? "unshift" : "push";
+    return t[s]({ ctx: this.ctx, callback: r, ...n }), this.ctx.state.collect(e, () => this.unregister(t, r));
+  }
+  unregister(e, t) {
+    const r = e.findIndex((n) => n.callback === t);
+    if (r >= 0)
+      return e.splice(r, 1), !0;
+  }
+  on(e, t, r) {
+    typeof r != "object" && (r = { prepend: r }), this.ctx.scope.assertActive(), t = this.ctx.reflect.bind(t);
+    const n = this.bail(this.ctx, "internal/listener", e, t, r);
+    if (n) return n;
+    const s = this._hooks[e] ||= [], i = typeof e == "string" ? `event <${e}>` : "event (Symbol)";
+    return this.register(i, s, t, r);
+  }
+  once(e, t, r) {
+    const n = this.on(e, function(...s) {
+      return n(), t.apply(this, s);
+    }, r);
+    return n;
+  }
+  async start() {
+    this.isActive = !0;
+    const e = this._hooks.ready || [];
+    for (; e.length; ) {
+      const { ctx: t, callback: r } = e.shift();
+      t.scope.ensure(async () => r());
+    }
+    await this.flush();
+  }
+  async stop() {
+    this.isActive = !1, this.ctx.scope.reset();
+  }
+}, ut = ft, lt = /* @__PURE__ */ ((e) => (e[e.PENDING = 0] = "PENDING", e[e.LOADING = 1] = "LOADING", e[e.ACTIVE = 2] = "ACTIVE", e[e.FAILED = 3] = "FAILED", e[e.DISPOSED = 4] = "DISPOSED", e))(lt || {}), pe = class Pe extends Error {
+  constructor(t, r) {
+    super(r ?? Pe.Code[t]), this.code = t;
+  }
+  static {
+    k(this, "CordisError");
+  }
+};
+((e) => {
+  e.Code = {
+    INACTIVE_EFFECT: "cannot create effect on inactive context"
+  };
+})(pe || (pe = {}));
+var $e = class {
+  constructor(e, t) {
+    this.parent = e, this.config = t, this.uid = e.registry ? e.registry.counter : 0, this.ctx = this.context = e.extend({ scope: this }), this.proxy = new Proxy({}, {
+      get: /* @__PURE__ */ k((r, n) => Reflect.get(this.config, n), "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(e, t) {
+    this.assertActive();
+    const r = ye(e) ? new e(this.ctx, t) : e(this.ctx, t);
+    let n = !1;
+    const s = typeof r == "function" ? r : r.dispose.bind(r), i = /* @__PURE__ */ k((...o) => {
+      if (!n)
+        return n = !0, M(this.disposables, i), s(...o);
+    }, "wrapped");
+    return this.disposables.push(i), typeof r == "function" ? i : (r.dispose = i, r);
+  }
+  collect(e, t) {
+    const r = P(() => (M(this.disposables, r), t()), "name", e);
+    return this.disposables.push(r), r;
+  }
+  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(e) {
+    const t = this.status;
+    e?.(), this.status = this._getStatus(), t !== this.status && this.context.emit("internal/status", this, t);
+  }
+  ensure(e) {
+    const t = e().catch((r) => {
+      this.context.emit(this.ctx, "internal/error", r), this.cancel(r);
+    }).finally(() => {
+      this.updateStatus(() => this.tasks.delete(t)), this.context.events._tasks.delete(t);
+    });
+    this.updateStatus(() => this.tasks.add(t)), this.context.events._tasks.add(t);
+  }
+  cancel(e) {
+    this.error = e, this.updateStatus(() => this.hasError = !0), this.reset();
+  }
+  get ready() {
+    return Object.entries(this.runtime.inject).every(([e, t]) => !t.required || !j(this.ctx.get(e)));
+  }
+  reset() {
+    this.isActive = !1, this.disposables = this.disposables.splice(0).filter((e) => {
+      if (this.uid !== null && e[I.static] === this) return !0;
+      (async () => e())().catch((t) => {
+        this.context.emit(this.ctx, "internal/error", t);
+      });
+    });
+  }
+  init(e) {
+    this.config ? this.start() : this.cancel(e);
+  }
+  start() {
+    if (!this.ready || this.isActive || this.uid === null) return !0;
+    this.isActive = !0, this.updateStatus(() => this.hasError = !1);
+  }
+  accept(...e) {
+    const r = { keys: Array.isArray(e[0]) ? e.shift() : null, callback: e[0], ...e[1] };
+    return this.effect(() => (this.acceptors.push(r), r.immediate && r.callback?.(this.config), () => M(this.acceptors, r)));
+  }
+  decline(e) {
+    return this.accept(e, () => !0);
+  }
+  checkUpdate(e, t) {
+    if (t || !this.config) return [!0, !0];
+    if (t === !1) return [!1, !1];
+    const r = /* @__PURE__ */ Object.create(null), n = /* @__PURE__ */ k((l) => {
+      const h = r[l] ??= !K(this.config[l], e[l]);
+      return i ||= h, h;
+    }, "checkPropertyUpdate"), s = /* @__PURE__ */ new Set();
+    let i = !1, o = !1, u = this.runtime.isReactive || null;
+    for (const { keys: l, callback: h, passive: d } of this.acceptors) {
+      if (!l)
+        u ||= !d;
+      else if (d)
+        l?.forEach((b) => s.add(b));
+      else {
+        let b = !1;
+        for (const g of l)
+          b ||= n(g);
+        if (!b) continue;
+      }
+      h?.(e) && (o = !0);
+    }
+    for (const l in { ...this.config, ...e })
+      if (u !== !1 && !(l in r) && !s.has(l)) {
+        const h = n(l);
+        u === null && (o ||= h);
+      }
+    return [i, o];
+  }
+}, ht = class extends $e {
+  constructor(e, t, r, n) {
+    super(e, r), this.runtime = t, this.dispose = P(e.scope.collect(`fork <${e.runtime.name}>`, () => {
+      this.uid = null, this.reset(), this.context.emit("internal/fork", this);
+      const s = M(t.disposables, this.dispose);
+      return M(t.children, this) && !t.children.length && e.registry.delete(t.plugin), s;
+    }), I.static, t), t.children.push(this), t.disposables.push(this.dispose), this.context.emit("internal/fork", this), this.init(n);
+  }
+  static {
+    k(this, "ForkScope");
+  }
+  dispose;
+  start() {
+    if (super.start()) return !0;
+    for (const e of this.runtime.forkables)
+      this.ensure(async () => e(this.context, this._config));
+  }
+  update(e, t) {
+    const r = this.config, n = this.runtime.isForkable ? this : this.runtime;
+    if (n.config !== r) return;
+    let s;
+    try {
+      s = ee(this.runtime.plugin, e);
+    } catch (u) {
+      return this.context.emit("internal/error", u), this.cancel(u);
+    }
+    const [i, o] = n.checkUpdate(s, t);
+    this.context.emit("internal/before-update", this, e), this.config = s, n.config = s, i && this.context.emit("internal/update", this, r), o && n.restart();
+  }
+}, Se = class extends $e {
+  constructor(e, t, r, n) {
+    super(e, r), this.plugin = t, t ? (this.setup(), this.init(n)) : (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(e, t, r) {
+    return new ht(e, this, t, r);
+  }
+  dispose() {
+    return this.uid = null, this.reset(), this.context.emit("internal/runtime", this), !0;
+  }
+  setup() {
+    const { name: e } = this.plugin;
+    e && e !== "apply" && (this.name = e), this.schema = this.plugin.Config || this.plugin.schema, this.inject = se.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((e, t) => {
+    if (typeof this.plugin != "function")
+      return this.plugin.apply(e, t);
+    if (ye(this.plugin)) {
+      const r = new this.plugin(e, t), n = r[I.expose];
+      return n && e.set(n, r), r.fork && this.forkables.push(r.fork.bind(r)), r;
+    } else
+      return this.plugin(e, t);
+  }, "apply");
+  reset() {
+    super.reset();
+    for (const e of this.children)
+      e.reset();
+  }
+  start() {
+    if (super.start()) return !0;
+    !this.isReusable && this.plugin && this.ensure(async () => this.value = this.apply(this.ctx, this._config));
+    for (const e of this.children)
+      e.start();
+  }
+  update(e, t) {
+    if (this.isForkable) {
+      const u = new Error(`attempting to update forkable plugin "${this.plugin.name}", which may lead to unexpected behavior`);
+      this.context.emit(this.ctx, "internal/warning", u);
+    }
+    const r = this.config;
+    let n;
+    try {
+      n = ee(this.runtime.plugin || this.context.constructor, e);
+    } catch (u) {
+      return this.context.emit("internal/error", u), this.cancel(u);
+    }
+    const [s, i] = this.checkUpdate(n, t), o = this.children.find((u) => u.config === r);
+    this.config = n, o && (this.context.emit("internal/before-update", o, e), o.config = n, s && this.context.emit("internal/update", o, r)), i && this.restart();
+  }
+};
+function De(e) {
+  return e && typeof e == "object" && typeof e.apply == "function";
+}
+k(De, "isApplicable");
+function se(e) {
+  return function(t, r) {
+    if (r.kind === "class")
+      t.inject = e;
+    else if (r.kind === "method")
+      r.addInitializer(function() {
+        const n = this[m.tracker]?.property;
+        if (!n) throw new Error("missing context tracker");
+        this[n].inject(e, (s) => {
+          t.call(X(this, { [n]: s }));
+        });
+      });
+    else
+      throw new Error("@Inject can only be used on class or class methods");
+  };
+}
+k(se, "Inject");
+((e) => {
+  function t(r) {
+    if (!r) return {};
+    if (Array.isArray(r))
+      return Object.fromEntries(r.map((o) => [o, { required: !0 }]));
+    const { required: n, optional: s, ...i } = r;
+    return Array.isArray(n) && Object.assign(i, Object.fromEntries(n.map((o) => [o, { required: !0 }]))), Array.isArray(s) && Object.assign(i, Object.fromEntries(s.map((o) => [o, { required: !1 }]))), i;
+  }
+  e.resolve = t, k(t, "resolve");
+})(se || (se = {}));
+var pt = class {
+  constructor(e, t) {
+    this.ctx = e, P(this, m.tracker, {
+      associate: "registry",
+      property: "ctx"
+    }), this.context = e;
+    const r = new Se(e, null, t);
+    e.scope = r, r.ctx = e, this.set(null, r);
+  }
+  static {
+    k(this, "Registry");
+  }
+  _counter = 0;
+  _internal = /* @__PURE__ */ new Map();
+  context;
+  get counter() {
+    return ++this._counter;
+  }
+  get size() {
+    return this._internal.size;
+  }
+  resolve(e, t = !1) {
+    if (e === null || typeof e == "function") return e;
+    if (De(e)) return e.apply;
+    if (t) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof e);
+  }
+  get(e) {
+    const t = this.resolve(e);
+    return t && this._internal.get(t);
+  }
+  has(e) {
+    const t = this.resolve(e);
+    return !!t && this._internal.has(t);
+  }
+  set(e, t) {
+    const r = this.resolve(e);
+    this._internal.set(r, t);
+  }
+  delete(e) {
+    const t = this.resolve(e), r = t && this._internal.get(t);
+    if (r)
+      return this._internal.delete(t), r.dispose(), r;
+  }
+  keys() {
+    return this._internal.keys();
+  }
+  values() {
+    return this._internal.values();
+  }
+  entries() {
+    return this._internal.entries();
+  }
+  forEach(e) {
+    return this._internal.forEach(e);
+  }
+  using(e, t) {
+    return this.inject(e, t);
+  }
+  inject(e, t) {
+    return this.plugin({ inject: e, apply: t, name: t.name });
+  }
+  plugin(e, t, r) {
+    if (this.resolve(e, !0), this.ctx.scope.assertActive(), !r)
+      try {
+        t = ee(e, t);
+      } catch (s) {
+        this.context.emit(this.ctx, "internal/error", s), r = s, t = null;
+      }
+    let n = this.get(e);
+    return n ? (n.isForkable || this.context.emit(this.ctx, "internal/warning", new Error(`duplicate plugin detected: ${e.name}`)), n.fork(this.ctx, t, r)) : (n = new Se(this.ctx, e, t, r), this.set(e, n), n.fork(this.ctx, t, r));
+  }
+}, dt = pt, I = class Y {
+  static {
+    k(this, "Context");
+  }
+  static store = m.store;
+  static events = m.events;
+  static static = m.static;
+  static filter = m.filter;
+  static expose = m.expose;
+  static isolate = m.isolate;
+  static internal = m.internal;
+  static intercept = m.intercept;
+  static origin = "ctx";
+  static current = "ctx";
+  static is(t) {
+    return !!t?.[Y.is];
+  }
+  static {
+    Y.is[Symbol.toPrimitive] = () => Symbol.for("cordis.is"), Y.prototype[Y.is] = !0;
+  }
+  /** @deprecated use `Service.traceable` instead */
+  static associate(t, r) {
+    return t;
+  }
+  constructor(t) {
+    t = ee(this.constructor, t), this[m.store] = /* @__PURE__ */ Object.create(null), this[m.isolate] = /* @__PURE__ */ Object.create(null), this[m.internal] = /* @__PURE__ */ Object.create(null), this[m.intercept] = /* @__PURE__ */ Object.create(null);
+    const r = new Proxy(this, le.handler);
+    r.root = r, r.reflect = new le(r), r.registry = new dt(r, t), r.lifecycle = new ut(r);
+    const n = /* @__PURE__ */ k((s) => {
+      if (s) {
+        n(Object.getPrototypeOf(s));
+        for (const i of Object.getOwnPropertyNames(s)) {
+          const o = s[i].prototype?.constructor;
+          o && (r[s[i].key] = new o(r, t), P(r[s[i].key], "ctx", r));
+        }
+      }
+    }, "attach");
+    return n(this[m.internal]), r;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Context <${this.name}>`;
+  }
+  get name() {
+    let t = this.runtime;
+    for (; t && !t.name; )
+      t = t.parent.runtime;
+    return t?.name;
+  }
+  get events() {
+    return this.lifecycle;
+  }
+  /** @deprecated */
+  get state() {
+    return this.scope;
+  }
+  extend(t = {}) {
+    const r = Reflect.getOwnPropertyDescriptor(this, m.shadow)?.value, n = Object.assign(Object.create(B(this, this)), t);
+    return r ? Object.assign(Object.create(n), { [m.shadow]: r }) : n;
+  }
+  isolate(t, r) {
+    const n = Object.create(this[m.isolate]);
+    return n[t] = r ?? Symbol(t), this.extend({ [m.isolate]: n });
+  }
+  intercept(t, r) {
+    const n = Object.create(this[m.intercept]);
+    return n[t] = r, this.extend({ [m.intercept]: n });
+  }
+};
+I.prototype[I.internal] = /* @__PURE__ */ Object.create(null);
+var Tt = class Ce {
+  static {
+    k(this, "Service");
+  }
+  static setup = m.setup;
+  static invoke = m.invoke;
+  static extend = m.extend;
+  static tracker = m.tracker;
+  static provide = m.provide;
+  static immediate = m.immediate;
+  start() {
+  }
+  stop() {
+  }
+  ctx;
+  name;
+  config;
+  constructor(...t) {
+    let r, n, s, i;
+    I.is(t[0]) ? (r = t[0], typeof t[1] == "string" ? (n = t[1], s = t[2]) : i = t[1]) : i = t[0], n ??= this.constructor[m.provide], s ??= this.constructor[m.immediate];
+    let o = this;
+    const u = {
+      associate: n,
+      property: "ctx"
+    };
+    return o[m.invoke] && (o = ue(n, ge(Object.getPrototypeOf(this), Function.prototype), u)), r ? o.ctx = r : o[m.setup](), o.name = n, o.config = i, P(o, m.tracker, u), o.ctx.provide(n), o.ctx.runtime.name = n, s && (r ? o[m.expose] = n : o.ctx.set(n, o)), o.ctx.on("ready", async () => {
+      await Promise.resolve(), await o.start(), s || o.ctx.set(n, o);
+    }), o.ctx.on("dispose", () => o.stop()), o;
+  }
+  [m.filter](t) {
+    return t[m.isolate][this.name] === this.ctx[m.isolate][this.name];
+  }
+  [m.setup]() {
+    this.ctx = new I();
+  }
+  [m.extend](t) {
+    let r;
+    return this[Ce.invoke] ? r = ue(this.name, this, this[m.tracker]) : r = Object.create(this), Object.assign(r, t);
+  }
+  static [Symbol.hasInstance](t) {
+    let r = t.constructor;
+    for (; r; ) {
+      if (r = r.prototype?.constructor, r === this) return !0;
+      r = Object.getPrototypeOf(r);
+    }
+    return !1;
+  }
+}, yt = Object.defineProperty, gt = Object.getOwnPropertyNames, E = (e, t) => yt(e, "name", { value: t, configurable: !0 }), mt = (e, t) => function() {
+  return t || (0, e[gt(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, bt = mt({
+  "src/index.ts"(e, t) {
+    var r = Symbol.for("schemastery"), n = Symbol.for("ValidationError");
+    globalThis.__schemastery_index__ ??= 0;
+    var s = class extends TypeError {
+      constructor(a, c) {
+        let f = "$";
+        for (const p of c.path || [])
+          typeof p == "string" ? f += "." + p : typeof p == "number" ? f += "[" + p + "]" : typeof p == "symbol" && (f += `[Symbol(${p.toString()})]`);
+        f.startsWith(".") && (f = f.slice(1)), super((f === "$" ? "" : `${f} `) + a), this.options = c;
+      }
+      static {
+        E(this, "ValidationError");
+      }
+      name = "ValidationError";
+      static is(a) {
+        return !!a?.[n];
+      }
+    };
+    Object.defineProperty(s.prototype, n, {
+      value: !0
+    });
+    var i = /* @__PURE__ */ E(function(a) {
+      const c = /* @__PURE__ */ E(function(f, p = {}) {
+        return i.resolve(f, c, p)[0];
+      }, "schema");
+      if (a.refs) {
+        const f = q(a.refs, (y) => new i(y)), p = /* @__PURE__ */ E((y) => f[y], "getRef");
+        for (const y in f) {
+          const O = f[y];
+          O.sKey = p(O.sKey), O.inner = p(O.inner), O.list = O.list && O.list.map(p), O.dict = O.dict && q(O.dict, p);
+        }
+        return f[a.uid];
+      }
+      if (Object.assign(c, a), 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, i.prototype), c.meta ||= {}, c.toString = c.toString.bind(c), c;
+    }, "Schema");
+    i.prototype = Object.create(Function.prototype), i.prototype[r] = !0, i.ValidationError = s;
+    var o;
+    i.prototype.toJSON = /* @__PURE__ */ E(function() {
+      if (o)
+        return o[this.uid] ??= JSON.parse(JSON.stringify({ ...this })), this.uid;
+      o = { [this.uid]: { ...this } }, o[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+      const c = { uid: this.uid, refs: o };
+      return o = void 0, c;
+    }, "toJSON"), i.prototype.set = /* @__PURE__ */ E(function(c, f) {
+      return this.dict[c] = f, this;
+    }, "set"), i.prototype.push = /* @__PURE__ */ E(function(c) {
+      return this.list.push(c), this;
+    }, "push");
+    function u(a, c) {
+      const f = typeof a == "string" ? { "": a } : { ...a };
+      for (const p in c) {
+        const y = c[p];
+        y?.$description || y?.$desc ? f[p] = y.$description || y.$desc : typeof y == "string" && (f[p] = y);
+      }
+      return f;
+    }
+    E(u, "mergeDesc");
+    function l(a) {
+      return a?.$value ?? a?.$inner;
+    }
+    E(l, "getInner");
+    function h(a) {
+      return Ae(a ?? {}, (c) => !c.startsWith("$"));
+    }
+    E(h, "extractKeys"), i.prototype.i18n = /* @__PURE__ */ E(function(c) {
+      const f = i(this), p = u(f.meta.description, c);
+      return Object.keys(p).length && (f.meta.description = p), f.dict && (f.dict = q(f.dict, (y, O) => y.i18n(q(c, (S) => l(S)?.[O] ?? S?.[O])))), f.list && (f.list = f.list.map((y, O) => y.i18n(q(c, (S = {}) => Array.isArray(l(S)) ? l(S)[O] : Array.isArray(S) ? S[O] : h(S))))), f.inner && (f.inner = f.inner.i18n(q(c, (y) => l(y) ? l(y) : h(y)))), f.sKey && (f.sKey = f.sKey.i18n(q(c, (y) => y?.$key))), f;
+    }, "i18n"), i.prototype.extra = /* @__PURE__ */ E(function(c, f) {
+      const p = i(this);
+      return p.meta = { ...p.meta, [c]: f }, p;
+    }, "extra");
+    for (const a of ["required", "disabled", "collapse", "hidden", "loose"])
+      Object.assign(i.prototype, {
+        [a](c = !0) {
+          const f = i(this);
+          return f.meta = { ...f.meta, [a]: c }, f;
+        }
+      });
+    i.prototype.deprecated = /* @__PURE__ */ E(function() {
+      const c = i(this);
+      return c.meta.badges ||= [], c.meta.badges.push({ text: "deprecated", type: "danger" }), c;
+    }, "deprecated"), i.prototype.experimental = /* @__PURE__ */ E(function() {
+      const c = i(this);
+      return c.meta.badges ||= [], c.meta.badges.push({ text: "experimental", type: "warning" }), c;
+    }, "experimental"), i.prototype.pattern = /* @__PURE__ */ E(function(c) {
+      const f = i(this), p = ve(c, ["source", "flags"]);
+      return f.meta = { ...f.meta, pattern: p }, f;
+    }, "pattern"), i.prototype.simplify = /* @__PURE__ */ E(function(c) {
+      if (K(c, this.meta.default, this.type === "dict")) return null;
+      if (j(c)) return c;
+      if (this.type === "object" || this.type === "dict") {
+        const f = {};
+        for (const p in c) {
+          const O = (this.type === "object" ? this.dict[p] : this.inner)?.simplify(c[p]);
+          (this.type === "dict" || !j(O)) && (f[p] = O);
+        }
+        return K(f, this.meta.default, this.type === "dict") ? null : f;
+      } else if (this.type === "array" || this.type === "tuple") {
+        const f = [];
+        return c.forEach((p, y) => {
+          const O = this.type === "array" ? this.inner : this.list[y], S = O ? O.simplify(p) : p;
+          f.push(S);
+        }), f;
+      } else if (this.type === "intersect") {
+        const f = {};
+        for (const p of this.list)
+          Object.assign(f, p.simplify(c));
+        return f;
+      } else if (this.type === "union")
+        for (const f of this.list)
+          try {
+            return i.resolve(c, f, {}), f.simplify(c);
+          } catch {
+          }
+      return c;
+    }, "simplify"), i.prototype.toString = /* @__PURE__ */ E(function(c) {
+      return $[this.type]?.(this, c) ?? `Schema<${this.type}>`;
+    }, "toString"), i.prototype.role = /* @__PURE__ */ E(function(a, c) {
+      const f = i(this);
+      return f.meta = { ...f.meta, role: a, extra: c }, f;
+    }, "role");
+    for (const a of ["default", "link", "comment", "description", "max", "min", "step"])
+      Object.assign(i.prototype, {
+        [a](c) {
+          const f = i(this);
+          return f.meta = { ...f.meta, [a]: c }, f;
+        }
+      });
+    var d = {};
+    i.extend = /* @__PURE__ */ E(function(c, f) {
+      d[c] = f;
+    }, "extend"), i.resolve = /* @__PURE__ */ E(function(c, f, p = {}, y = !1) {
+      if (!f) return [c];
+      if (p.ignore?.(c, f)) return [c];
+      if (j(c) && f.type !== "lazy") {
+        if (f.meta.required) throw new s("missing required value", p);
+        let S = f, A = f.meta.default;
+        for (; S?.type === "intersect" && j(A); )
+          S = S.list[0], A = S?.meta.default;
+        if (j(A)) return [c];
+        c = ne(A);
+      }
+      const O = d[f.type];
+      if (!O) throw new s(`unsupported type "${f.type}"`, p);
+      try {
+        return O(c, f, p, y);
+      } catch (S) {
+        if (!f.meta.loose) throw S;
+        return [f.meta.default];
+      }
+    }, "resolve"), i.from = /* @__PURE__ */ E(function(c) {
+      if (j(c))
+        return i.any();
+      if (["string", "number", "boolean"].includes(typeof c))
+        return i.const(c).required();
+      if (c[r])
+        return c;
+      if (typeof c == "function")
+        switch (c) {
+          case String:
+            return i.string().required();
+          case Number:
+            return i.number().required();
+          case Boolean:
+            return i.boolean().required();
+          case Function:
+            return i.function().required();
+          default:
+            return i.is(c).required();
+        }
+      else
+        throw new TypeError(`cannot infer schema from ${c}`);
+    }, "from"), i.lazy = /* @__PURE__ */ E(function(c) {
+      const f = /* @__PURE__ */ E(() => (p.inner[r] || (p.inner = p.builder(), p.inner.meta = { ...p.meta, ...p.inner.meta }), p.inner.toJSON()), "toJSON"), p = new i({ type: "lazy", builder: c, inner: { toJSON: f } });
+      return p;
+    }, "lazy"), i.natural = /* @__PURE__ */ E(function() {
+      return i.number().step(1).min(0);
+    }, "natural"), i.percent = /* @__PURE__ */ E(function() {
+      return i.number().step(0.01).min(0).max(1).role("slider");
+    }, "percent"), i.date = /* @__PURE__ */ E(function() {
+      return i.union([
+        i.is(Date),
+        i.transform(i.string().role("datetime"), (c, f) => {
+          const p = new Date(c);
+          if (isNaN(+p)) throw new s(`invalid date "${c}"`, f);
+          return p;
+        }, !0)
+      ]);
+    }, "date"), i.regExp = /* @__PURE__ */ E(function(c = "") {
+      return i.union([
+        i.is(RegExp),
+        i.transform(i.string().role("regexp", { flag: c }), (f, p) => {
+          try {
+            return new RegExp(f, c);
+          } catch (y) {
+            throw new s(y.message, p);
+          }
+        }, !0)
+      ]);
+    }, "regExp"), i.arrayBuffer = /* @__PURE__ */ E(function(c) {
+      return i.union([
+        i.is(ArrayBuffer),
+        i.is(SharedArrayBuffer),
+        i.transform(i.any(), (f, p) => {
+          if (N.isSource(f)) return N.fromSource(f);
+          throw new s(`expected ArrayBufferSource but got ${f}`, p);
+        }, !0),
+        ...c ? [i.transform(i.string(), (f, p) => {
+          try {
+            return c === "base64" ? N.fromBase64(f) : N.fromHex(f);
+          } catch (y) {
+            throw new s(y.message, p);
+          }
+        }, !0)] : []
+      ]);
+    }, "arrayBuffer"), i.extend("lazy", (a, c, f, p) => (c.inner[r] || (c.inner = c.builder(), c.inner.meta = { ...c.meta, ...c.inner.meta }), i.resolve(a, c.inner, f, p))), i.extend("any", (a) => [a]), i.extend("never", (a, c, f) => {
+      throw new s(`expected nullable but got ${a}`, f);
+    }), i.extend("const", (a, { value: c }, f) => {
+      if (K(a, c)) return [c];
+      throw new s(`expected ${c} but got ${a}`, f);
+    });
+    function R(a, c, f, p, y = !1) {
+      const { max: O = 1 / 0, min: S = -1 / 0 } = c;
+      if (a > O) throw new s(`expected ${f} <= ${O} but got ${a}`, p);
+      if (a < S && !y) throw new s(`expected ${f} >= ${S} but got ${a}`, p);
+    }
+    E(R, "checkWithinRange"), i.extend("string", (a, { meta: c }, f) => {
+      if (typeof a != "string") throw new s(`expected string but got ${a}`, f);
+      if (c.pattern) {
+        const p = new RegExp(c.pattern.source, c.pattern.flags);
+        if (!p.test(a)) throw new s(`expect string to match regexp ${p}`, f);
+      }
+      return R(a.length, c, "string length", f), [a];
+    });
+    function b(a, c) {
+      const f = a.toString();
+      if (f.includes("e")) return a * Math.pow(10, c);
+      const p = f.indexOf(".");
+      if (p === -1) return a * Math.pow(10, c);
+      const y = f.slice(p + 1), O = f.slice(0, p);
+      return y.length <= c ? +(O + y.padEnd(c, "0")) : +(O + y.slice(0, c) + "." + y.slice(c));
+    }
+    E(b, "decimalShift");
+    function g(a, c, f) {
+      if (f = Math.abs(f), !/^\d+\.\d+$/.test(f.toString()))
+        return (a - c) % f === 0;
+      const p = f.toString().indexOf("."), y = f.toString().slice(p + 1).length;
+      return Math.abs(b(a, y) - b(c, y)) % b(f, y) === 0;
+    }
+    E(g, "isMultipleOf"), i.extend("number", (a, { meta: c }, f) => {
+      if (typeof a != "number") throw new s(`expected number but got ${a}`, f);
+      R(a, c, "number", f);
+      const { step: p } = c;
+      if (p && !g(a, c.min ?? 0, p))
+        throw new s(`expected number multiple of ${p} but got ${a}`, f);
+      return [a];
+    }), i.extend("boolean", (a, c, f) => {
+      if (typeof a == "boolean") return [a];
+      throw new s(`expected boolean but got ${a}`, f);
+    }), i.extend("bitset", (a, { bits: c, meta: f }, p) => {
+      let y = 0, O = [];
+      if (typeof a == "number") {
+        y = a;
+        for (const S in c)
+          a & c[S] && O.push(S);
+      } else if (Array.isArray(a)) {
+        O = a;
+        for (const S of O) {
+          if (typeof S != "string") throw new s(`expected string but got ${S}`, p);
+          S in c && (y |= c[S]);
+        }
+      } else
+        throw new s(`expected number or array but got ${a}`, p);
+      return y === f.default ? [y] : [y, O];
+    }), i.extend("function", (a, c, f) => {
+      if (typeof a == "function") return [a];
+      throw new s(`expected function but got ${a}`, f);
+    }), i.extend("is", (a, { constructor: c }, f) => {
+      if (typeof c == "function") {
+        if (a instanceof c) return [a];
+        throw new s(`expected ${c.name} but got ${a}`, f);
+      } else {
+        if (j(a))
+          throw new s(`expected ${c} but got ${a}`, f);
+        let p = Object.getPrototypeOf(a);
+        for (; p; ) {
+          if (p.constructor?.name === c) return [a];
+          p = Object.getPrototypeOf(p);
+        }
+        throw new s(`expected ${c} but got ${a}`, f);
+      }
+    });
+    function w(a, c, f, p) {
+      try {
+        const [y, O] = i.resolve(a[c], f, {
+          ...p,
+          path: [...p.path || [], c]
+        });
+        return O !== void 0 && (a[c] = O), y;
+      } catch (y) {
+        if (!p?.autofix) throw y;
+        return delete a[c], f.meta.default;
+      }
+    }
+    E(w, "property"), i.extend("array", (a, { inner: c, meta: f }, p) => {
+      if (!Array.isArray(a)) throw new s(`expected array but got ${a}`, p);
+      return R(a.length, f, "array length", p, !j(c.meta.default)), [a.map((y, O) => w(a, O, c, p))];
+    }), i.extend("dict", (a, { inner: c, sKey: f }, p, y) => {
+      if (!te(a)) throw new s(`expected object but got ${a}`, p);
+      const O = {};
+      for (const S in a) {
+        let A;
+        try {
+          A = i.resolve(S, f, p)[0];
+        } catch (Me) {
+          if (y) continue;
+          throw Me;
+        }
+        O[A] = w(a, S, c, p), a[A] = a[S], S !== A && delete a[S];
+      }
+      return [O];
+    }), i.extend("tuple", (a, { list: c }, f, p) => {
+      if (!Array.isArray(a)) throw new s(`expected array but got ${a}`, f);
+      const y = c.map((O, S) => w(a, S, O, f));
+      return p ? [y] : (y.push(...a.slice(c.length)), [y]);
+    });
+    function _(a, c) {
+      for (const f in c)
+        f in a || (a[f] = c[f]);
+    }
+    E(_, "merge"), i.extend("object", (a, { dict: c }, f, p) => {
+      if (!te(a)) throw new s(`expected object but got ${a}`, f);
+      const y = {};
+      for (const O in c) {
+        const S = w(a, O, c[O], f);
+        (!j(S) || O in a) && (y[O] = S);
+      }
+      return p || _(y, a), [y];
+    }), i.extend("union", (a, { list: c, toString: f }, p, y) => {
+      for (const O of c)
+        try {
+          return i.resolve(a, O, p, y);
+        } catch {
+        }
+      throw new s(`expected ${f()} but got ${JSON.stringify(a)}`, p);
+    }), i.extend("intersect", (a, { list: c, toString: f }, p, y) => {
+      if (!c.length) return [a];
+      let O;
+      for (const S of c) {
+        const A = i.resolve(a, S, p, !0)[0];
+        if (!j(A))
+          if (j(O))
+            O = A;
+          else {
+            if (typeof O != typeof A)
+              throw new s(`expected ${f()} but got ${JSON.stringify(a)}`, p);
+            if (typeof A == "object")
+              _(O ??= {}, A);
+            else if (O !== A)
+              throw new s(`expected ${f()} but got ${JSON.stringify(a)}`, p);
+          }
+      }
+      return !y && te(a) && _(O, a), [O];
+    }), i.extend("transform", (a, { inner: c, callback: f, preserve: p }, y) => {
+      const [O, S = a] = i.resolve(a, c, y, !0);
+      return p ? [f(O)] : [f(O), f(S)];
+    });
+    var $ = {};
+    function v(a, c, f) {
+      $[a] = f, Object.assign(i, {
+        [a](...p) {
+          const y = new i({ type: a });
+          return c.forEach((O, S) => {
+            switch (O) {
+              case "sKey":
+                y.sKey = p[S] ?? i.string();
+                break;
+              case "inner":
+                y.inner = i.from(p[S]);
+                break;
+              case "list":
+                y.list = p[S].map(i.from);
+                break;
+              case "dict":
+                y.dict = q(p[S], i.from);
+                break;
+              case "bits": {
+                y.bits = {};
+                for (const A in p[S])
+                  typeof p[S][A] == "number" && (y.bits[A] = p[S][A]);
+                break;
+              }
+              case "callback": {
+                const A = y.callback = p[S];
+                A.toJSON ||= () => A.toString();
+                break;
+              }
+              case "constructor": {
+                const A = y.constructor = p[S];
+                typeof A == "function" && (A.toJSON ||= () => A.name);
+                break;
+              }
+              default:
+                y[O] = p[S];
+            }
+          }), a === "object" || a === "dict" ? y.meta.default = {} : a === "array" || a === "tuple" ? y.meta.default = [] : a === "bitset" && (y.meta.default = 0), y;
+        }
+      });
+    }
+    E(v, "defineMethod"), v("is", ["constructor"], ({ constructor: a }) => typeof a == "function" ? a.name : a), v("any", [], () => "any"), v("never", [], () => "never"), v("const", ["value"], ({ value: a }) => typeof a == "string" ? JSON.stringify(a) : a), v("string", [], () => "string"), v("number", [], () => "number"), v("boolean", [], () => "boolean"), v("bitset", ["bits"], () => "bitset"), v("function", [], () => "function"), v("array", ["inner"], ({ inner: a }) => `${a.toString(!0)}[]`), v("dict", ["inner", "sKey"], ({ inner: a, sKey: c }) => `{ [key: ${c.toString()}]: ${a.toString()} }`), v("tuple", ["list"], ({ list: a }) => `[${a.map((c) => c.toString()).join(", ")}]`), v("object", ["dict"], ({ dict: a }) => Object.keys(a).length === 0 ? "{}" : `{ ${Object.entries(a).map(([c, f]) => `${c}${f.meta.required ? "" : "?"}: ${f.toString()}`).join(", ")} }`), v("union", ["list"], ({ list: a }, c) => {
+      const f = a.map(({ toString: p }) => p()).join(" | ");
+      return c ? `(${f})` : f;
+    }), v("intersect", ["list"], ({ list: a }) => `${a.map((c) => c.toString(!0)).join(" & ")}`), v("transform", ["inner", "callback", "preserve"], ({ inner: a }, c) => a.toString(c)), t.exports = i;
+  }
+});
+const Pt = bt();
+var C = /* @__PURE__ */ ((e) => (e.BODY_USED = "BODY_USED", e.NO_BODY_READER = "NO_BODY_READER", e.TIMEOUT = "TIMEOUT", e.NETWORK_ERROR = "NETWORK_ERROR", e.BODY_NOT_ALLOWED = "BODY_NOT_ALLOWED", e.HOOK_CONTEXT_CHANGED = "HOOK_CONTEXT_CHANGED", e.ABORTED_BY_HOOK = "ABORTED_BY_HOOK", e.INVALID_HOOK_CALLBACK = "INVALID_HOOK_CALLBACK", e.UNEXPECTED_HOOK_RETURN = "UNEXPECTED_HOOK_RETURN", e))(C || {});
+class T extends Error {
+  constructor(t, r, n, s) {
+    super(r, s), this.code = t, this.context = n;
+  }
+  name = "FexiosError";
+  static is(t) {
+    return t?.constructor === T;
+  }
+}
+class we extends T {
+  constructor(t, r, n) {
+    super(r.statusText, t, void 0, n), this.response = r;
+  }
+  name = "FexiosResponseError";
+  static is(t) {
+    return t?.constructor === we;
+  }
+}
+function wt(e, t = 2048) {
+  if (!(e instanceof Uint8Array))
+    throw new TypeError("Input must be a Uint8Array");
+  if (e.length === 0)
+    return !0;
+  const r = Math.min(
+    Math.max(e.length, 256),
+    t
+  ), n = e.slice(0, r);
+  if (Ot(n))
+    return !1;
+  const s = Rt(n);
+  if (s.nullByteRatio > 0.05 || s.highByteRatio > 0.95)
+    return !1;
+  const i = ["utf-8", "utf-16le", "utf-16be", "iso-8859-1"];
+  let o = -1, u = !1;
+  for (const l of i)
+    try {
+      const h = new TextDecoder(l, { fatal: !0 }).decode(n), d = St(h);
+      d > o && (o = d, u = d > 0.7);
+    } catch {
+      continue;
+    }
+  return u;
+}
+function Ot(e) {
+  if (e.length < 4) return !1;
+  const t = [
+    [137, 80, 78, 71],
+    // PNG
+    [255, 216, 255],
+    // JPEG
+    [71, 73, 70],
+    // GIF
+    [37, 80, 68, 70],
+    // PDF
+    [80, 75, 3, 4],
+    // ZIP/Office documents
+    [80, 75, 5, 6],
+    // ZIP empty archive
+    [80, 75, 7, 8],
+    // ZIP spanned archive
+    [127, 69, 76, 70],
+    // ELF executable
+    [77, 90],
+    // Windows executable
+    [202, 254, 186, 190],
+    // Java class file
+    [0, 0, 1, 0],
+    // ICO
+    [82, 73, 70, 70]
+    // RIFF (AVI, WAV, etc.)
+  ];
+  for (const r of t)
+    if (e.length >= r.length) {
+      let n = !0;
+      for (let s = 0; s < r.length; s++)
+        if (e[s] !== r[s]) {
+          n = !1;
+          break;
+        }
+      if (n) return !0;
+    }
+  return !1;
+}
+function Rt(e) {
+  let t = 0, r = 0, n = 0;
+  for (const s of e)
+    s === 0 && t++, s > 127 && r++, (s < 32 && s !== 9 && s !== 10 && s !== 13 || s === 127) && n++;
+  return {
+    nullByteRatio: t / e.length,
+    highByteRatio: r / e.length,
+    controlCharRatio: n / e.length
+  };
+}
+function St(e) {
+  if (e.length === 0) return 1;
+  let t = 1, r = 0;
+  for (let s = 0; s < e.length; s++) {
+    const i = e[s].charCodeAt(0);
+    i >= 32 && i <= 126 || i === 9 || i === 10 || i === 13 || i === 32 ? r++ : i > 127 && i < 65534 ? !kt(i) && !xt(i) && r++ : t -= 0.1;
+  }
+  const n = r / e.length;
+  return t *= n, Et(e) && (t *= 1.1), Math.max(0, Math.min(1, t));
+}
+function kt(e) {
+  return e >= 0 && e <= 31 || e >= 127 && e <= 159;
+}
+function xt(e) {
+  return e >= 57344 && e <= 63743 || e >= 983040 && e <= 1048573 || e >= 1048576 && e <= 1114109;
+}
+function Et(e) {
+  return [
+    /\b\w+\b/,
+    // Words
+    /[.!?]+\s/,
+    // Sentence endings
+    /\s+/,
+    // Whitespace
+    /[a-zA-Z]{3,}/,
+    // English words
+    /[\u4e00-\u9fa5]+/,
+    // Chinese characters
+    /\d+/
+    // Numbers
+  ].some((t) => t.test(e));
+}
+function U(e) {
+  if (typeof e != "object" || e === null || Object.prototype.toString.call(e) !== "[object Object]")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  return t === Object.prototype || t === null;
+}
+const re = (e, ...t) => {
+  const r = (s) => {
+    if (Array.isArray(s)) return s.slice();
+    if (U(s)) {
+      const i = {};
+      for (const o of Reflect.ownKeys(s)) i[o] = r(s[o]);
+      return i;
+    }
+    return s;
+  }, n = r(e);
+  for (const s of t)
+    if (s != null)
+      for (const i of Reflect.ownKeys(s)) {
+        const o = s[i];
+        if (typeof o > "u") continue;
+        const u = n[i];
+        U(u) && U(o) ? n[i] = re(u, o) : n[i] = r(o);
+      }
+  return n;
+};
+class G {
+  constructor(t, r, n) {
+    this.rawResponse = t, this.data = r, this.ok = t.ok, this.status = t.status, this.statusText = t.statusText, this.headers = t.headers, Object.entries(n || {}).forEach(([s, i]) => {
+      this[s] = i;
+    });
+  }
+  ok;
+  status;
+  statusText;
+  headers;
+}
+async function ke(e, t, r) {
+  if (e.bodyUsed)
+    throw new T(
+      C.BODY_USED,
+      "Response body has already been used or locked"
+    );
+  const n = e.headers.get("content-type") || "", s = Number(e.headers.get("content-length")) || 0, i = (u, l) => l === "json" || u.startsWith("application/json"), o = (u, l, h) => h === "blob" || u.startsWith("image/") && !u.startsWith("image/svg") || u.startsWith("video/") || u.startsWith("audio/") || !wt(l);
+  if ((e.status === 101 || e.status === 426 || e.headers.get("upgrade")) && typeof globalThis.WebSocket < "u") {
+    const u = new WebSocket(e.url);
+    return await new Promise((l, h) => {
+      u.onopen = l, u.onerror = h;
+    }), new G(e, u, {
+      ok: !0,
+      status: 101,
+      statusText: "Switching Protocols"
+    });
+  } else if (n.startsWith("text/event-stream") && !["text", "json"].includes(t || "") && typeof globalThis.EventSource < "u") {
+    const u = new EventSource(e.url);
+    return await new Promise((l, h) => {
+      u.onopen = l, u.onerror = h;
+    }), new G(e, u);
+  } else {
+    if (t === "stream")
+      return new G(
+        e,
+        e.body
+      );
+    {
+      const u = e.clone().body?.getReader();
+      if (!u)
+        throw new T(
+          C.NO_BODY_READER,
+          "Failed to get ReadableStream from response body"
+        );
+      let l = new Uint8Array();
+      for (; ; ) {
+        const { done: d, value: R } = await u.read();
+        if (d) break;
+        if (R && (l = new Uint8Array([...l, ...R]), r && s > 0)) {
+          const b = Math.min(l.length / s, 1);
+          r(b, l);
+        }
+      }
+      const h = new G(e, void 0);
+      if (t === "arrayBuffer")
+        return h.data = l.buffer, h;
+      if (i(n, t))
+        try {
+          const d = new TextDecoder().decode(l);
+          h.data = JSON.parse(d);
+        } catch {
+        }
+      if (typeof h.data != "string" && o(n, l, t) ? h.data = new Blob([l], {
+        type: e.headers.get("content-type") || void 0
+      }) : h.data = new TextDecoder().decode(l), typeof h.data == "string" && t !== "text") {
+        const d = h.data.trim(), R = d[0], b = d[d.length - 1];
+        if (R === "{" && b === "}" || R === "[" && b === "]")
+          try {
+            h.data = JSON.parse(h.data);
+          } catch {
+          }
+      }
+      if (typeof h.data > "u" && (h.data = l.length > 0 ? l : void 0), h.ok)
+        return h;
+      throw new we(
+        `Request failed with status code ${e.status}`,
+        h
+      );
+    }
+  }
+}
+var oe;
+((e) => {
+  e.makeSearchParams = (s) => {
+    if (!s)
+      return new URLSearchParams();
+    if (s instanceof URLSearchParams)
+      return s;
+    if (typeof s != "object" || s?.constructor !== Object)
+      throw new TypeError("only plain object is supported");
+    const i = new URLSearchParams(), o = (h, d) => {
+      d != null && i.append(h, d);
+    }, u = (h, d) => {
+      d != null && i.set(h, d);
+    }, l = (h, d) => {
+      if (d != null) {
+        if (Array.isArray(d)) {
+          for (const R of d) o(h, R?.toString());
+          return;
+        }
+        if (typeof d == "object" && d.constructor === Object) {
+          for (const [R, b] of Object.entries(d)) {
+            if (b == null) continue;
+            const g = R.endsWith("[]"), w = g ? R.slice(0, -2) : R, _ = `${h}[${w}]`;
+            if (g) {
+              const $ = `${_}[]`;
+              if (Array.isArray(b))
+                for (const v of b) o($, v?.toString());
+              else typeof b == "object" && b !== null && b.constructor === Object ? l(`${_}[]`, b) : o($, b?.toString());
+            } else if (Array.isArray(b))
+              for (const $ of b) o(_, $?.toString());
+            else typeof b == "object" && b !== null && b.constructor === Object ? l(_, b) : u(_, b?.toString());
+          }
+          return;
+        }
+        u(h, d?.toString());
+      }
+    };
+    for (const [h, d] of Object.entries(s))
+      l(h, d);
+    return i;
+  }, e.makeQueryString = (s) => (0, e.makeSearchParams)(s).toString(), e.makeURL = (s, i, o, u) => {
+    const l = typeof window < "u" && window.location?.origin || "http://localhost", h = typeof s == "string" ? new URL(s, u ?? l) : new URL(s), d = (0, e.toQueryRecord)(h.searchParams), R = (0, e.mergeQueries)(d, i || {}), b = (0, e.makeSearchParams)(R);
+    return h.search = b.toString(), h.hash = o || "", h;
+  }, e.toQueryRecord = (s) => {
+    typeof s == "string" && (s = (0, e.fromString)(s));
+    const i = {}, o = (l) => {
+      if (!l.includes("[")) return { path: [l], forceArray: !1 };
+      const h = [l.slice(0, l.indexOf("["))], d = /\[([^\]]*)\]/g;
+      let R, b = !1, g = !1;
+      for (; R = d.exec(l); )
+        R[1] === "" ? (b = !0, g = !0) : (h.push(R[1]), g = !1);
+      return b && g && (h[h.length - 1] = h[h.length - 1] + "[]"), { path: h, forceArray: b };
+    }, u = (l, h, d, R) => {
+      let b = l;
+      for (let g = 0; g < h.length; g++) {
+        const w = h[g];
+        g === h.length - 1 ? R ? b[w] === void 0 ? b[w] = [d] : Array.isArray(b[w]) ? b[w].push(d) : b[w] = [b[w], d] : b[w] === void 0 ? b[w] = d : Array.isArray(b[w]) ? b[w].push(d) : b[w] = [b[w], d] : ((b[w] === void 0 || typeof b[w] != "object" || Array.isArray(b[w])) && (b[w] = {}), b = b[w]);
+      }
+    };
+    for (const [l, h] of s.entries()) {
+      const { path: d, forceArray: R } = o(String(l));
+      u(i, d, h?.toString(), R);
+    }
+    return i;
+  }, e.fromString = (s) => {
+    const i = s.trim();
+    if (!i) return new URLSearchParams();
+    if (i.startsWith("?")) return new URLSearchParams(i.slice(1));
+    const o = i.indexOf("?");
+    if (o >= 0) {
+      const u = i.indexOf("#", o + 1), l = i.slice(o + 1, u >= 0 ? u : void 0);
+      return new URLSearchParams(l);
+    }
+    return new URLSearchParams(i);
+  }, e.mergeQueries = (s, ...i) => {
+    const o = t(r(s));
+    for (const u of i)
+      u != null && n(o, r(u));
+    return o;
+  };
+  function t(s) {
+    if (Array.isArray(s)) return s.map(t);
+    if (U(s)) {
+      const i = {};
+      for (const [o, u] of Object.entries(s)) i[o] = t(u);
+      return i;
+    }
+    if (s instanceof Map) {
+      const i = {};
+      for (const [o, u] of s.entries()) i[o] = t(u);
+      return i;
+    }
+    return s;
+  }
+  function r(s) {
+    if (!s) return {};
+    if (s instanceof URLSearchParams || s instanceof FormData || s instanceof Map)
+      return (0, e.toQueryRecord)(s);
+    if (typeof s == "string") return (0, e.toQueryRecord)((0, e.fromString)(s));
+    if (U(s)) return s;
+    throw new TypeError(
+      `unsupported type transformation, got: ${Object.prototype.toString.call(
+        s
+      )}`
+    );
+  }
+  function n(s, i) {
+    for (const [o, u] of Object.entries(i)) {
+      if (u === void 0) continue;
+      if (u === null) {
+        delete s[o];
+        continue;
+      }
+      const l = s[o];
+      U(l) && U(u) ? n(l, u) : s[o] = t(u);
+    }
+  }
+})(oe || (oe = {}));
+const Ie = function(e) {
+  const t = this.constructor.prototype, r = Reflect.get(t, e, t);
+  function n(...s) {
+    return Reflect.apply(r, n, s);
+  }
+  Reflect.setPrototypeOf(n, t);
+  for (const s of Reflect.ownKeys(r)) {
+    const i = Reflect.getOwnPropertyDescriptor(r, s);
+    i && Reflect.defineProperty(n, s, i);
+  }
+  return n;
+};
+Ie.prototype = Object.create(Function.prototype);
+var V;
+((e) => {
+  e.makeHeaders = (t) => {
+    if (!t) return new Headers();
+    if (t instanceof Headers) return new Headers(t);
+    const r = new Headers();
+    if (t instanceof Map) {
+      for (const [n, s] of t.entries())
+        if (s != null)
+          if (Array.isArray(s))
+            for (const i of s)
+              i != null && r.append(n, String(i));
+          else
+            r.append(n, String(s));
+      return r;
+    }
+    if (U(t)) {
+      for (const [n, s] of Object.entries(t))
+        if (s != null)
+          if (Array.isArray(s))
+            for (const i of s)
+              i != null && r.append(n, String(i));
+          else
+            r.append(n, String(s));
+      return r;
+    }
+    throw new TypeError(
+      "only plain object, Map/ReadonlyMap, or Headers is supported"
+    );
+  }, e.toHeaderRecord = (t) => {
+    if (t instanceof Headers) {
+      const r = {};
+      return t.forEach((n, s) => {
+        r[s] = r[s] ? [...r[s], n] : [n];
+      }), r;
+    }
+    if (t instanceof Map) {
+      const r = {};
+      for (const [n, s] of t.entries())
+        if (s != null)
+          if (Array.isArray(s)) {
+            const i = s.filter((o) => o != null).map((o) => String(o));
+            i.length && (r[n] = (r[n] ?? []).concat(i));
+          } else {
+            const i = String(s);
+            r[n] = r[n] ? [...r[n], i] : [i];
+          }
+      return r;
+    }
+    throw new TypeError(
+      `unsupported type transformation, got: ${Object.prototype.toString.call(
+        t
+      )}`
+    );
+  }, e.mergeHeaders = (t, ...r) => {
+    const n = t instanceof Headers ? new Headers(t) : (0, e.makeHeaders)(t), s = (i) => {
+      for (const [o, u] of Object.entries(i))
+        if (u !== void 0) {
+          if (u === null) {
+            n.delete(o);
+            continue;
+          }
+          if (Array.isArray(u)) {
+            n.delete(o);
+            for (const l of u)
+              l != null && n.append(o, String(l));
+          } else
+            n.set(o, String(u));
+        }
+    };
+    for (const i of r) {
+      if (i == null) continue;
+      if (i instanceof Headers) {
+        i.forEach((u, l) => {
+          n.set(l, u);
+        });
+        continue;
+      }
+      if (U(i)) {
+        s(i);
+        continue;
+      }
+      const o = (0, e.toHeaderRecord)(i);
+      for (const [u, l] of Object.entries(o)) {
+        n.delete(u);
+        for (const h of l) n.append(u, h);
+      }
+    }
+    return n;
+  };
+})(V || (V = {}));
+class L extends Ie {
+  static FINAL_SYMBOL = Symbol("FEXIOS_FINAL_CONTEXT");
+  static NORMALIZED_SYMBOL = Symbol("FEXIOS_NORMALIZED_QUERY");
+  baseConfigs;
+  static DEFAULT_CONFIGS = {
+    baseURL: "",
+    timeout: 60 * 1e3,
+    credentials: "same-origin",
+    headers: {},
+    query: {},
+    responseType: void 0,
+    fetch: globalThis.fetch
+  };
+  hooks = [];
+  static ALL_METHODS = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options",
+    "trace"
+  ];
+  static METHODS_WITHOUT_BODY = [
+    "get",
+    "head",
+    "options",
+    "trace"
+  ];
+  constructor(t = {}) {
+    super("request"), this.baseConfigs = re(L.DEFAULT_CONFIGS, t), L.ALL_METHODS.forEach(
+      (r) => this.createMethodShortcut(r.toLowerCase())
+    );
+  }
+  async request(t, r) {
+    let n = r = r || {};
+    if (typeof t == "string" || t instanceof URL ? n.url = t.toString() : typeof t == "object" && (n = re(t, n)), n = await this.emit("beforeInit", n, {
+      shouldAdjustRequestParams: !0,
+      shouldHandleShortCircuitResponse: !0
+    }), n[L.FINAL_SYMBOL]) return n;
+    if (L.METHODS_WITHOUT_BODY.includes(
+      n.method?.toLocaleLowerCase()
+    ) && n.body)
+      throw new T(
+        C.BODY_NOT_ALLOWED,
+        `Request method "${n.method}" does not allow body`
+      );
+    if (n = await this.emit("beforeRequest", n, {
+      shouldAdjustRequestParams: !0,
+      shouldHandleShortCircuitResponse: !0,
+      preAdjust: !0,
+      requestOptionsOverridesURLSearchParams: !0,
+      preRequestOptionsOverridesURLSearchParams: !0,
+      postRequestOptionsOverridesURLSearchParams: !0
+    }), n[L.FINAL_SYMBOL]) return n;
+    let s;
+    const i = {};
+    if (typeof n.body < "u" && n.body !== null && (n.body instanceof Blob || n.body instanceof FormData || n.body instanceof URLSearchParams ? s = n.body : typeof n.body == "object" && n.body !== null ? (s = JSON.stringify(n.body), n.headers = this.mergeHeaders(n.headers, {
+      "Content-Type": "application/json"
+    })) : s = n.body), !V.makeHeaders(
+      r.headers || {}
+    ).get("content-type") && s && (s instanceof FormData || s instanceof URLSearchParams ? i["content-type"] = null : typeof s == "string" && typeof n.body == "object" ? i["content-type"] = "application/json" : s instanceof Blob && (i["content-type"] = s.type || "application/octet-stream")), n.body = s, n = await this.emit("afterBodyTransformed", n, {
+      shouldAdjustRequestParams: !0,
+      shouldHandleShortCircuitResponse: !0,
+      preAdjust: !0,
+      postRequestOptionsOverridesURLSearchParams: !0
+    }), n[L.FINAL_SYMBOL]) return n;
+    const o = n.abortController || globalThis.AbortController ? new AbortController() : void 0, u = n.baseURL || this.baseConfigs.baseURL || globalThis.location?.href || "http://localhost", l = new URL(
+      n.url.toString(),
+      u
+    ), h = oe.makeURL(
+      l,
+      n.query,
+      l.hash
+    ).toString(), d = new Request(h, {
+      method: n.method || "GET",
+      credentials: n.credentials,
+      cache: n.cache,
+      mode: n.mode,
+      headers: V.mergeHeaders(
+        this.baseConfigs.headers,
+        n.headers || {},
+        i
+      ),
+      body: n.body,
+      signal: o?.signal
+    });
+    if (n.rawRequest = d, n = await this.emit("beforeActualFetch", n, {
+      shouldHandleShortCircuitResponse: !0
+    }), n[L.FINAL_SYMBOL]) return n;
+    const R = n.timeout || this.baseConfigs.timeout || 60 * 1e3;
+    if (n.url.startsWith("ws"))
+      try {
+        const g = new WebSocket(n.url);
+        return await new Promise((w, _) => {
+          const $ = setTimeout(() => {
+            _(
+              new T(
+                C.TIMEOUT,
+                `WebSocket connection timed out after ${R}ms`,
+                n
+              )
+            );
+          }, R);
+          g.onopen = () => {
+            clearTimeout($), w();
+          }, g.onerror = (v) => {
+            clearTimeout($), _(
+              new T(
+                C.NETWORK_ERROR,
+                "WebSocket connection failed",
+                n
+              )
+            );
+          }, g.onclose = (v) => {
+            v.code !== 1e3 && (clearTimeout($), _(
+              new T(
+                C.NETWORK_ERROR,
+                `WebSocket closed with code ${v.code}`,
+                n
+              )
+            ));
+          };
+        }), n.rawResponse = new Response(), n.response = new G(n.rawResponse, g, {
+          ok: !0,
+          status: 101,
+          statusText: "Switching Protocols"
+        }), n.data = g, n.headers = new Headers(), this.emit("afterResponse", n);
+      } catch (g) {
+        throw g instanceof T ? g : new T(
+          C.NETWORK_ERROR,
+          `WebSocket creation failed: ${g}`,
+          n
+        );
+      }
+    let b;
+    try {
+      o && (b = setTimeout(() => {
+        o.abort();
+      }, R));
+      const g = await (r.fetch || this.baseConfigs.fetch || globalThis.fetch)(n.rawRequest).catch((w) => {
+        throw b && clearTimeout(b), o?.signal.aborted ? new T(
+          C.TIMEOUT,
+          `Request timed out after ${R}ms`,
+          n
+        ) : new T(C.NETWORK_ERROR, w.message, n);
+      });
+      return b && clearTimeout(b), n.rawResponse = g, n.response = await ke(
+        g,
+        n.responseType,
+        (w, _) => {
+          r?.onProgress?.(w, _);
+        }
+      ), n.data = n.response.data, n.headers = n.response.headers, this.emit("afterResponse", n);
+    } catch (g) {
+      throw b && clearTimeout(b), g;
+    }
+  }
+  mergeQueries = oe.mergeQueries;
+  mergeHeaders = V.mergeHeaders;
+  normalizeContext(t, r = {}) {
+    const n = t, s = n.baseURL || this.baseConfigs.baseURL || globalThis.location?.href || "http://localhost", i = new URL(
+      s,
+      globalThis.location?.href || "http://localhost"
+    ), o = new URL(n.url.toString(), i), u = !!n[L.NORMALIZED_SYMBOL];
+    n.baseURL = i ? i.origin : o.origin;
+    let l;
+    u ? l = r.requestOptionsOverridesURLSearchParams ? this.mergeQueries({}, o.search, n.query) : this.mergeQueries({}, n.query, o.search) : (l = r.requestOptionsOverridesURLSearchParams ? this.mergeQueries(
+      i?.search || "",
+      this.baseConfigs.query,
+      o.search,
+      n.query
+    ) : this.mergeQueries(
+      i?.search || "",
+      this.baseConfigs.query,
+      n.query,
+      o.search
+    ), n[L.NORMALIZED_SYMBOL] = !0), n.query = l;
+    const h = new URL(o);
+    return h.search = "", n.url = h.toString(), n;
+  }
+  async emit(t, r, n = {}) {
+    const s = this.hooks.filter((i) => i.event === t);
+    if (n?.shouldAdjustRequestParams && n?.preAdjust)
+      try {
+        r = this.normalizeContext(r, {
+          requestOptionsOverridesURLSearchParams: n.preRequestOptionsOverridesURLSearchParams
+        });
+      } catch {
+      }
+    try {
+      let i = 0;
+      for (const o of s) {
+        const u = `${t}#${o.action.name || `anonymous#${i}`}`, l = Symbol("FEXIOS_HOOK_CONTEXT");
+        r[l] = l;
+        const h = r.url;
+        let d = "";
+        try {
+          const b = this.mergeQueries(
+            {},
+            r.query || {}
+          );
+          d = JSON.stringify(b);
+        } catch {
+        }
+        let R = await o.action.call(this, r);
+        if (R === void 0 && (R = r), R === !1)
+          throw new T(
+            C.ABORTED_BY_HOOK,
+            `Request aborted by hook "${u}"`,
+            r
+          );
+        if (R instanceof Response) {
+          const b = R, g = { ...r, rawResponse: b }, w = await ke(
+            b,
+            r.responseType,
+            (_, $) => {
+              r.onProgress?.(_, $);
+            }
+          );
+          if (g.response = w, g.data = w.data, g.headers = w.headers, t !== "afterResponse") {
+            const _ = await this.emit("afterResponse", g);
+            return _[L.FINAL_SYMBOL] = !0, _;
+          } else
+            return g[L.FINAL_SYMBOL] = !0, g;
+        } else if (typeof R == "object" && R[l] === l)
+          r = R;
+        else {
+          const b = globalThis["".concat("console")];
+          try {
+            throw new T(
+              C.HOOK_CONTEXT_CHANGED,
+              `Hook "${u}" should return the original FexiosContext or return false to abort the request, but got "${R}".`
+            );
+          } catch (g) {
+            b.warn(g.stack || g);
+          }
+        }
+        if (n?.shouldAdjustRequestParams)
+          try {
+            const b = r.baseURL || this.baseConfigs.baseURL || globalThis.location?.href || "http://localhost", g = new URL(
+              r.url.toString(),
+              b
+            );
+            let w = {};
+            if (d)
+              try {
+                w = JSON.parse(d);
+              } catch {
+              }
+            const _ = r.query || {}, $ = this.mergeQueries(
+              w,
+              g.search,
+              _
+            );
+            r.query = $;
+            const v = new URL(g);
+            v.search = "", r.url = v.toString();
+          } catch {
+          }
+        delete r[l], i++;
+      }
+    } catch (i) {
+      return Promise.reject(i);
+    }
+    return r;
+  }
+  on(t, r, n = !1) {
+    if (typeof r != "function")
+      throw new T(
+        C.INVALID_HOOK_CALLBACK,
+        `Hook should be a function, but got "${typeof r}"`
+      );
+    return this.hooks[n ? "unshift" : "push"]({
+      event: t,
+      action: r
+    }), this;
+  }
+  off(t, r) {
+    return t === "*" || !t ? this.hooks = this.hooks.filter((n) => n.action !== r) : this.hooks = this.hooks.filter(
+      (n) => n.event !== t || n.action !== r
+    ), this;
+  }
+  createInterceptor(t) {
+    return {
+      handlers: () => this.hooks.filter((r) => r.event === t).map((r) => r.action),
+      use: (r, n = !1) => this.on(t, r, n),
+      clear: () => {
+        this.hooks = this.hooks.filter((r) => r.event !== t);
+      }
+    };
+  }
+  interceptors = {
+    request: this.createInterceptor("beforeRequest"),
+    response: this.createInterceptor("afterResponse")
+  };
+  createMethodShortcut(t) {
+    return Reflect.defineProperty(this, t, {
+      get: () => (r, n, s) => (L.METHODS_WITHOUT_BODY.includes(
+        t.toLocaleLowerCase()
+      ) ? s = n : (s = s || {}, s.body = n), this.request(r, {
+        ...s,
+        method: t
+      }))
+    }), this;
+  }
+  extends(t) {
+    const r = new L(re(this.baseConfigs, t));
+    return r.hooks = [...this.hooks], r._plugins = new Map(this._plugins), r._plugins.forEach(async (n) => {
+      await r.plugin(n);
+    }), r;
+  }
+  create = L.create;
+  static create(t) {
+    return new L(t);
+  }
+  _plugins = /* @__PURE__ */ new Map();
+  async plugin(t) {
+    if (typeof t?.name == "string" && typeof t?.install == "function") {
+      if (this._plugins.has(t.name))
+        return this;
+      const r = await t.install(this);
+      if (this._plugins.set(t.name, t), r instanceof L)
+        return r;
+    }
+    return this;
+  }
+  // 版本弃子们.jpg
+  /** @deprecated Use checkIsPlainObject from utils instead */
+  checkIsPlainObject = U;
+  /** @deprecated Use `mergeQueries` instead */
+  mergeQuery = this.mergeQueries;
+}
+const At = L.create, xe = At();
+typeof globalThis < "u" ? globalThis.fexios = xe : typeof window < "u" && (window.fexios = xe);
+var ce;
+((e) => {
+  function t(n) {
+    return Array.isArray(n) ? n.join("|") : typeof n == "boolean" || n === null ? n ? "1" : void 0 : typeof n == "number" ? "" + n : n;
+  }
+  e.normalizeParamValue = t;
+  function r(n) {
+    const s = (o) => o && (o instanceof URLSearchParams || o instanceof FormData);
+    if (n == null)
+      return;
+    const i = new FormData();
+    if (s(n))
+      return n.forEach((o, u) => {
+        const l = t(o);
+        l != null && i.append(u, l);
+      }), i;
+    if (U(n))
+      return Object.entries(n).forEach(([o, u]) => {
+        const l = t(u);
+        l != null && i.append(o, l);
+      }), i;
+  }
+  e.normalizeBody = r;
+})(ce || (ce = {}));
+var Q = /* @__PURE__ */ ((e) => (e.HTTP_ERROR = "HTTP_ERROR", e.LOGIN_FAILED = "LOGIN_FAILED", e.LOGIN_RETRY_LIMIT_EXCEEDED = "LOGIN_RETRY_LIMIT_EXCEEDED", e.TOKEN_RETRY_LIMIT_EXCEEDED = "TOKEN_RETRY_LIMIT_EXCEEDED", e))(Q || {});
+class D extends Error {
+  constructor(t, r = "", n) {
+    super(), this.code = t, this.message = r, this.cause = n, this.name = "WikiSaikouError";
+  }
+  static is(t, r) {
+    return t instanceof this && (r === void 0 || t.code === r);
+  }
+}
+class H extends Error {
+  constructor(t, r) {
+    super(), this.errors = t, this.cause = r, this.name = "MediaWikiApiError", this.errors = H.normalizeErrors(t), this.message = t.map((n) => n.text).filter(Boolean).join(`
+`), this.code = this.isBadTokenError() ? "badtoken" : this.errors[0]?.code || "Unknown Error";
+  }
+  get firstError() {
+    return this.errors[0];
+  }
+  isBadTokenError() {
+    return this.errors.some((t) => t.code === "badtoken") || ["NeedToken", "WrongToken"].includes(this.cause?.data?.login?.result);
+  }
+  toString() {
+    return `[${this.name} ${this.code}]`;
+  }
+  static is(t) {
+    return t instanceof this;
+  }
+  static normalizeErrors(t) {
+    return Array.isArray(t) === !1 ? [] : t.filter((r) => typeof r == "object" && !!r?.code).map((r) => r.text ? r : r.info ? { ...r, text: r.info } : r["*"] ? { ...r, text: r["*"] } : { ...r, text: "" });
+  }
+}
+((e) => {
+  function t(i) {
+    if (i == null) return;
+    if (i?.response?.data !== void 0) return i.response.data;
+    if (i?.data !== void 0) return i.data;
+    const o = i instanceof Error ? i.cause : void 0;
+    return o?.response?.data !== void 0 ? o.response.data : o?.data !== void 0 ? o.data : i || void 0;
+  }
+  function r(i) {
+    return n(i).length > 0;
+  }
+  e.includesMediaWikiApiError = r, e.normalizeMwApiErrors = H.normalizeErrors;
+  function n(i) {
+    let o = t(i);
+    if (typeof o != "object" || o === null)
+      return [];
+    const u = o?.error, l = o?.errors, h = [];
+    return u && h.push(u), Array.isArray(l) && h.push(...l), (0, e.normalizeMwApiErrors)(h);
+  }
+  e.extractMediaWikiApiErrors = n;
+  function s(i) {
+    if (H.is(i))
+      return i.isBadTokenError();
+    {
+      const o = n(i);
+      return new H(o).isBadTokenError();
+    }
+  }
+  e.isBadTokenError = s;
+})(D || (D = {}));
+const Ee = Symbol.for("__FEXIOS_SAIKOU__");
+function Ue(e) {
+  const t = e instanceof L ? e : new L({
+    baseURL: e instanceof URL ? e.toString() : String(e),
+    responseType: "json"
+  });
+  return t[Ee] || (Reflect.defineProperty(t, Ee, {
+    get: () => !0,
+    enumerable: !1,
+    configurable: !1
+  }), t._tokens = /* @__PURE__ */ new Map(), t.on("afterResponse", (r) => {
+    const { data: n, rawRequest: s } = r, i = s?.headers.get("x-mw-token-name");
+    i && D.isBadTokenError(n) && t._tokens.delete(i);
+    const o = n?.query?.tokens;
+    o && typeof o == "object" && Object.entries(o).forEach(([l, h]) => {
+      typeof h == "string" && t._tokens.set(l.replace(/token$/i, "").toLowerCase(), h);
+    });
+    const u = n?.login?.token;
+    return typeof u == "string" && t._tokens.set("login", u), r;
+  }), t.on("beforeInit", (r) => {
+    if (r.method?.toLowerCase() !== "post")
+      return r;
+    if (r.body === void 0 || r.body === null)
+      return r.body = void 0, r;
+    const n = r.body = ce.normalizeBody(r.body), s = new URLSearchParams(r.query);
+    return n.has("format") && s.delete("format"), n.has("formatversion") && s.delete("formatversion"), n.has("action") && s.delete("action"), n.has("origin") && (s.set("origin", "" + n.get("origin")), n.delete("origin")), r.query = Object.fromEntries(s.entries()), r;
+  }), t.on("beforeInit", (r) => (r.query = ce.normalizeBody(r.query) || {}, r)), t.on("beforeRequest", (r) => {
+    const n = new URL(r.url), s = n.searchParams;
+    if (globalThis.location && (!s.has("origin") && location.origin !== n.origin ? (s.set("origin", location.origin), t.baseConfigs.credentials = "include", t.baseConfigs.mode = "cors") : location.origin === n.origin && (s.delete("origin"), t.baseConfigs.credentials = void 0, t.baseConfigs.mode = void 0)), n.searchParams.has("origin")) {
+      const i = encodeURIComponent(
+        n.searchParams.get("origin") || ""
+      ).replace(/\./g, "%2E");
+      r.query = {}, n.searchParams.delete("origin"), r.url = `${n}${n.search ? "&" : "?"}origin=${i}`;
+    }
+    return r;
+  })), t;
+}
+const W = (e, ...t) => {
+  const r = (i) => Object.prototype.toString.call(i) === "[object Object]", n = (i) => {
+    if (Array.isArray(i)) return i.slice();
+    if (r(i)) {
+      const o = {};
+      for (const u of Reflect.ownKeys(i)) o[u] = n(i[u]);
+      return o;
+    }
+    return i;
+  }, s = n(e);
+  for (const i of t)
+    if (i != null)
+      for (const o of Reflect.ownKeys(i)) {
+        const u = i[o];
+        if (typeof u > "u") continue;
+        const l = s[o];
+        r(l) && r(u) ? s[o] = W(l, u) : s[o] = n(u);
+      }
+  return s;
+}, vt = (e, t, r) => {
+  let n = { ...Ne.DEFAULT_CONFIGS };
+  if (typeof e == "string" ? n = W(n, {
+    baseURL: e,
+    fexiosConfigs: t || {},
+    defaultParams: r || {}
+  }) : typeof e == "object" && e !== null && (n = W(n, e)), !n.baseURL && typeof window == "object" && window.mediaWiki) {
+    const { wgServer: s, wgScriptPath: i } = window.mediaWiki?.config?.get(["wgServer", "wgScriptPath"]) || {};
+    typeof s == "string" && typeof i == "string" && (n.baseURL = `${s}${i}/api.php`);
+  }
+  if (typeof n.baseURL != "string")
+    throw new Error("baseURL is required");
+  return n;
+}, _t = () => {
+}, jt = async (e, t) => {
+  let r = 0;
+  const { retry: n = 3, onRetry: s = _t, shouldRetry: i = () => !0 } = t;
+  let o;
+  do
+    try {
+      return await e();
+    } catch (u) {
+      if (o = u, i(u, r))
+        s(u, r), r++;
+      else
+        throw u;
+    }
+  while (r < n);
+  throw o || new Error("Retry failed");
+};
+const J = class {
+  constructor(t, r, n) {
+    this.version = "7.1.2", this.token = this.getToken;
+    const s = this.config = vt(
+      t,
+      r,
+      n
+    );
+    this.request = Ue(s.baseURL);
+  }
+  setBaseURL(t) {
+    return this.config.baseURL = t, this.request.baseConfigs.baseURL = t, this;
+  }
+  /** Base methods encapsulation */
+  async get(t, r) {
+    return this.runRequestWithApiErrorMapping(
+      () => this.request.get(
+        "",
+        W(
+          {},
+          this.config.fexiosConfigs,
+          { query: W(this.config.defaultParams, t) },
+          r
+        )
+      )
+    );
+  }
+  async post(t, r) {
+    return this.runRequestWithApiErrorMapping(
+      () => this.request.post(
+        "",
+        t,
+        W(
+          {},
+          this.config.fexiosConfigs,
+          {
+            query: this.config.defaultParams
+          },
+          r
+        )
+      )
+    );
+  }
+  /**
+   * Wrap a request to map non-2xx responses containing MediaWiki API error bodies
+   * into MediaWikiApiError when throwOnApiError=true, and then pass 2xx responses
+   * through handleApiResponse for unified processing.
+   */
+  async runRequestWithApiErrorMapping(t) {
+    try {
+      const r = await t();
+      return this.handleApiResponse(r);
+    } catch (r) {
+      throw this.config.throwOnApiError && D.includesMediaWikiApiError(r) ? new H(
+        D.extractMediaWikiApiErrors(r),
+        r
+      ) : r;
+    }
+  }
+  throwIfApiError(t) {
+    const r = D.extractMediaWikiApiErrors(t);
+    if (r.length > 0)
+      throw new H(r, t);
+  }
+  handleApiResponse(t) {
+    return this.config.throwOnApiError && this.throwIfApiError(t.data), t;
+  }
+  /** Token Handler */
+  get tokens() {
+    return this.request._tokens;
+  }
+  async fetchTokens(t = ["csrf"]) {
+    return this.config.fexiosConfigs.credentials = "include", await this.get({
+      action: "query",
+      meta: "tokens",
+      type: t
+    }), this.tokens;
+  }
+  async getToken(t = "csrf", r = !1) {
+    return (!this.tokens.get(t) || r) && (this.tokens.delete(t), await this.fetchTokens([t])), this.tokens.get(t);
+  }
+  badToken(t) {
+    return this.tokens.delete(t), this.tokens;
+  }
+  async postWithToken(t, r, n) {
+    const {
+      tokenName: s = "token",
+      retry: i = 3,
+      noCache: o = !1,
+      fexiosOptions: u
+    } = n || {};
+    if (i < 1)
+      throw new D(
+        Q.TOKEN_RETRY_LIMIT_EXCEEDED,
+        "The limit of the number of times to automatically re-acquire the token has been exceeded"
+      );
+    let l = 0;
+    return jt(
+      async () => {
+        const h = await this.getToken(
+          t,
+          o || l > 0
+        );
+        try {
+          const d = await this.post(
+            {
+              [s]: h,
+              ...r
+            },
+            W(u || {}, {
+              headers: { "x-mw-token-name": t }
+            })
+          );
+          if (D.isBadTokenError(d.data))
+            throw d;
+          return d;
+        } catch (d) {
+          throw D.isBadTokenError(d) || d?.ok === !1 || H.is(d) ? d : new D(
+            Q.HTTP_ERROR,
+            "Network/transport or SDK-internal error (not a MediaWiki API error)",
+            d
+          );
+        }
+      },
+      {
+        retry: i,
+        onRetry: (h, d) => {
+          l = d + 1;
+        },
+        shouldRetry: (h) => D.isBadTokenError(h) || h?.ok === !1
+      }
+    ).catch((h) => {
+      throw D.isBadTokenError(h) || h?.ok === !1 ? new D(
+        Q.TOKEN_RETRY_LIMIT_EXCEEDED,
+        "Retry attempts for acquiring/using token exhausted",
+        h
+      ) : h;
+    });
+  }
+  postWithEditToken(t) {
+    return this.postWithToken("csrf", t);
+  }
+  // for backward compatibility
+  /** @deprecated Use `this.config.baseURL` instead */
+  get baseURL() {
+    return this.config.baseURL;
+  }
+  /** @deprecated Use `this.config.defaultParams` instead */
+  get defaultParams() {
+    return this.config.defaultParams;
+  }
+  /** @deprecated Use `this.config.fexiosConfigs` instead */
+  get defaultOptions() {
+    return this.config.fexiosConfigs;
+  }
+};
+J.INIT_DEFAULT_PARAMS = {
+  action: "query",
+  errorformat: "plaintext",
+  format: "json",
+  formatversion: 2
+}, J.DEFAULT_CONFIGS = {
+  baseURL: void 0,
+  fexiosConfigs: {
+    responseType: "json"
+  },
+  defaultParams: J.INIT_DEFAULT_PARAMS,
+  throwOnApiError: !1
+}, J.createRequestHandler = Ue;
+let Ne = J;
+class Dt extends Ne {
+  async clientLogin(t, r, n) {
+    n ||= {}, !n.logincontinue && !n.loginreturnurl && (n.loginreturnurl = location?.origin);
+    const s = await this.postWithToken(
+      "login",
+      {
+        action: "clientlogin",
+        username: t,
+        password: r,
+        ...n
+      },
+      {
+        tokenName: "logintoken"
+      }
+    );
+    if (s?.data?.clientlogin?.status === "PASS")
+      return s.data.clientlogin;
+    throw new D(
+      Q.LOGIN_FAILED,
+      s.data.clientlogin.message,
+      s
+    );
+  }
+}
+const Ct = (e, t = document) => t.querySelector(e), It = (e, t = document) => t.querySelectorAll(e), Be = (e) => typeof e == "function";
+async function Ut(e) {
+  return Be(e) ? await e() : e;
+}
+function Nt(e) {
+  return Be(e) ? e() : e;
+}
+var Lt = /* @__PURE__ */ ((e) => (e.ANALYTICS_API_BASE = "https://analytics.ipe.wiki/api/v6", e.ANALYTICS_DASH_URL = "https://analytics.ipe.wiki", e.GITHUB_URL = "https://github.com/inpageedit/inpageedit-next", e.GITHUB_OWNER = "inpageedit", e.GITHUB_REPO = "inpageedit-next", e.HOME_URL = "https://www.ipe.wiki/", e.UPDATE_LOGS_URL = "https://www.ipe.wiki/changelogs/", e.PLUGIN_REGISTRY_URL = "https://registry.ipe.wiki/registry.v1.json", e.I18N_INDEX_URL = "https://registry.ipe.wiki/i18n/index.json", e.QQ_GROUP_ID = "1026023666", e))(Lt || {});
+function qe(e) {
+  return e.charAt(0).toLowerCase() + e.slice(1);
+}
+function Bt(e) {
+  return qe(e).replace(/_/g, "-").replace(/.[A-Z]+/g, (t) => t[0] + "-" + t.slice(1).toLowerCase());
+}
+function qt(e) {
+  return qe(e).replace(/-/g, "_").replace(/.[A-Z]+/g, (t) => t[0] + "_" + t.slice(1).toLowerCase());
+}
+function Mt(e) {
+  return function(t) {
+    return t.PreferencesSchema = e, t;
+  };
+}
+export {
+  pe as C,
+  Lt as E,
+  ht as F,
+  Dt as G,
+  se as I,
+  Se as M,
+  Mt as R,
+  Pt as S,
+  H as T,
+  re as U,
+  $e as a,
+  lt as b,
+  Tt as c,
+  He as d,
+  ut as e,
+  qt as f,
+  Nt as g,
+  It as h,
+  Ut as i,
+  I as j,
+  Bt as p,
+  Ct as q,
+  m as s
+};
+//# sourceMappingURL=Preferences-C10tZMl1.js.map