@inpageedit/core 0.14.4 → 0.15.0

package/dist/Preferences-DqtjY7XU.js

@@ -0,0 +1,1541 @@
+const ke = () => {
+  let e, t;
+  return { promise: new Promise((n, c) => {
+    e = n, t = c;
+  }), resolve: e, reject: t };
+};
+Promise.withResolvers || (Promise.withResolvers = ke);
+var ve = Object.defineProperty, w = (e, t) => ve(e, "name", { value: t, configurable: !0 });
+function Oe() {
+}
+w(Oe, "noop");
+function $(e) {
+  return e == null;
+}
+w($, "isNullable");
+function Se(e) {
+  return !$(e);
+}
+w(Se, "isNonNullable");
+function J(e) {
+  return e && typeof e == "object" && !Array.isArray(e);
+}
+w(J, "isPlainObject");
+function fe(e, t) {
+  return Object.fromEntries(Object.entries(e).filter(([r, n]) => t(r, n)));
+}
+w(fe, "filterKeys");
+function C(e, t) {
+  return Object.fromEntries(Object.entries(e).map(([r, n]) => [r, t(n, r)]));
+}
+w(C, "mapValues");
+function ae(e, t, r) {
+  if (!t) return { ...e };
+  const n = {};
+  for (const c of t)
+    (r || e[c] !== void 0) && (n[c] = e[c]);
+  return n;
+}
+w(ae, "pick");
+function je(e, t) {
+  if (!t) return { ...e };
+  const r = { ...e };
+  for (const n of t)
+    Reflect.deleteProperty(r, n);
+  return r;
+}
+w(je, "omit");
+function _(e, t, r) {
+  return Object.defineProperty(e, t, { writable: !0, value: r, enumerable: !1 });
+}
+w(_, "defineProperty");
+function $e(e, t) {
+  return t.every((r) => e.includes(r));
+}
+w($e, "contain");
+function Ae(e, t) {
+  return e.filter((r) => t.includes(r));
+}
+w(Ae, "intersection");
+function _e(e, t) {
+  return e.filter((r) => !t.includes(r));
+}
+w(_e, "difference");
+function Re(e, t) {
+  return Array.from(/* @__PURE__ */ new Set([...e, ...t]));
+}
+w(Re, "union");
+function Pe(e) {
+  return [...new Set(e)];
+}
+w(Pe, "deduplicate");
+function N(e, t) {
+  const r = e?.indexOf(t);
+  return r >= 0 ? (e.splice(r, 1), !0) : !1;
+}
+w(N, "remove");
+function Ee(e) {
+  return Array.isArray(e) ? e : $(e) ? [] : [e];
+}
+w(Ee, "makeArray");
+function I(e, t) {
+  return arguments.length === 1 ? (r) => I(e, r) : e in globalThis && t instanceof globalThis[e] || Object.prototype.toString.call(t).slice(8, -1) === e;
+}
+w(I, "is");
+function M(e) {
+  return I("ArrayBuffer", e) || I("SharedArrayBuffer", e);
+}
+w(M, "isArrayBufferLike");
+function ue(e) {
+  return M(e) || ArrayBuffer.isView(e);
+}
+w(ue, "isArrayBufferSource");
+var E;
+((e) => {
+  e.is = M, e.isSource = ue;
+  function t(a) {
+    return ArrayBuffer.isView(a) ? a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength) : a;
+  }
+  e.fromSource = t, w(t, "fromSource");
+  function r(a) {
+    if (typeof Buffer < "u")
+      return Buffer.from(a).toString("base64");
+    let y = "";
+    const d = new Uint8Array(a);
+    for (let b = 0; b < d.byteLength; b++)
+      y += String.fromCharCode(d[b]);
+    return btoa(y);
+  }
+  e.toBase64 = r, w(r, "toBase64");
+  function n(a) {
+    return typeof Buffer < "u" ? t(Buffer.from(a, "base64")) : Uint8Array.from(atob(a), (y) => y.charCodeAt(0));
+  }
+  e.fromBase64 = n, w(n, "fromBase64");
+  function c(a) {
+    return typeof Buffer < "u" ? Buffer.from(a).toString("hex") : Array.from(new Uint8Array(a), (y) => y.toString(16).padStart(2, "0")).join("");
+  }
+  e.toHex = c, w(c, "toHex");
+  function i(a) {
+    if (typeof Buffer < "u") return t(Buffer.from(a, "hex"));
+    const y = a.length % 2 === 0 ? a : a.slice(0, a.length - 1), d = [];
+    for (let b = 0; b < y.length; b += 2)
+      d.push(parseInt(`${y[b]}${y[b + 1]}`, 16));
+    return Uint8Array.from(d).buffer;
+  }
+  e.fromHex = i, w(i, "fromHex");
+})(E || (E = {}));
+E.fromBase64;
+E.toBase64;
+E.fromHex;
+E.toHex;
+function V(e, t = /* @__PURE__ */ new Map()) {
+  if (!e || typeof e != "object") return e;
+  if (I("Date", e)) return new Date(e.valueOf());
+  if (I("RegExp", e)) return new RegExp(e.source, e.flags);
+  if (M(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 c = [];
+    return t.set(e, c), e.forEach((i, a) => {
+      c[a] = Reflect.apply(V, null, [i, t]);
+    }), c;
+  }
+  const n = Object.create(Object.getPrototypeOf(e));
+  t.set(e, n);
+  for (const c of Reflect.ownKeys(e)) {
+    const i = { ...Reflect.getOwnPropertyDescriptor(e, c) };
+    "value" in i && (i.value = Reflect.apply(V, null, [i.value, t])), Reflect.defineProperty(n, c, i);
+  }
+  return n;
+}
+w(V, "clone");
+function B(e, t, r) {
+  if (e === t || !r && $(e) && $(t)) return !0;
+  if (typeof e != typeof t || typeof e != "object" || !e || !t) return !1;
+  function n(c, i) {
+    return c(e) ? c(t) ? i(e, t) : !1 : c(t) ? !1 : void 0;
+  }
+  return w(n, "check"), n(Array.isArray, (c, i) => c.length === i.length && c.every((a, y) => B(a, i[y]))) ?? n(I("Date"), (c, i) => c.valueOf() === i.valueOf()) ?? n(I("RegExp"), (c, i) => c.source === i.source && c.flags === i.flags) ?? n(M, (c, i) => {
+    if (c.byteLength !== i.byteLength) return !1;
+    const a = new Uint8Array(c), y = new Uint8Array(i);
+    for (let d = 0; d < a.length; d++)
+      if (a[d] !== y[d]) return !1;
+    return !0;
+  }) ?? Object.keys({ ...e, ...t }).every((c) => B(e[c], t[c], r));
+}
+w(B, "deepEqual");
+function De(e) {
+  return e.charAt(0).toUpperCase() + e.slice(1);
+}
+w(De, "capitalize");
+function Ce(e) {
+  return e.charAt(0).toLowerCase() + e.slice(1);
+}
+w(Ce, "uncapitalize");
+function Ne(e) {
+  return e.replace(/[_-][a-z]/g, (t) => t.slice(1).toUpperCase());
+}
+w(Ne, "camelCase");
+function X(e, t, r) {
+  const n = [];
+  let c = 0;
+  for (let i = 0; i < e.length; i++) {
+    const a = e.charCodeAt(i);
+    if (a >= 65 && a <= 90) {
+      if (c === 1) {
+        const y = e.charCodeAt(i + 1);
+        y >= 97 && y <= 122 && n.push(r), n.push(a + 32);
+      } else
+        c !== 0 && n.push(r), n.push(a + 32);
+      c = 1;
+    } else a >= 97 && a <= 122 ? (n.push(a), c = 2) : t.includes(a) ? (c !== 0 && n.push(r), c = 0) : n.push(a);
+  }
+  return String.fromCharCode(...n);
+}
+w(X, "tokenize");
+function Ie(e) {
+  return X(e, [45, 95], 45);
+}
+w(Ie, "paramCase");
+function Be(e) {
+  return X(e, [45, 95], 95);
+}
+w(Be, "snakeCase");
+function Fe(e) {
+  return typeof e != "string" ? `[${e.toString()}]` : /^[a-z_$][\w$]*$/i.test(e) ? `.${e}` : `[${JSON.stringify(e)}]`;
+}
+w(Fe, "formatProperty");
+function le(e) {
+  return e.replace(/\/$/, "");
+}
+w(le, "trimSlash");
+function Ue(e) {
+  return e.startsWith("/") || (e = "/" + e), le(e);
+}
+w(Ue, "sanitize");
+var se;
+((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(x) {
+    t = x;
+  }
+  e.setTimezoneOffset = r, w(r, "setTimezoneOffset");
+  function n() {
+    return t;
+  }
+  e.getTimezoneOffset = n, w(n, "getTimezoneOffset");
+  function c(x = /* @__PURE__ */ new Date(), k) {
+    return typeof x == "number" && (x = new Date(x)), k === void 0 && (k = t), Math.floor((x.valueOf() / e.minute - k) / 1440);
+  }
+  e.getDateNumber = c, w(c, "getDateNumber");
+  function i(x, k) {
+    const F = new Date(x * e.day);
+    return k === void 0 && (k = t), new Date(+F + k * e.minute);
+  }
+  e.fromDateNumber = i, w(i, "fromDateNumber");
+  const a = /\d+(?:\.\d+)?/.source, y = new RegExp(`^${[
+    "w(?:eek(?:s)?)?",
+    "d(?:ay(?:s)?)?",
+    "h(?:our(?:s)?)?",
+    "m(?:in(?:ute)?(?:s)?)?",
+    "s(?:ec(?:ond)?(?:s)?)?"
+  ].map((x) => `(${a}${x})?`).join("")}$`);
+  function d(x) {
+    const k = y.exec(x);
+    return k ? (parseFloat(k[1]) * e.week || 0) + (parseFloat(k[2]) * e.day || 0) + (parseFloat(k[3]) * e.hour || 0) + (parseFloat(k[4]) * e.minute || 0) + (parseFloat(k[5]) * e.second || 0) : 0;
+  }
+  e.parseTime = d, w(d, "parseTime");
+  function b(x) {
+    const k = d(x);
+    return k ? x = Date.now() + k : /^\d{1,2}(:\d{1,2}){1,2}$/.test(x) ? x = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${x}` : /^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(x) && (x = `${(/* @__PURE__ */ new Date()).getFullYear()}-${x}`), x ? new Date(x) : /* @__PURE__ */ new Date();
+  }
+  e.parseDate = b, w(b, "parseDate");
+  function j(x) {
+    const k = Math.abs(x);
+    return k >= e.day - e.hour / 2 ? Math.round(x / e.day) + "d" : k >= e.hour - e.minute / 2 ? Math.round(x / e.hour) + "h" : k >= e.minute - e.second / 2 ? Math.round(x / e.minute) + "m" : k >= e.second ? Math.round(x / e.second) + "s" : x + "ms";
+  }
+  e.format = j, w(j, "format");
+  function O(x, k = 2) {
+    return x.toString().padStart(k, "0");
+  }
+  e.toDigits = O, w(O, "toDigits");
+  function R(x, k = /* @__PURE__ */ new Date()) {
+    return x.replace("yyyy", k.getFullYear().toString()).replace("yy", k.getFullYear().toString().slice(2)).replace("MM", O(k.getMonth() + 1)).replace("dd", O(k.getDate())).replace("hh", O(k.getHours())).replace("mm", O(k.getMinutes())).replace("ss", O(k.getSeconds())).replace("SSS", O(k.getMilliseconds(), 3));
+  }
+  e.template = R, w(R, "template");
+})(se || (se = {}));
+var ze = Object.defineProperty, g = (e, t) => ze(e, "name", { value: t, configurable: !0 }), h = {
+  // 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")
+}, Le = function* () {
+}.constructor, oe = async function* () {
+}.constructor;
+function ee(e) {
+  return !(!e.prototype || e instanceof Le || oe !== Function && e instanceof oe);
+}
+g(ee, "isConstructor");
+function q(e, t) {
+  const r = e.Config || e.schema;
+  return r && e.schema !== !1 && (t = r(t)), t ?? {};
+}
+g(q, "resolveConfig");
+function he(e) {
+  return [Map, Set, Date, Promise].some((t) => e instanceof t);
+}
+g(he, "isUnproxyable");
+function te(e, t) {
+  if (e === Object.prototype) return t;
+  const r = Object.create(te(Object.getPrototypeOf(e), t));
+  for (const n of Reflect.ownKeys(e))
+    Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(e, n));
+  return r;
+}
+g(te, "joinPrototype");
+function re(e) {
+  return e && (typeof e == "object" || typeof e == "function");
+}
+g(re, "isObject");
+function D(e, t, r) {
+  if (!re(t)) return t;
+  if (Object.hasOwn(t, h.shadow))
+    return Object.getPrototypeOf(t);
+  const n = t[h.tracker];
+  return n ? G(e, t, n, r) : t;
+}
+g(D, "getTraceable");
+function L(e, t) {
+  return t ? new Proxy(e, {
+    get: /* @__PURE__ */ g((r, n, c) => n in t && n !== "constructor" ? Reflect.get(t, n, c) : Reflect.get(r, n, c), "get"),
+    set: /* @__PURE__ */ g((r, n, c, i) => n in t && n !== "constructor" ? Reflect.set(t, n, c, i) : Reflect.set(r, n, c, i), "set")
+  }) : e;
+}
+g(L, "withProps");
+function H(e, t, r) {
+  return L(e, Object.defineProperty(/* @__PURE__ */ Object.create(null), t, {
+    value: r,
+    writable: !1
+  }));
+}
+g(H, "withProp");
+function W(e, t, r, n) {
+  if (!r) return n;
+  const c = Reflect.getOwnPropertyDescriptor(t, r)?.value;
+  return c ? H(n, r, e.extend({ [h.shadow]: c })) : n;
+}
+g(W, "createShadow");
+function pe(e, t, r, n) {
+  return new Proxy(t, {
+    apply: /* @__PURE__ */ g((c, i, a) => (i === r && (i = n), a = a.map((y) => typeof y != "function" || y[h.original] ? y : new Proxy(y, {
+      get: /* @__PURE__ */ g((d, b, j) => {
+        if (b === h.original) return d;
+        const O = Reflect.get(d, b, j);
+        return b === "toString" && O === Function.prototype.toString ? function(...R) {
+          return Reflect.apply(O, this === j ? d : this, R);
+        } : O;
+      }, "get"),
+      apply: /* @__PURE__ */ g((d, b, j) => Reflect.apply(d, D(e, b), j.map((O) => D(e, O))), "apply"),
+      construct: /* @__PURE__ */ g((d, b, j) => Reflect.construct(d, b.map((O) => D(e, O)), j), "construct")
+    })), D(e, Reflect.apply(c, i, a))), "apply")
+  });
+}
+g(pe, "createShadowMethod");
+function G(e, t, r, n) {
+  e[h.shadow] && (e = Object.getPrototypeOf(e));
+  const c = new Proxy(t, {
+    get: /* @__PURE__ */ g((i, a, y) => {
+      if (a === h.original) return i;
+      if (a === r.property) return e;
+      if (typeof a == "symbol")
+        return Reflect.get(i, a, y);
+      if (r.associate && e[h.internal][`${r.associate}.${a}`])
+        return Reflect.get(e, `${r.associate}.${a}`, H(e, h.receiver, y));
+      const d = W(e, i, r.property, y), b = Reflect.get(i, a, d), j = b?.[h.tracker];
+      return j ? G(e, b, j) : !n && typeof b == "function" ? pe(e, b, y, d) : b;
+    }, "get"),
+    set: /* @__PURE__ */ g((i, a, y, d) => {
+      if (a === h.original || a === r.property) return !1;
+      if (typeof a == "symbol")
+        return Reflect.set(i, a, y, d);
+      if (r.associate && e[h.internal][`${r.associate}.${a}`])
+        return Reflect.set(e, `${r.associate}.${a}`, y, H(e, h.receiver, d));
+      const b = W(e, i, r.property, d);
+      return Reflect.set(i, a, y, b);
+    }, "set"),
+    apply: /* @__PURE__ */ g((i, a, y) => ne(c, i, a, y), "apply")
+  });
+  return c;
+}
+g(G, "createTraceable");
+function ne(e, t, r, n) {
+  return t[h.invoke] ? t[h.invoke].apply(e, n) : Reflect.apply(t, r, n);
+}
+g(ne, "applyTraceable");
+function Y(e, t, r) {
+  const n = /* @__PURE__ */ g(function(...c) {
+    const i = G(n.ctx, n, r);
+    return ne(i, n, this, c);
+  }, "self");
+  return _(n, "name", e), Object.setPrototypeOf(n, t);
+}
+g(Y, "createCallable");
+var Me = class U {
+  constructor(t) {
+    this.ctx = t, _(this, h.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 {
+    g(this, "ReflectService");
+  }
+  static resolveInject(t, r) {
+    let n = t[h.internal][r];
+    for (; n?.type === "alias"; )
+      r = n.name, n = t[h.internal][r];
+    return [r, n];
+  }
+  static checkInject(t, r, n) {
+    if (t = t[h.shadow] ?? t, ["prototype", "then", "registry", "lifecycle"].includes(r) || r[0] === "$" || r[0] === "_" || !t.runtime.plugin || t.bail(t, "internal/inject", r)) return;
+    const c = n.stack.split(`
+`);
+    c.splice(1, 1), n.stack = c.join(`
+`), t.emit(t, "internal/warning", n);
+  }
+  static handler = {
+    get: /* @__PURE__ */ g((t, r, n) => {
+      if (typeof r != "string") return Reflect.get(t, r, n);
+      if (Reflect.has(t, r))
+        return D(n, Reflect.get(t, r, n), !0);
+      const [c, i] = U.resolveInject(t, r), a = new Error(`property ${c} is not registered, declare it as \`inject\` to suppress this warning`);
+      return i ? i.type === "accessor" ? i.get.call(n, n[h.receiver]) : (i.builtin || U.checkInject(n, c, a), n.reflect.get(c)) : (U.checkInject(n, c, a), Reflect.get(t, c, n));
+    }, "get"),
+    set: /* @__PURE__ */ g((t, r, n, c) => {
+      if (typeof r != "string") return Reflect.set(t, r, n, c);
+      const [i, a] = U.resolveInject(t, r);
+      return a ? a.type === "accessor" ? a.set ? a.set.call(c, n, c[h.receiver]) : !1 : (c.reflect.set(i, n), !0) : Reflect.set(t, i, n, c);
+    }, "set"),
+    has: /* @__PURE__ */ g((t, r) => {
+      if (typeof r != "string") return Reflect.has(t, r);
+      if (Reflect.has(t, r)) return !0;
+      const [, n] = U.resolveInject(t, r);
+      return !!n;
+    }, "has")
+  };
+  get(t) {
+    if (this.ctx[h.internal][t]?.type !== "service") return;
+    const n = this.ctx[h.isolate][t], c = this.ctx[h.store][n]?.value;
+    return D(this.ctx, c);
+  }
+  set(t, r) {
+    this.provide(t);
+    const n = this.ctx[h.isolate][t], c = this.ctx[h.store][n]?.value;
+    r ??= void 0;
+    let i = /* @__PURE__ */ g(() => {
+    }, "dispose");
+    if (c === r) return i;
+    if (!$(r) && !$(c))
+      throw new Error(`service ${t} has been registered`);
+    const a = this.ctx;
+    $(r) || (i = a.effect(() => () => {
+      a.set(t, void 0);
+    })), he(r) && a.emit(a, "internal/warning", new Error(`service ${t} is an unproxyable object, which may lead to unexpected behavior`));
+    const y = Object.create(a);
+    return y[h.filter] = (d) => a[h.isolate][t] === d[h.isolate][t], a.emit(y, "internal/before-service", t, r), a[h.store][n] = { value: r, source: a }, a.emit(y, "internal/service", t, c), i;
+  }
+  provide(t, r, n) {
+    const c = this.ctx.root[h.internal];
+    if (t in c) return;
+    const i = Symbol(t);
+    c[t] = { type: "service", builtin: n }, this.ctx.root[h.isolate][t] = i, re(r) && (this.ctx[h.store][i] = { value: r, source: null }, _(r, h.tracker, {
+      associate: t,
+      property: "ctx"
+    }));
+  }
+  _accessor(t, r) {
+    const n = this.ctx.root[h.internal];
+    return t in n ? () => {
+    } : (n[t] = { type: "accessor", ...r }, () => delete this.ctx.root[h.isolate][t]);
+  }
+  accessor(t, r) {
+    this.ctx.scope.effect(() => this._accessor(t, r));
+  }
+  alias(t, r) {
+    const n = this.ctx.root[h.internal];
+    if (!(t in n))
+      for (const c of r)
+        n[c] ||= { type: "alias", name: t };
+  }
+  _mixin(t, r) {
+    const n = Array.isArray(r) ? r.map((a) => [a, a]) : Object.entries(r), c = typeof t == "string" ? (a) => a[t] : () => t, i = n.map(([a, y]) => this._accessor(y, {
+      get(d) {
+        const b = c(this);
+        if ($(b)) return b;
+        const j = d ? L(d, b) : b, O = Reflect.get(b, a, j);
+        return typeof O != "function" ? O : O.bind(j ?? b);
+      },
+      set(d, b) {
+        const j = c(this), O = b ? L(b, j) : j;
+        return Reflect.set(j, a, d, O);
+      }
+    }));
+    return () => i.forEach((a) => a());
+  }
+  mixin(t, r) {
+    this.ctx.scope.effect(() => this._mixin(t, r));
+  }
+  trace(t) {
+    return D(this.ctx, t);
+  }
+  bind(t) {
+    return new Proxy(t, {
+      apply: /* @__PURE__ */ g((r, n, c) => r.apply(this.trace(n), c.map((i) => this.trace(i))), "apply")
+    });
+  }
+}, Q = Me;
+function Z(e) {
+  return e !== null && e !== !1 && e !== void 0;
+}
+g(Z, "isBailed");
+var qe = class {
+  constructor(e) {
+    this.ctx = e, _(this, h.tracker, {
+      associate: "lifecycle",
+      property: "ctx"
+    }), _(this.on("internal/listener", function(r, n, c) {
+      const i = c.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), _(n, "name", "event <dispose>"), () => N(this.scope.disposables, n);
+      if (r === "fork")
+        return this.scope.runtime.forkables[i](n), this.scope.collect("event <fork>", () => N(this.scope.runtime.forkables, n));
+    }), P.static, e.scope);
+    for (const r of ["info", "error", "warning"])
+      _(this.on(`internal/${r}`, (n, ...c) => {
+        this._hooks[`internal/${r}`].length > 1;
+      }), P.static, e.scope);
+    _(this.on("internal/before-service", function(r) {
+      for (const n of this.registry.values()) {
+        if (!n.inject[r]?.required) continue;
+        const c = n.isReusable ? n.children : [n];
+        for (const i of c)
+          this[h.filter](i.ctx) && (i.updateStatus(), i.reset());
+      }
+    }, { global: !0 }), P.static, e.scope), _(this.on("internal/service", function(r) {
+      for (const n of this.registry.values()) {
+        if (!n.inject[r]?.required) continue;
+        const c = n.isReusable ? n.children : [n];
+        for (const i of c)
+          this[h.filter](i.ctx) && i.start();
+      }
+    }, { global: !0 }), P.static, e.scope);
+    const t = /* @__PURE__ */ g((r, n) => {
+      if (!r.runtime.plugin) return !1;
+      for (const c in r.runtime.inject)
+        if (n === Q.resolveInject(r.ctx, c)[0]) return !0;
+      return t(r.parent.scope, n);
+    }, "checkInject");
+    _(this.on("internal/inject", function(r) {
+      return t(this.scope, r);
+    }, { global: !0 }), P.static, e.scope);
+  }
+  static {
+    g(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 = D(this.ctx, t), e.slice().filter((r) => {
+      const n = t?.[P.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 c of this.filterHooks(this._hooks[n] || [], r))
+      yield c.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 (Z(t)) return t;
+  }
+  bail(...e) {
+    for (const t of this.dispatch("bail", e))
+      if (Z(t)) return t;
+  }
+  register(e, t, r, n) {
+    const c = n.prepend ? "unshift" : "push";
+    return t[c]({ 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 c = this._hooks[e] ||= [], i = typeof e == "string" ? `event <${e}>` : "event (Symbol)";
+    return this.register(i, c, t, r);
+  }
+  once(e, t, r) {
+    const n = this.on(e, function(...c) {
+      return n(), t.apply(this, c);
+    }, 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();
+  }
+}, Je = qe, Ve = /* @__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))(Ve || {}), T = class ye extends Error {
+  constructor(t, r) {
+    super(r ?? ye.Code[t]), this.code = t;
+  }
+  static {
+    g(this, "CordisError");
+  }
+};
+((e) => {
+  e.Code = {
+    INACTIVE_EFFECT: "cannot create effect on inactive context"
+  };
+})(T || (T = {}));
+var de = 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__ */ g((r, n) => Reflect.get(this.config, n), "get")
+    });
+  }
+  static {
+    g(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 T("INACTIVE_EFFECT");
+  }
+  effect(e, t) {
+    this.assertActive();
+    const r = ee(e) ? new e(this.ctx, t) : e(this.ctx, t);
+    let n = !1;
+    const c = typeof r == "function" ? r : r.dispose.bind(r), i = /* @__PURE__ */ g((...a) => {
+      if (!n)
+        return n = !0, N(this.disposables, i), c(...a);
+    }, "wrapped");
+    return this.disposables.push(i), typeof r == "function" ? i : (r.dispose = i, r);
+  }
+  collect(e, t) {
+    const r = _(() => (N(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 || !$(this.ctx.get(e)));
+  }
+  reset() {
+    this.isActive = !1, this.disposables = this.disposables.splice(0).filter((e) => {
+      if (this.uid !== null && e[P.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), () => N(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__ */ g((d) => {
+      const b = r[d] ??= !B(this.config[d], e[d]);
+      return i ||= b, b;
+    }, "checkPropertyUpdate"), c = /* @__PURE__ */ new Set();
+    let i = !1, a = !1, y = this.runtime.isReactive || null;
+    for (const { keys: d, callback: b, passive: j } of this.acceptors) {
+      if (!d)
+        y ||= !j;
+      else if (j)
+        d?.forEach((R) => c.add(R));
+      else {
+        let R = !1;
+        for (const x of d)
+          R ||= n(x);
+        if (!R) continue;
+      }
+      b?.(e) && (a = !0);
+    }
+    for (const d in { ...this.config, ...e })
+      if (y !== !1 && !(d in r) && !c.has(d)) {
+        const b = n(d);
+        y === null && (a ||= b);
+      }
+    return [i, a];
+  }
+}, He = class extends de {
+  constructor(e, t, r, n) {
+    super(e, r), this.runtime = t, this.dispose = _(e.scope.collect(`fork <${e.runtime.name}>`, () => {
+      this.uid = null, this.reset(), this.context.emit("internal/fork", this);
+      const c = N(t.disposables, this.dispose);
+      return N(t.children, this) && !t.children.length && e.registry.delete(t.plugin), c;
+    }), P.static, t), t.children.push(this), t.disposables.push(this.dispose), this.context.emit("internal/fork", this), this.init(n);
+  }
+  static {
+    g(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 c;
+    try {
+      c = q(this.runtime.plugin, e);
+    } catch (y) {
+      return this.context.emit("internal/error", y), this.cancel(y);
+    }
+    const [i, a] = n.checkUpdate(c, t);
+    this.context.emit("internal/before-update", this, e), this.config = c, n.config = c, i && this.context.emit("internal/update", this, r), a && n.restart();
+  }
+}, ce = class extends de {
+  constructor(e, t, r, n) {
+    super(e, r), this.plugin = t, t ? (this.setup(), this.init(n)) : (this.name = "root", this.isActive = !0);
+  }
+  static {
+    g(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 He(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 = K.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__ */ g((e, t) => {
+    if (typeof this.plugin != "function")
+      return this.plugin.apply(e, t);
+    if (ee(this.plugin)) {
+      const r = new this.plugin(e, t), n = r[P.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 y = new Error(`attempting to update forkable plugin "${this.plugin.name}", which may lead to unexpected behavior`);
+      this.context.emit(this.ctx, "internal/warning", y);
+    }
+    const r = this.config;
+    let n;
+    try {
+      n = q(this.runtime.plugin || this.context.constructor, e);
+    } catch (y) {
+      return this.context.emit("internal/error", y), this.cancel(y);
+    }
+    const [c, i] = this.checkUpdate(n, t), a = this.children.find((y) => y.config === r);
+    this.config = n, a && (this.context.emit("internal/before-update", a, e), a.config = n, c && this.context.emit("internal/update", a, r)), i && this.restart();
+  }
+};
+function me(e) {
+  return e && typeof e == "object" && typeof e.apply == "function";
+}
+g(me, "isApplicable");
+function K(e) {
+  return function(t, r) {
+    if (r.kind === "class")
+      t.inject = e;
+    else if (r.kind === "method")
+      r.addInitializer(function() {
+        const n = this[h.tracker]?.property;
+        if (!n) throw new Error("missing context tracker");
+        this[n].inject(e, (c) => {
+          t.call(L(this, { [n]: c }));
+        });
+      });
+    else
+      throw new Error("@Inject can only be used on class or class methods");
+  };
+}
+g(K, "Inject");
+((e) => {
+  function t(r) {
+    if (!r) return {};
+    if (Array.isArray(r))
+      return Object.fromEntries(r.map((a) => [a, { required: !0 }]));
+    const { required: n, optional: c, ...i } = r;
+    return Array.isArray(n) && Object.assign(i, Object.fromEntries(n.map((a) => [a, { required: !0 }]))), Array.isArray(c) && Object.assign(i, Object.fromEntries(c.map((a) => [a, { required: !1 }]))), i;
+  }
+  e.resolve = t, g(t, "resolve");
+})(K || (K = {}));
+var Ke = class {
+  constructor(e, t) {
+    this.ctx = e, _(this, h.tracker, {
+      associate: "registry",
+      property: "ctx"
+    }), this.context = e;
+    const r = new ce(e, null, t);
+    e.scope = r, r.ctx = e, this.set(null, r);
+  }
+  static {
+    g(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 (me(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 = q(e, t);
+      } catch (c) {
+        this.context.emit(this.ctx, "internal/error", c), r = c, 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 ce(this.ctx, e, t, r), this.set(e, n), n.fork(this.ctx, t, r));
+  }
+}, Ge = Ke, P = class z {
+  static {
+    g(this, "Context");
+  }
+  static store = h.store;
+  static events = h.events;
+  static static = h.static;
+  static filter = h.filter;
+  static expose = h.expose;
+  static isolate = h.isolate;
+  static internal = h.internal;
+  static intercept = h.intercept;
+  static origin = "ctx";
+  static current = "ctx";
+  static is(t) {
+    return !!t?.[z.is];
+  }
+  static {
+    z.is[Symbol.toPrimitive] = () => Symbol.for("cordis.is"), z.prototype[z.is] = !0;
+  }
+  /** @deprecated use `Service.traceable` instead */
+  static associate(t, r) {
+    return t;
+  }
+  constructor(t) {
+    t = q(this.constructor, t), this[h.store] = /* @__PURE__ */ Object.create(null), this[h.isolate] = /* @__PURE__ */ Object.create(null), this[h.internal] = /* @__PURE__ */ Object.create(null), this[h.intercept] = /* @__PURE__ */ Object.create(null);
+    const r = new Proxy(this, Q.handler);
+    r.root = r, r.reflect = new Q(r), r.registry = new Ge(r, t), r.lifecycle = new Je(r);
+    const n = /* @__PURE__ */ g((c) => {
+      if (c) {
+        n(Object.getPrototypeOf(c));
+        for (const i of Object.getOwnPropertyNames(c)) {
+          const a = c[i].prototype?.constructor;
+          a && (r[c[i].key] = new a(r, t), _(r[c[i].key], "ctx", r));
+        }
+      }
+    }, "attach");
+    return n(this[h.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, h.shadow)?.value, n = Object.assign(Object.create(D(this, this)), t);
+    return r ? Object.assign(Object.create(n), { [h.shadow]: r }) : n;
+  }
+  isolate(t, r) {
+    const n = Object.create(this[h.isolate]);
+    return n[t] = r ?? Symbol(t), this.extend({ [h.isolate]: n });
+  }
+  intercept(t, r) {
+    const n = Object.create(this[h.intercept]);
+    return n[t] = r, this.extend({ [h.intercept]: n });
+  }
+};
+P.prototype[P.internal] = /* @__PURE__ */ Object.create(null);
+var Xe = class be {
+  static {
+    g(this, "Service");
+  }
+  static setup = h.setup;
+  static invoke = h.invoke;
+  static extend = h.extend;
+  static tracker = h.tracker;
+  static provide = h.provide;
+  static immediate = h.immediate;
+  start() {
+  }
+  stop() {
+  }
+  ctx;
+  name;
+  config;
+  constructor(...t) {
+    let r, n, c, i;
+    P.is(t[0]) ? (r = t[0], typeof t[1] == "string" ? (n = t[1], c = t[2]) : i = t[1]) : i = t[0], n ??= this.constructor[h.provide], c ??= this.constructor[h.immediate];
+    let a = this;
+    const y = {
+      associate: n,
+      property: "ctx"
+    };
+    return a[h.invoke] && (a = Y(n, te(Object.getPrototypeOf(this), Function.prototype), y)), r ? a.ctx = r : a[h.setup](), a.name = n, a.config = i, _(a, h.tracker, y), a.ctx.provide(n), a.ctx.runtime.name = n, c && (r ? a[h.expose] = n : a.ctx.set(n, a)), a.ctx.on("ready", async () => {
+      await Promise.resolve(), await a.start(), c || a.ctx.set(n, a);
+    }), a.ctx.on("dispose", () => a.stop()), a;
+  }
+  [h.filter](t) {
+    return t[h.isolate][this.name] === this.ctx[h.isolate][this.name];
+  }
+  [h.setup]() {
+    this.ctx = new P();
+  }
+  [h.extend](t) {
+    let r;
+    return this[be.invoke] ? r = Y(this.name, this, this[h.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;
+  }
+}, We = Object.defineProperty, Ye = Object.getOwnPropertyNames, v = (e, t) => We(e, "name", { value: t, configurable: !0 }), Qe = (e, t) => function() {
+  return t || (0, e[Ye(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, Ze = Qe({
+  "src/index.ts"(e, t) {
+    var r = Symbol.for("schemastery"), n = Symbol.for("ValidationError");
+    globalThis.__schemastery_index__ ??= 0;
+    var c = class extends TypeError {
+      constructor(o, s) {
+        let f = "$";
+        for (const u of s.path || [])
+          typeof u == "string" ? f += "." + u : typeof u == "number" ? f += "[" + u + "]" : typeof u == "symbol" && (f += `[Symbol(${u.toString()})]`);
+        f.startsWith(".") && (f = f.slice(1)), super((f === "$" ? "" : `${f} `) + o), this.options = s;
+      }
+      static {
+        v(this, "ValidationError");
+      }
+      name = "ValidationError";
+      static is(o) {
+        return !!o?.[n];
+      }
+    };
+    Object.defineProperty(c.prototype, n, {
+      value: !0
+    });
+    var i = /* @__PURE__ */ v(function(o) {
+      const s = /* @__PURE__ */ v(function(f, u = {}) {
+        return i.resolve(f, s, u)[0];
+      }, "schema");
+      if (o.refs) {
+        const f = C(o.refs, (l) => new i(l)), u = /* @__PURE__ */ v((l) => f[l], "getRef");
+        for (const l in f) {
+          const p = f[l];
+          p.sKey = u(p.sKey), p.inner = u(p.inner), p.list = p.list && p.list.map(u), p.dict = p.dict && C(p.dict, u);
+        }
+        return f[o.uid];
+      }
+      if (Object.assign(s, o), typeof s.callback == "string")
+        try {
+          s.callback = new Function("return " + s.callback)();
+        } catch {
+        }
+      return Object.defineProperty(s, "uid", { value: globalThis.__schemastery_index__++ }), Object.setPrototypeOf(s, i.prototype), s.meta ||= {}, s.toString = s.toString.bind(s), s;
+    }, "Schema");
+    i.prototype = Object.create(Function.prototype), i.prototype[r] = !0, i.ValidationError = c;
+    var a;
+    i.prototype.toJSON = /* @__PURE__ */ v(function() {
+      if (a)
+        return a[this.uid] ??= JSON.parse(JSON.stringify({ ...this })), this.uid;
+      a = { [this.uid]: { ...this } }, a[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+      const s = { uid: this.uid, refs: a };
+      return a = void 0, s;
+    }, "toJSON"), i.prototype.set = /* @__PURE__ */ v(function(s, f) {
+      return this.dict[s] = f, this;
+    }, "set"), i.prototype.push = /* @__PURE__ */ v(function(s) {
+      return this.list.push(s), this;
+    }, "push");
+    function y(o, s) {
+      const f = typeof o == "string" ? { "": o } : { ...o };
+      for (const u in s) {
+        const l = s[u];
+        l?.$description || l?.$desc ? f[u] = l.$description || l.$desc : typeof l == "string" && (f[u] = l);
+      }
+      return f;
+    }
+    v(y, "mergeDesc");
+    function d(o) {
+      return o?.$value ?? o?.$inner;
+    }
+    v(d, "getInner");
+    function b(o) {
+      return fe(o ?? {}, (s) => !s.startsWith("$"));
+    }
+    v(b, "extractKeys"), i.prototype.i18n = /* @__PURE__ */ v(function(s) {
+      const f = i(this), u = y(f.meta.description, s);
+      return Object.keys(u).length && (f.meta.description = u), f.dict && (f.dict = C(f.dict, (l, p) => l.i18n(C(s, (m) => d(m)?.[p] ?? m?.[p])))), f.list && (f.list = f.list.map((l, p) => l.i18n(C(s, (m = {}) => Array.isArray(d(m)) ? d(m)[p] : Array.isArray(m) ? m[p] : b(m))))), f.inner && (f.inner = f.inner.i18n(C(s, (l) => d(l) ? d(l) : b(l)))), f.sKey && (f.sKey = f.sKey.i18n(C(s, (l) => l?.$key))), f;
+    }, "i18n"), i.prototype.extra = /* @__PURE__ */ v(function(s, f) {
+      const u = i(this);
+      return u.meta = { ...u.meta, [s]: f }, u;
+    }, "extra");
+    for (const o of ["required", "disabled", "collapse", "hidden", "loose"])
+      Object.assign(i.prototype, {
+        [o](s = !0) {
+          const f = i(this);
+          return f.meta = { ...f.meta, [o]: s }, f;
+        }
+      });
+    i.prototype.deprecated = /* @__PURE__ */ v(function() {
+      const s = i(this);
+      return s.meta.badges ||= [], s.meta.badges.push({ text: "deprecated", type: "danger" }), s;
+    }, "deprecated"), i.prototype.experimental = /* @__PURE__ */ v(function() {
+      const s = i(this);
+      return s.meta.badges ||= [], s.meta.badges.push({ text: "experimental", type: "warning" }), s;
+    }, "experimental"), i.prototype.pattern = /* @__PURE__ */ v(function(s) {
+      const f = i(this), u = ae(s, ["source", "flags"]);
+      return f.meta = { ...f.meta, pattern: u }, f;
+    }, "pattern"), i.prototype.simplify = /* @__PURE__ */ v(function(s) {
+      if (B(s, this.meta.default, this.type === "dict")) return null;
+      if ($(s)) return s;
+      if (this.type === "object" || this.type === "dict") {
+        const f = {};
+        for (const u in s) {
+          const p = (this.type === "object" ? this.dict[u] : this.inner)?.simplify(s[u]);
+          (this.type === "dict" || !$(p)) && (f[u] = p);
+        }
+        return B(f, this.meta.default, this.type === "dict") ? null : f;
+      } else if (this.type === "array" || this.type === "tuple") {
+        const f = [];
+        return s.forEach((u, l) => {
+          const p = this.type === "array" ? this.inner : this.list[l], m = p ? p.simplify(u) : u;
+          f.push(m);
+        }), f;
+      } else if (this.type === "intersect") {
+        const f = {};
+        for (const u of this.list)
+          Object.assign(f, u.simplify(s));
+        return f;
+      } else if (this.type === "union")
+        for (const f of this.list)
+          try {
+            return i.resolve(s, f, {}), f.simplify(s);
+          } catch {
+          }
+      return s;
+    }, "simplify"), i.prototype.toString = /* @__PURE__ */ v(function(s) {
+      return ie[this.type]?.(this, s) ?? `Schema<${this.type}>`;
+    }, "toString"), i.prototype.role = /* @__PURE__ */ v(function(o, s) {
+      const f = i(this);
+      return f.meta = { ...f.meta, role: o, extra: s }, f;
+    }, "role");
+    for (const o of ["default", "link", "comment", "description", "max", "min", "step"])
+      Object.assign(i.prototype, {
+        [o](s) {
+          const f = i(this);
+          return f.meta = { ...f.meta, [o]: s }, f;
+        }
+      });
+    var j = {};
+    i.extend = /* @__PURE__ */ v(function(s, f) {
+      j[s] = f;
+    }, "extend"), i.resolve = /* @__PURE__ */ v(function(s, f, u = {}, l = !1) {
+      if (!f) return [s];
+      if (u.ignore?.(s, f)) return [s];
+      if ($(s) && f.type !== "lazy") {
+        if (f.meta.required) throw new c("missing required value", u);
+        let m = f, S = f.meta.default;
+        for (; m?.type === "intersect" && $(S); )
+          m = m.list[0], S = m?.meta.default;
+        if ($(S)) return [s];
+        s = V(S);
+      }
+      const p = j[f.type];
+      if (!p) throw new c(`unsupported type "${f.type}"`, u);
+      try {
+        return p(s, f, u, l);
+      } catch (m) {
+        if (!f.meta.loose) throw m;
+        return [f.meta.default];
+      }
+    }, "resolve"), i.from = /* @__PURE__ */ v(function(s) {
+      if ($(s))
+        return i.any();
+      if (["string", "number", "boolean"].includes(typeof s))
+        return i.const(s).required();
+      if (s[r])
+        return s;
+      if (typeof s == "function")
+        switch (s) {
+          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(s).required();
+        }
+      else
+        throw new TypeError(`cannot infer schema from ${s}`);
+    }, "from"), i.lazy = /* @__PURE__ */ v(function(s) {
+      const f = /* @__PURE__ */ v(() => (u.inner[r] || (u.inner = u.builder(), u.inner.meta = { ...u.meta, ...u.inner.meta }), u.inner.toJSON()), "toJSON"), u = new i({ type: "lazy", builder: s, inner: { toJSON: f } });
+      return u;
+    }, "lazy"), i.natural = /* @__PURE__ */ v(function() {
+      return i.number().step(1).min(0);
+    }, "natural"), i.percent = /* @__PURE__ */ v(function() {
+      return i.number().step(0.01).min(0).max(1).role("slider");
+    }, "percent"), i.date = /* @__PURE__ */ v(function() {
+      return i.union([
+        i.is(Date),
+        i.transform(i.string().role("datetime"), (s, f) => {
+          const u = new Date(s);
+          if (isNaN(+u)) throw new c(`invalid date "${s}"`, f);
+          return u;
+        }, !0)
+      ]);
+    }, "date"), i.regExp = /* @__PURE__ */ v(function(s = "") {
+      return i.union([
+        i.is(RegExp),
+        i.transform(i.string().role("regexp", { flag: s }), (f, u) => {
+          try {
+            return new RegExp(f, s);
+          } catch (l) {
+            throw new c(l.message, u);
+          }
+        }, !0)
+      ]);
+    }, "regExp"), i.arrayBuffer = /* @__PURE__ */ v(function(s) {
+      return i.union([
+        i.is(ArrayBuffer),
+        i.is(SharedArrayBuffer),
+        i.transform(i.any(), (f, u) => {
+          if (E.isSource(f)) return E.fromSource(f);
+          throw new c(`expected ArrayBufferSource but got ${f}`, u);
+        }, !0),
+        ...s ? [i.transform(i.string(), (f, u) => {
+          try {
+            return s === "base64" ? E.fromBase64(f) : E.fromHex(f);
+          } catch (l) {
+            throw new c(l.message, u);
+          }
+        }, !0)] : []
+      ]);
+    }, "arrayBuffer"), i.extend("lazy", (o, s, f, u) => (s.inner[r] || (s.inner = s.builder(), s.inner.meta = { ...s.meta, ...s.inner.meta }), i.resolve(o, s.inner, f, u))), i.extend("any", (o) => [o]), i.extend("never", (o, s, f) => {
+      throw new c(`expected nullable but got ${o}`, f);
+    }), i.extend("const", (o, { value: s }, f) => {
+      if (B(o, s)) return [s];
+      throw new c(`expected ${s} but got ${o}`, f);
+    });
+    function O(o, s, f, u, l = !1) {
+      const { max: p = 1 / 0, min: m = -1 / 0 } = s;
+      if (o > p) throw new c(`expected ${f} <= ${p} but got ${o}`, u);
+      if (o < m && !l) throw new c(`expected ${f} >= ${m} but got ${o}`, u);
+    }
+    v(O, "checkWithinRange"), i.extend("string", (o, { meta: s }, f) => {
+      if (typeof o != "string") throw new c(`expected string but got ${o}`, f);
+      if (s.pattern) {
+        const u = new RegExp(s.pattern.source, s.pattern.flags);
+        if (!u.test(o)) throw new c(`expect string to match regexp ${u}`, f);
+      }
+      return O(o.length, s, "string length", f), [o];
+    });
+    function R(o, s) {
+      const f = o.toString();
+      if (f.includes("e")) return o * Math.pow(10, s);
+      const u = f.indexOf(".");
+      if (u === -1) return o * Math.pow(10, s);
+      const l = f.slice(u + 1), p = f.slice(0, u);
+      return l.length <= s ? +(p + l.padEnd(s, "0")) : +(p + l.slice(0, s) + "." + l.slice(s));
+    }
+    v(R, "decimalShift");
+    function x(o, s, f) {
+      if (f = Math.abs(f), !/^\d+\.\d+$/.test(f.toString()))
+        return (o - s) % f === 0;
+      const u = f.toString().indexOf("."), l = f.toString().slice(u + 1).length;
+      return Math.abs(R(o, l) - R(s, l)) % R(f, l) === 0;
+    }
+    v(x, "isMultipleOf"), i.extend("number", (o, { meta: s }, f) => {
+      if (typeof o != "number") throw new c(`expected number but got ${o}`, f);
+      O(o, s, "number", f);
+      const { step: u } = s;
+      if (u && !x(o, s.min ?? 0, u))
+        throw new c(`expected number multiple of ${u} but got ${o}`, f);
+      return [o];
+    }), i.extend("boolean", (o, s, f) => {
+      if (typeof o == "boolean") return [o];
+      throw new c(`expected boolean but got ${o}`, f);
+    }), i.extend("bitset", (o, { bits: s, meta: f }, u) => {
+      let l = 0, p = [];
+      if (typeof o == "number") {
+        l = o;
+        for (const m in s)
+          o & s[m] && p.push(m);
+      } else if (Array.isArray(o)) {
+        p = o;
+        for (const m of p) {
+          if (typeof m != "string") throw new c(`expected string but got ${m}`, u);
+          m in s && (l |= s[m]);
+        }
+      } else
+        throw new c(`expected number or array but got ${o}`, u);
+      return l === f.default ? [l] : [l, p];
+    }), i.extend("function", (o, s, f) => {
+      if (typeof o == "function") return [o];
+      throw new c(`expected function but got ${o}`, f);
+    }), i.extend("is", (o, { constructor: s }, f) => {
+      if (typeof s == "function") {
+        if (o instanceof s) return [o];
+        throw new c(`expected ${s.name} but got ${o}`, f);
+      } else {
+        if ($(o))
+          throw new c(`expected ${s} but got ${o}`, f);
+        let u = Object.getPrototypeOf(o);
+        for (; u; ) {
+          if (u.constructor?.name === s) return [o];
+          u = Object.getPrototypeOf(u);
+        }
+        throw new c(`expected ${s} but got ${o}`, f);
+      }
+    });
+    function k(o, s, f, u) {
+      try {
+        const [l, p] = i.resolve(o[s], f, {
+          ...u,
+          path: [...u.path || [], s]
+        });
+        return p !== void 0 && (o[s] = p), l;
+      } catch (l) {
+        if (!u?.autofix) throw l;
+        return delete o[s], f.meta.default;
+      }
+    }
+    v(k, "property"), i.extend("array", (o, { inner: s, meta: f }, u) => {
+      if (!Array.isArray(o)) throw new c(`expected array but got ${o}`, u);
+      return O(o.length, f, "array length", u, !$(s.meta.default)), [o.map((l, p) => k(o, p, s, u))];
+    }), i.extend("dict", (o, { inner: s, sKey: f }, u, l) => {
+      if (!J(o)) throw new c(`expected object but got ${o}`, u);
+      const p = {};
+      for (const m in o) {
+        let S;
+        try {
+          S = i.resolve(m, f, u)[0];
+        } catch (xe) {
+          if (l) continue;
+          throw xe;
+        }
+        p[S] = k(o, m, s, u), o[S] = o[m], m !== S && delete o[m];
+      }
+      return [p];
+    }), i.extend("tuple", (o, { list: s }, f, u) => {
+      if (!Array.isArray(o)) throw new c(`expected array but got ${o}`, f);
+      const l = s.map((p, m) => k(o, m, p, f));
+      return u ? [l] : (l.push(...o.slice(s.length)), [l]);
+    });
+    function F(o, s) {
+      for (const f in s)
+        f in o || (o[f] = s[f]);
+    }
+    v(F, "merge"), i.extend("object", (o, { dict: s }, f, u) => {
+      if (!J(o)) throw new c(`expected object but got ${o}`, f);
+      const l = {};
+      for (const p in s) {
+        const m = k(o, p, s[p], f);
+        (!$(m) || p in o) && (l[p] = m);
+      }
+      return u || F(l, o), [l];
+    }), i.extend("union", (o, { list: s, toString: f }, u, l) => {
+      for (const p of s)
+        try {
+          return i.resolve(o, p, u, l);
+        } catch {
+        }
+      throw new c(`expected ${f()} but got ${JSON.stringify(o)}`, u);
+    }), i.extend("intersect", (o, { list: s, toString: f }, u, l) => {
+      if (!s.length) return [o];
+      let p;
+      for (const m of s) {
+        const S = i.resolve(o, m, u, !0)[0];
+        if (!$(S))
+          if ($(p))
+            p = S;
+          else {
+            if (typeof p != typeof S)
+              throw new c(`expected ${f()} but got ${JSON.stringify(o)}`, u);
+            if (typeof S == "object")
+              F(p ??= {}, S);
+            else if (p !== S)
+              throw new c(`expected ${f()} but got ${JSON.stringify(o)}`, u);
+          }
+      }
+      return !l && J(o) && F(p, o), [p];
+    }), i.extend("transform", (o, { inner: s, callback: f, preserve: u }, l) => {
+      const [p, m = o] = i.resolve(o, s, l, !0);
+      return u ? [f(p)] : [f(p), f(m)];
+    });
+    var ie = {};
+    function A(o, s, f) {
+      ie[o] = f, Object.assign(i, {
+        [o](...u) {
+          const l = new i({ type: o });
+          return s.forEach((p, m) => {
+            switch (p) {
+              case "sKey":
+                l.sKey = u[m] ?? i.string();
+                break;
+              case "inner":
+                l.inner = i.from(u[m]);
+                break;
+              case "list":
+                l.list = u[m].map(i.from);
+                break;
+              case "dict":
+                l.dict = C(u[m], i.from);
+                break;
+              case "bits": {
+                l.bits = {};
+                for (const S in u[m])
+                  typeof u[m][S] == "number" && (l.bits[S] = u[m][S]);
+                break;
+              }
+              case "callback": {
+                const S = l.callback = u[m];
+                S.toJSON ||= () => S.toString();
+                break;
+              }
+              case "constructor": {
+                const S = l.constructor = u[m];
+                typeof S == "function" && (S.toJSON ||= () => S.name);
+                break;
+              }
+              default:
+                l[p] = u[m];
+            }
+          }), o === "object" || o === "dict" ? l.meta.default = {} : o === "array" || o === "tuple" ? l.meta.default = [] : o === "bitset" && (l.meta.default = 0), l;
+        }
+      });
+    }
+    v(A, "defineMethod"), A("is", ["constructor"], ({ constructor: o }) => typeof o == "function" ? o.name : o), A("any", [], () => "any"), A("never", [], () => "never"), A("const", ["value"], ({ value: o }) => typeof o == "string" ? JSON.stringify(o) : o), A("string", [], () => "string"), A("number", [], () => "number"), A("boolean", [], () => "boolean"), A("bitset", ["bits"], () => "bitset"), A("function", [], () => "function"), A("array", ["inner"], ({ inner: o }) => `${o.toString(!0)}[]`), A("dict", ["inner", "sKey"], ({ inner: o, sKey: s }) => `{ [key: ${s.toString()}]: ${o.toString()} }`), A("tuple", ["list"], ({ list: o }) => `[${o.map((s) => s.toString()).join(", ")}]`), A("object", ["dict"], ({ dict: o }) => Object.keys(o).length === 0 ? "{}" : `{ ${Object.entries(o).map(([s, f]) => `${s}${f.meta.required ? "" : "?"}: ${f.toString()}`).join(", ")} }`), A("union", ["list"], ({ list: o }, s) => {
+      const f = o.map(({ toString: u }) => u()).join(" | ");
+      return s ? `(${f})` : f;
+    }), A("intersect", ["list"], ({ list: o }) => `${o.map((s) => s.toString(!0)).join(" & ")}`), A("transform", ["inner", "callback", "preserve"], ({ inner: o }, s) => o.toString(s)), t.exports = i;
+  }
+});
+const et = Ze(), tt = (e, t = document) => t.querySelector(e), rt = (e, t = document) => t.querySelectorAll(e), ge = (e) => typeof e == "function";
+async function nt(e) {
+  return ge(e) ? await e() : e;
+}
+function it(e) {
+  return ge(e) ? e() : e;
+}
+var Te = /* @__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))(Te || {});
+function we(e) {
+  return e.charAt(0).toLowerCase() + e.slice(1);
+}
+function st(e) {
+  return we(e).replace(/_/g, "-").replace(/.[A-Z]+/g, (t) => t[0] + "-" + t.slice(1).toLowerCase());
+}
+function ot(e) {
+  return we(e).replace(/-/g, "_").replace(/.[A-Z]+/g, (t) => t[0] + "_" + t.slice(1).toLowerCase());
+}
+function ct(e) {
+  return function(t) {
+    return t.PreferencesSchema = e, t;
+  };
+}
+export {
+  T as C,
+  Te as E,
+  He as F,
+  K as I,
+  ce as M,
+  ct as R,
+  et as S,
+  de as a,
+  Ve as b,
+  Xe as c,
+  ke as d,
+  Je as e,
+  ot as f,
+  it as g,
+  rt as h,
+  nt as i,
+  P as j,
+  st as p,
+  tt as q,
+  h as s
+};
+//# sourceMappingURL=Preferences-DqtjY7XU.js.map