@inpageedit/core 0.12.0 → 0.13.0-alpha.0

package/dist/endpoints-DgyuoRZd.js

@@ -0,0 +1,1507 @@
+const wt = () => {
+  let t, e;
+  return { promise: new Promise((n, c) => {
+    t = n, e = c;
+  }), resolve: t, reject: e };
+};
+Promise.withResolvers || (Promise.withResolvers = wt);
+var xt = Object.defineProperty, w = (t, e) => xt(t, "name", { value: e, configurable: !0 });
+function vt() {
+}
+w(vt, "noop");
+function $(t) {
+  return t == null;
+}
+w($, "isNullable");
+function St(t) {
+  return !$(t);
+}
+w(St, "isNonNullable");
+function J(t) {
+  return t && typeof t == "object" && !Array.isArray(t);
+}
+w(J, "isPlainObject");
+function ft(t, e) {
+  return Object.fromEntries(Object.entries(t).filter(([r, n]) => e(r, n)));
+}
+w(ft, "filterKeys");
+function N(t, e) {
+  return Object.fromEntries(Object.entries(t).map(([r, n]) => [r, e(n, r)]));
+}
+w(N, "mapValues");
+function at(t, e, r) {
+  if (!e) return { ...t };
+  const n = {};
+  for (const c of e)
+    (r || t[c] !== void 0) && (n[c] = t[c]);
+  return n;
+}
+w(at, "pick");
+function kt(t, e) {
+  if (!e) return { ...t };
+  const r = { ...t };
+  for (const n of e)
+    Reflect.deleteProperty(r, n);
+  return r;
+}
+w(kt, "omit");
+function A(t, e, r) {
+  return Object.defineProperty(t, e, { writable: !0, value: r, enumerable: !1 });
+}
+w(A, "defineProperty");
+function Ot(t, e) {
+  return e.every((r) => t.includes(r));
+}
+w(Ot, "contain");
+function jt(t, e) {
+  return t.filter((r) => e.includes(r));
+}
+w(jt, "intersection");
+function $t(t, e) {
+  return t.filter((r) => !e.includes(r));
+}
+w($t, "difference");
+function _t(t, e) {
+  return Array.from(/* @__PURE__ */ new Set([...t, ...e]));
+}
+w(_t, "union");
+function At(t) {
+  return [...new Set(t)];
+}
+w(At, "deduplicate");
+function D(t, e) {
+  const r = t?.indexOf(e);
+  return r >= 0 ? (t.splice(r, 1), !0) : !1;
+}
+w(D, "remove");
+function Rt(t) {
+  return Array.isArray(t) ? t : $(t) ? [] : [t];
+}
+w(Rt, "makeArray");
+function B(t, e) {
+  return arguments.length === 1 ? (r) => B(t, r) : t in globalThis && e instanceof globalThis[t] || Object.prototype.toString.call(e).slice(8, -1) === t;
+}
+w(B, "is");
+function q(t) {
+  return B("ArrayBuffer", t) || B("SharedArrayBuffer", t);
+}
+w(q, "isArrayBufferLike");
+function ut(t) {
+  return q(t) || ArrayBuffer.isView(t);
+}
+w(ut, "isArrayBufferSource");
+var E;
+((t) => {
+  t.is = q, t.isSource = ut;
+  function e(a) {
+    return ArrayBuffer.isView(a) ? a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength) : a;
+  }
+  t.fromSource = e, w(e, "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);
+  }
+  t.toBase64 = r, w(r, "toBase64");
+  function n(a) {
+    return typeof Buffer < "u" ? e(Buffer.from(a, "base64")) : Uint8Array.from(atob(a), (y) => y.charCodeAt(0));
+  }
+  t.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("");
+  }
+  t.toHex = c, w(c, "toHex");
+  function i(a) {
+    if (typeof Buffer < "u") return e(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;
+  }
+  t.fromHex = i, w(i, "fromHex");
+})(E || (E = {}));
+E.fromBase64;
+E.toBase64;
+E.fromHex;
+E.toHex;
+function V(t, e = /* @__PURE__ */ new Map()) {
+  if (!t || typeof t != "object") return t;
+  if (B("Date", t)) return new Date(t.valueOf());
+  if (B("RegExp", t)) return new RegExp(t.source, t.flags);
+  if (q(t)) return t.slice(0);
+  if (ArrayBuffer.isView(t)) return t.buffer.slice(t.byteOffset, t.byteOffset + t.byteLength);
+  const r = e.get(t);
+  if (r) return r;
+  if (Array.isArray(t)) {
+    const c = [];
+    return e.set(t, c), t.forEach((i, a) => {
+      c[a] = Reflect.apply(V, null, [i, e]);
+    }), c;
+  }
+  const n = Object.create(Object.getPrototypeOf(t));
+  e.set(t, n);
+  for (const c of Reflect.ownKeys(t)) {
+    const i = { ...Reflect.getOwnPropertyDescriptor(t, c) };
+    "value" in i && (i.value = Reflect.apply(V, null, [i.value, e])), Reflect.defineProperty(n, c, i);
+  }
+  return n;
+}
+w(V, "clone");
+function I(t, e, r) {
+  if (t === e || !r && $(t) && $(e)) return !0;
+  if (typeof t != typeof e || typeof t != "object" || !t || !e) return !1;
+  function n(c, i) {
+    return c(t) ? c(e) ? i(t, e) : !1 : c(e) ? !1 : void 0;
+  }
+  return w(n, "check"), n(Array.isArray, (c, i) => c.length === i.length && c.every((a, y) => I(a, i[y]))) ?? n(B("Date"), (c, i) => c.valueOf() === i.valueOf()) ?? n(B("RegExp"), (c, i) => c.source === i.source && c.flags === i.flags) ?? n(q, (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({ ...t, ...e }).every((c) => I(t[c], e[c], r));
+}
+w(I, "deepEqual");
+function Pt(t) {
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}
+w(Pt, "capitalize");
+function Et(t) {
+  return t.charAt(0).toLowerCase() + t.slice(1);
+}
+w(Et, "uncapitalize");
+function Ct(t) {
+  return t.replace(/[_-][a-z]/g, (e) => e.slice(1).toUpperCase());
+}
+w(Ct, "camelCase");
+function T(t, e, r) {
+  const n = [];
+  let c = 0;
+  for (let i = 0; i < t.length; i++) {
+    const a = t.charCodeAt(i);
+    if (a >= 65 && a <= 90) {
+      if (c === 1) {
+        const y = t.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) : e.includes(a) ? (c !== 0 && n.push(r), c = 0) : n.push(a);
+  }
+  return String.fromCharCode(...n);
+}
+w(T, "tokenize");
+function Nt(t) {
+  return T(t, [45, 95], 45);
+}
+w(Nt, "paramCase");
+function Dt(t) {
+  return T(t, [45, 95], 95);
+}
+w(Dt, "snakeCase");
+function Bt(t) {
+  return typeof t != "string" ? `[${t.toString()}]` : /^[a-z_$][\w$]*$/i.test(t) ? `.${t}` : `[${JSON.stringify(t)}]`;
+}
+w(Bt, "formatProperty");
+function lt(t) {
+  return t.replace(/\/$/, "");
+}
+w(lt, "trimSlash");
+function It(t) {
+  return t.startsWith("/") || (t = "/" + t), lt(t);
+}
+w(It, "sanitize");
+var st;
+((t) => {
+  t.millisecond = 1, t.second = 1e3, t.minute = t.second * 60, t.hour = t.minute * 60, t.day = t.hour * 24, t.week = t.day * 7;
+  let e = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  function r(x) {
+    e = x;
+  }
+  t.setTimezoneOffset = r, w(r, "setTimezoneOffset");
+  function n() {
+    return e;
+  }
+  t.getTimezoneOffset = n, w(n, "getTimezoneOffset");
+  function c(x = /* @__PURE__ */ new Date(), v) {
+    return typeof x == "number" && (x = new Date(x)), v === void 0 && (v = e), Math.floor((x.valueOf() / t.minute - v) / 1440);
+  }
+  t.getDateNumber = c, w(c, "getDateNumber");
+  function i(x, v) {
+    const z = new Date(x * t.day);
+    return v === void 0 && (v = e), new Date(+z + v * t.minute);
+  }
+  t.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 v = y.exec(x);
+    return v ? (parseFloat(v[1]) * t.week || 0) + (parseFloat(v[2]) * t.day || 0) + (parseFloat(v[3]) * t.hour || 0) + (parseFloat(v[4]) * t.minute || 0) + (parseFloat(v[5]) * t.second || 0) : 0;
+  }
+  t.parseTime = d, w(d, "parseTime");
+  function b(x) {
+    const v = d(x);
+    return v ? x = Date.now() + v : /^\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();
+  }
+  t.parseDate = b, w(b, "parseDate");
+  function j(x) {
+    const v = Math.abs(x);
+    return v >= t.day - t.hour / 2 ? Math.round(x / t.day) + "d" : v >= t.hour - t.minute / 2 ? Math.round(x / t.hour) + "h" : v >= t.minute - t.second / 2 ? Math.round(x / t.minute) + "m" : v >= t.second ? Math.round(x / t.second) + "s" : x + "ms";
+  }
+  t.format = j, w(j, "format");
+  function k(x, v = 2) {
+    return x.toString().padStart(v, "0");
+  }
+  t.toDigits = k, w(k, "toDigits");
+  function R(x, v = /* @__PURE__ */ new Date()) {
+    return x.replace("yyyy", v.getFullYear().toString()).replace("yy", v.getFullYear().toString().slice(2)).replace("MM", k(v.getMonth() + 1)).replace("dd", k(v.getDate())).replace("hh", k(v.getHours())).replace("mm", k(v.getMinutes())).replace("ss", k(v.getSeconds())).replace("SSS", k(v.getMilliseconds(), 3));
+  }
+  t.template = R, w(R, "template");
+})(st || (st = {}));
+var zt = Object.defineProperty, g = (t, e) => zt(t, "name", { value: e, 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")
+}, Ut = function* () {
+}.constructor, ot = async function* () {
+}.constructor;
+function tt(t) {
+  return !(!t.prototype || t instanceof Ut || ot !== Function && t instanceof ot);
+}
+g(tt, "isConstructor");
+function L(t, e) {
+  const r = t.Config || t.schema;
+  return r && t.schema !== !1 && (e = r(e)), e ?? {};
+}
+g(L, "resolveConfig");
+function ht(t) {
+  return [Map, Set, Date, Promise].some((e) => t instanceof e);
+}
+g(ht, "isUnproxyable");
+function et(t, e) {
+  if (t === Object.prototype) return e;
+  const r = Object.create(et(Object.getPrototypeOf(t), e));
+  for (const n of Reflect.ownKeys(t))
+    Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(t, n));
+  return r;
+}
+g(et, "joinPrototype");
+function rt(t) {
+  return t && (typeof t == "object" || typeof t == "function");
+}
+g(rt, "isObject");
+function C(t, e, r) {
+  if (!rt(e)) return e;
+  if (Object.hasOwn(e, h.shadow))
+    return Object.getPrototypeOf(e);
+  const n = e[h.tracker];
+  return n ? G(t, e, n, r) : e;
+}
+g(C, "getTraceable");
+function F(t, e) {
+  return e ? new Proxy(t, {
+    get: /* @__PURE__ */ g((r, n, c) => n in e && n !== "constructor" ? Reflect.get(e, n, c) : Reflect.get(r, n, c), "get"),
+    set: /* @__PURE__ */ g((r, n, c, i) => n in e && n !== "constructor" ? Reflect.set(e, n, c, i) : Reflect.set(r, n, c, i), "set")
+  }) : t;
+}
+g(F, "withProps");
+function H(t, e, r) {
+  return F(t, Object.defineProperty(/* @__PURE__ */ Object.create(null), e, {
+    value: r,
+    writable: !1
+  }));
+}
+g(H, "withProp");
+function W(t, e, r, n) {
+  if (!r) return n;
+  const c = Reflect.getOwnPropertyDescriptor(e, r)?.value;
+  return c ? H(n, r, t.extend({ [h.shadow]: c })) : n;
+}
+g(W, "createShadow");
+function pt(t, e, r, n) {
+  return new Proxy(e, {
+    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 k = Reflect.get(d, b, j);
+        return b === "toString" && k === Function.prototype.toString ? function(...R) {
+          return Reflect.apply(k, this === j ? d : this, R);
+        } : k;
+      }, "get"),
+      apply: /* @__PURE__ */ g((d, b, j) => Reflect.apply(d, C(t, b), j.map((k) => C(t, k))), "apply"),
+      construct: /* @__PURE__ */ g((d, b, j) => Reflect.construct(d, b.map((k) => C(t, k)), j), "construct")
+    })), C(t, Reflect.apply(c, i, a))), "apply")
+  });
+}
+g(pt, "createShadowMethod");
+function G(t, e, r, n) {
+  t[h.shadow] && (t = Object.getPrototypeOf(t));
+  const c = new Proxy(e, {
+    get: /* @__PURE__ */ g((i, a, y) => {
+      if (a === h.original) return i;
+      if (a === r.property) return t;
+      if (typeof a == "symbol")
+        return Reflect.get(i, a, y);
+      if (r.associate && t[h.internal][`${r.associate}.${a}`])
+        return Reflect.get(t, `${r.associate}.${a}`, H(t, h.receiver, y));
+      const d = W(t, i, r.property, y), b = Reflect.get(i, a, d), j = b?.[h.tracker];
+      return j ? G(t, b, j) : !n && typeof b == "function" ? pt(t, 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 && t[h.internal][`${r.associate}.${a}`])
+        return Reflect.set(t, `${r.associate}.${a}`, y, H(t, h.receiver, d));
+      const b = W(t, i, r.property, d);
+      return Reflect.set(i, a, y, b);
+    }, "set"),
+    apply: /* @__PURE__ */ g((i, a, y) => nt(c, i, a, y), "apply")
+  });
+  return c;
+}
+g(G, "createTraceable");
+function nt(t, e, r, n) {
+  return e[h.invoke] ? e[h.invoke].apply(t, n) : Reflect.apply(e, r, n);
+}
+g(nt, "applyTraceable");
+function Y(t, e, r) {
+  const n = /* @__PURE__ */ g(function(...c) {
+    const i = G(n.ctx, n, r);
+    return nt(i, n, this, c);
+  }, "self");
+  return A(n, "name", t), Object.setPrototypeOf(n, e);
+}
+g(Y, "createCallable");
+var Mt = class U {
+  constructor(e) {
+    this.ctx = e, A(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(e, r) {
+    let n = e[h.internal][r];
+    for (; n?.type === "alias"; )
+      r = n.name, n = e[h.internal][r];
+    return [r, n];
+  }
+  static checkInject(e, r, n) {
+    if (e = e[h.shadow] ?? e, ["prototype", "then", "registry", "lifecycle"].includes(r) || r[0] === "$" || r[0] === "_" || !e.runtime.plugin || e.bail(e, "internal/inject", r)) return;
+    const c = n.stack.split(`
+`);
+    c.splice(1, 1), n.stack = c.join(`
+`), e.emit(e, "internal/warning", n);
+  }
+  static handler = {
+    get: /* @__PURE__ */ g((e, r, n) => {
+      if (typeof r != "string") return Reflect.get(e, r, n);
+      if (Reflect.has(e, r))
+        return C(n, Reflect.get(e, r, n), !0);
+      const [c, i] = U.resolveInject(e, 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(e, c, n));
+    }, "get"),
+    set: /* @__PURE__ */ g((e, r, n, c) => {
+      if (typeof r != "string") return Reflect.set(e, r, n, c);
+      const [i, a] = U.resolveInject(e, 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(e, i, n, c);
+    }, "set"),
+    has: /* @__PURE__ */ g((e, r) => {
+      if (typeof r != "string") return Reflect.has(e, r);
+      if (Reflect.has(e, r)) return !0;
+      const [, n] = U.resolveInject(e, r);
+      return !!n;
+    }, "has")
+  };
+  get(e) {
+    if (this.ctx[h.internal][e]?.type !== "service") return;
+    const n = this.ctx[h.isolate][e], c = this.ctx[h.store][n]?.value;
+    return C(this.ctx, c);
+  }
+  set(e, r) {
+    this.provide(e);
+    const n = this.ctx[h.isolate][e], 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 ${e} has been registered`);
+    const a = this.ctx;
+    $(r) || (i = a.effect(() => () => {
+      a.set(e, void 0);
+    })), ht(r) && a.emit(a, "internal/warning", new Error(`service ${e} is an unproxyable object, which may lead to unexpected behavior`));
+    const y = Object.create(a);
+    return y[h.filter] = (d) => a[h.isolate][e] === d[h.isolate][e], a.emit(y, "internal/before-service", e, r), a[h.store][n] = { value: r, source: a }, a.emit(y, "internal/service", e, c), i;
+  }
+  provide(e, r, n) {
+    const c = this.ctx.root[h.internal];
+    if (e in c) return;
+    const i = Symbol(e);
+    c[e] = { type: "service", builtin: n }, this.ctx.root[h.isolate][e] = i, rt(r) && (this.ctx[h.store][i] = { value: r, source: null }, A(r, h.tracker, {
+      associate: e,
+      property: "ctx"
+    }));
+  }
+  _accessor(e, r) {
+    const n = this.ctx.root[h.internal];
+    return e in n ? () => {
+    } : (n[e] = { type: "accessor", ...r }, () => delete this.ctx.root[h.isolate][e]);
+  }
+  accessor(e, r) {
+    this.ctx.scope.effect(() => this._accessor(e, r));
+  }
+  alias(e, r) {
+    const n = this.ctx.root[h.internal];
+    if (!(e in n))
+      for (const c of r)
+        n[c] ||= { type: "alias", name: e };
+  }
+  _mixin(e, r) {
+    const n = Array.isArray(r) ? r.map((a) => [a, a]) : Object.entries(r), c = typeof e == "string" ? (a) => a[e] : () => e, i = n.map(([a, y]) => this._accessor(y, {
+      get(d) {
+        const b = c(this);
+        if ($(b)) return b;
+        const j = d ? F(d, b) : b, k = Reflect.get(b, a, j);
+        return typeof k != "function" ? k : k.bind(j ?? b);
+      },
+      set(d, b) {
+        const j = c(this), k = b ? F(b, j) : j;
+        return Reflect.set(j, a, d, k);
+      }
+    }));
+    return () => i.forEach((a) => a());
+  }
+  mixin(e, r) {
+    this.ctx.scope.effect(() => this._mixin(e, r));
+  }
+  trace(e) {
+    return C(this.ctx, e);
+  }
+  bind(e) {
+    return new Proxy(e, {
+      apply: /* @__PURE__ */ g((r, n, c) => r.apply(this.trace(n), c.map((i) => this.trace(i))), "apply")
+    });
+  }
+}, Q = Mt;
+function X(t) {
+  return t !== null && t !== !1 && t !== void 0;
+}
+g(X, "isBailed");
+var Ft = class {
+  constructor(t) {
+    this.ctx = t, A(this, h.tracker, {
+      associate: "lifecycle",
+      property: "ctx"
+    }), A(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), A(n, "name", "event <dispose>"), () => D(this.scope.disposables, n);
+      if (r === "fork")
+        return this.scope.runtime.forkables[i](n), this.scope.collect("event <fork>", () => D(this.scope.runtime.forkables, n));
+    }), P.static, t.scope);
+    for (const r of ["info", "error", "warning"])
+      A(this.on(`internal/${r}`, (n, ...c) => {
+        this._hooks[`internal/${r}`].length > 1;
+      }), P.static, t.scope);
+    A(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, t.scope), A(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, t.scope);
+    const e = /* @__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 e(r.parent.scope, n);
+    }, "checkInject");
+    A(this.on("internal/inject", function(r) {
+      return e(this.scope, r);
+    }, { global: !0 }), P.static, t.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(t, e) {
+    return e = C(this.ctx, e), t.slice().filter((r) => {
+      const n = e?.[P.filter];
+      return r.global || !n || n.call(e, r.ctx);
+    });
+  }
+  *dispatch(t, e) {
+    const r = typeof e[0] == "object" || typeof e[0] == "function" ? e.shift() : null, n = e.shift();
+    n !== "internal/event" && this.emit("internal/event", t, n, e, r);
+    for (const c of this.filterHooks(this._hooks[n] || [], r))
+      yield c.callback.apply(r, e);
+  }
+  async parallel(...t) {
+    await Promise.all(this.dispatch("emit", t));
+  }
+  emit(...t) {
+    Array.from(this.dispatch("emit", t));
+  }
+  async serial(...t) {
+    for await (const e of this.dispatch("serial", t))
+      if (X(e)) return e;
+  }
+  bail(...t) {
+    for (const e of this.dispatch("bail", t))
+      if (X(e)) return e;
+  }
+  register(t, e, r, n) {
+    const c = n.prepend ? "unshift" : "push";
+    return e[c]({ ctx: this.ctx, callback: r, ...n }), this.ctx.state.collect(t, () => this.unregister(e, r));
+  }
+  unregister(t, e) {
+    const r = t.findIndex((n) => n.callback === e);
+    if (r >= 0)
+      return t.splice(r, 1), !0;
+  }
+  on(t, e, r) {
+    typeof r != "object" && (r = { prepend: r }), this.ctx.scope.assertActive(), e = this.ctx.reflect.bind(e);
+    const n = this.bail(this.ctx, "internal/listener", t, e, r);
+    if (n) return n;
+    const c = this._hooks[t] ||= [], i = typeof t == "string" ? `event <${t}>` : "event (Symbol)";
+    return this.register(i, c, e, r);
+  }
+  once(t, e, r) {
+    const n = this.on(t, function(...c) {
+      return n(), e.apply(this, c);
+    }, r);
+    return n;
+  }
+  async start() {
+    this.isActive = !0;
+    const t = this._hooks.ready || [];
+    for (; t.length; ) {
+      const { ctx: e, callback: r } = t.shift();
+      e.scope.ensure(async () => r());
+    }
+    await this.flush();
+  }
+  async stop() {
+    this.isActive = !1, this.ctx.scope.reset();
+  }
+}, qt = Ft, Z = class yt extends Error {
+  constructor(e, r) {
+    super(r ?? yt.Code[e]), this.code = e;
+  }
+  static {
+    g(this, "CordisError");
+  }
+};
+((t) => {
+  t.Code = {
+    INACTIVE_EFFECT: "cannot create effect on inactive context"
+  };
+})(Z || (Z = {}));
+var dt = class {
+  constructor(t, e) {
+    this.parent = t, this.config = e, this.uid = t.registry ? t.registry.counter : 0, this.ctx = this.context = t.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 Z("INACTIVE_EFFECT");
+  }
+  effect(t, e) {
+    this.assertActive();
+    const r = tt(t) ? new t(this.ctx, e) : t(this.ctx, e);
+    let n = !1;
+    const c = typeof r == "function" ? r : r.dispose.bind(r), i = /* @__PURE__ */ g((...a) => {
+      if (!n)
+        return n = !0, D(this.disposables, i), c(...a);
+    }, "wrapped");
+    return this.disposables.push(i), typeof r == "function" ? i : (r.dispose = i, r);
+  }
+  collect(t, e) {
+    const r = A(() => (D(this.disposables, r), e()), "name", t);
+    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(t) {
+    const e = this.status;
+    t?.(), this.status = this._getStatus(), e !== this.status && this.context.emit("internal/status", this, e);
+  }
+  ensure(t) {
+    const e = t().catch((r) => {
+      this.context.emit(this.ctx, "internal/error", r), this.cancel(r);
+    }).finally(() => {
+      this.updateStatus(() => this.tasks.delete(e)), this.context.events._tasks.delete(e);
+    });
+    this.updateStatus(() => this.tasks.add(e)), this.context.events._tasks.add(e);
+  }
+  cancel(t) {
+    this.error = t, this.updateStatus(() => this.hasError = !0), this.reset();
+  }
+  get ready() {
+    return Object.entries(this.runtime.inject).every(([t, e]) => !e.required || !$(this.ctx.get(t)));
+  }
+  reset() {
+    this.isActive = !1, this.disposables = this.disposables.splice(0).filter((t) => {
+      if (this.uid !== null && t[P.static] === this) return !0;
+      (async () => t())().catch((e) => {
+        this.context.emit(this.ctx, "internal/error", e);
+      });
+    });
+  }
+  init(t) {
+    this.config ? this.start() : this.cancel(t);
+  }
+  start() {
+    if (!this.ready || this.isActive || this.uid === null) return !0;
+    this.isActive = !0, this.updateStatus(() => this.hasError = !1);
+  }
+  accept(...t) {
+    const r = { keys: Array.isArray(t[0]) ? t.shift() : null, callback: t[0], ...t[1] };
+    return this.effect(() => (this.acceptors.push(r), r.immediate && r.callback?.(this.config), () => D(this.acceptors, r)));
+  }
+  decline(t) {
+    return this.accept(t, () => !0);
+  }
+  checkUpdate(t, e) {
+    if (e || !this.config) return [!0, !0];
+    if (e === !1) return [!1, !1];
+    const r = /* @__PURE__ */ Object.create(null), n = /* @__PURE__ */ g((d) => {
+      const b = r[d] ??= !I(this.config[d], t[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?.(t) && (a = !0);
+    }
+    for (const d in { ...this.config, ...t })
+      if (y !== !1 && !(d in r) && !c.has(d)) {
+        const b = n(d);
+        y === null && (a ||= b);
+      }
+    return [i, a];
+  }
+}, Lt = class extends dt {
+  constructor(t, e, r, n) {
+    super(t, r), this.runtime = e, this.dispose = A(t.scope.collect(`fork <${t.runtime.name}>`, () => {
+      this.uid = null, this.reset(), this.context.emit("internal/fork", this);
+      const c = D(e.disposables, this.dispose);
+      return D(e.children, this) && !e.children.length && t.registry.delete(e.plugin), c;
+    }), P.static, e), e.children.push(this), e.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 t of this.runtime.forkables)
+      this.ensure(async () => t(this.context, this._config));
+  }
+  update(t, e) {
+    const r = this.config, n = this.runtime.isForkable ? this : this.runtime;
+    if (n.config !== r) return;
+    let c;
+    try {
+      c = L(this.runtime.plugin, t);
+    } catch (y) {
+      return this.context.emit("internal/error", y), this.cancel(y);
+    }
+    const [i, a] = n.checkUpdate(c, e);
+    this.context.emit("internal/before-update", this, t), this.config = c, n.config = c, i && this.context.emit("internal/update", this, r), a && n.restart();
+  }
+}, ct = class extends dt {
+  constructor(t, e, r, n) {
+    super(t, r), this.plugin = e, e ? (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(t, e, r) {
+    return new Lt(t, this, e, r);
+  }
+  dispose() {
+    return this.uid = null, this.reset(), this.context.emit("internal/runtime", this), !0;
+  }
+  setup() {
+    const { name: t } = this.plugin;
+    t && t !== "apply" && (this.name = t), 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((t, e) => {
+    if (typeof this.plugin != "function")
+      return this.plugin.apply(t, e);
+    if (tt(this.plugin)) {
+      const r = new this.plugin(t, e), n = r[P.expose];
+      return n && t.set(n, r), r.fork && this.forkables.push(r.fork.bind(r)), r;
+    } else
+      return this.plugin(t, e);
+  }, "apply");
+  reset() {
+    super.reset();
+    for (const t of this.children)
+      t.reset();
+  }
+  start() {
+    if (super.start()) return !0;
+    !this.isReusable && this.plugin && this.ensure(async () => this.value = this.apply(this.ctx, this._config));
+    for (const t of this.children)
+      t.start();
+  }
+  update(t, e) {
+    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 = L(this.runtime.plugin || this.context.constructor, t);
+    } catch (y) {
+      return this.context.emit("internal/error", y), this.cancel(y);
+    }
+    const [c, i] = this.checkUpdate(n, e), a = this.children.find((y) => y.config === r);
+    this.config = n, a && (this.context.emit("internal/before-update", a, t), a.config = n, c && this.context.emit("internal/update", a, r)), i && this.restart();
+  }
+};
+function mt(t) {
+  return t && typeof t == "object" && typeof t.apply == "function";
+}
+g(mt, "isApplicable");
+function K(t) {
+  return function(e, r) {
+    if (r.kind === "class")
+      e.inject = t;
+    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(t, (c) => {
+          e.call(F(this, { [n]: c }));
+        });
+      });
+    else
+      throw new Error("@Inject can only be used on class or class methods");
+  };
+}
+g(K, "Inject");
+((t) => {
+  function e(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;
+  }
+  t.resolve = e, g(e, "resolve");
+})(K || (K = {}));
+var Jt = class {
+  constructor(t, e) {
+    this.ctx = t, A(this, h.tracker, {
+      associate: "registry",
+      property: "ctx"
+    }), this.context = t;
+    const r = new ct(t, null, e);
+    t.scope = r, r.ctx = t, 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(t, e = !1) {
+    if (t === null || typeof t == "function") return t;
+    if (mt(t)) return t.apply;
+    if (e) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof t);
+  }
+  get(t) {
+    const e = this.resolve(t);
+    return e && this._internal.get(e);
+  }
+  has(t) {
+    const e = this.resolve(t);
+    return !!e && this._internal.has(e);
+  }
+  set(t, e) {
+    const r = this.resolve(t);
+    this._internal.set(r, e);
+  }
+  delete(t) {
+    const e = this.resolve(t), r = e && this._internal.get(e);
+    if (r)
+      return this._internal.delete(e), r.dispose(), r;
+  }
+  keys() {
+    return this._internal.keys();
+  }
+  values() {
+    return this._internal.values();
+  }
+  entries() {
+    return this._internal.entries();
+  }
+  forEach(t) {
+    return this._internal.forEach(t);
+  }
+  using(t, e) {
+    return this.inject(t, e);
+  }
+  inject(t, e) {
+    return this.plugin({ inject: t, apply: e, name: e.name });
+  }
+  plugin(t, e, r) {
+    if (this.resolve(t, !0), this.ctx.scope.assertActive(), !r)
+      try {
+        e = L(t, e);
+      } catch (c) {
+        this.context.emit(this.ctx, "internal/error", c), r = c, e = null;
+      }
+    let n = this.get(t);
+    return n ? (n.isForkable || this.context.emit(this.ctx, "internal/warning", new Error(`duplicate plugin detected: ${t.name}`)), n.fork(this.ctx, e, r)) : (n = new ct(this.ctx, t, e, r), this.set(t, n), n.fork(this.ctx, e, r));
+  }
+}, Vt = Jt, P = class M {
+  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(e) {
+    return !!e?.[M.is];
+  }
+  static {
+    M.is[Symbol.toPrimitive] = () => Symbol.for("cordis.is"), M.prototype[M.is] = !0;
+  }
+  /** @deprecated use `Service.traceable` instead */
+  static associate(e, r) {
+    return e;
+  }
+  constructor(e) {
+    e = L(this.constructor, e), 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 Vt(r, e), r.lifecycle = new qt(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, e), A(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 e = this.runtime;
+    for (; e && !e.name; )
+      e = e.parent.runtime;
+    return e?.name;
+  }
+  get events() {
+    return this.lifecycle;
+  }
+  /** @deprecated */
+  get state() {
+    return this.scope;
+  }
+  extend(e = {}) {
+    const r = Reflect.getOwnPropertyDescriptor(this, h.shadow)?.value, n = Object.assign(Object.create(C(this, this)), e);
+    return r ? Object.assign(Object.create(n), { [h.shadow]: r }) : n;
+  }
+  isolate(e, r) {
+    const n = Object.create(this[h.isolate]);
+    return n[e] = r ?? Symbol(e), this.extend({ [h.isolate]: n });
+  }
+  intercept(e, r) {
+    const n = Object.create(this[h.intercept]);
+    return n[e] = r, this.extend({ [h.intercept]: n });
+  }
+};
+P.prototype[P.internal] = /* @__PURE__ */ Object.create(null);
+var Qt = class bt {
+  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(...e) {
+    let r, n, c, i;
+    P.is(e[0]) ? (r = e[0], typeof e[1] == "string" ? (n = e[1], c = e[2]) : i = e[1]) : i = e[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, et(Object.getPrototypeOf(this), Function.prototype), y)), r ? a.ctx = r : a[h.setup](), a.name = n, a.config = i, A(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](e) {
+    return e[h.isolate][this.name] === this.ctx[h.isolate][this.name];
+  }
+  [h.setup]() {
+    this.ctx = new P();
+  }
+  [h.extend](e) {
+    let r;
+    return this[bt.invoke] ? r = Y(this.name, this, this[h.tracker]) : r = Object.create(this), Object.assign(r, e);
+  }
+  static [Symbol.hasInstance](e) {
+    let r = e.constructor;
+    for (; r; ) {
+      if (r = r.prototype?.constructor, r === this) return !0;
+      r = Object.getPrototypeOf(r);
+    }
+    return !1;
+  }
+}, Ht = Object.defineProperty, Kt = Object.getOwnPropertyNames, S = (t, e) => Ht(t, "name", { value: e, configurable: !0 }), Gt = (t, e) => function() {
+  return e || (0, t[Kt(t)[0]])((e = { exports: {} }).exports, e), e.exports;
+}, Wt = Gt({
+  "src/index.ts"(t, e) {
+    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 {
+        S(this, "ValidationError");
+      }
+      name = "ValidationError";
+      static is(o) {
+        return !!o?.[n];
+      }
+    };
+    Object.defineProperty(c.prototype, n, {
+      value: !0
+    });
+    var i = /* @__PURE__ */ S(function(o) {
+      const s = /* @__PURE__ */ S(function(f, u = {}) {
+        return i.resolve(f, s, u)[0];
+      }, "schema");
+      if (o.refs) {
+        const f = N(o.refs, (l) => new i(l)), u = /* @__PURE__ */ S((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 && N(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__ */ S(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__ */ S(function(s, f) {
+      return this.dict[s] = f, this;
+    }, "set"), i.prototype.push = /* @__PURE__ */ S(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;
+    }
+    S(y, "mergeDesc");
+    function d(o) {
+      return o?.$value ?? o?.$inner;
+    }
+    S(d, "getInner");
+    function b(o) {
+      return ft(o ?? {}, (s) => !s.startsWith("$"));
+    }
+    S(b, "extractKeys"), i.prototype.i18n = /* @__PURE__ */ S(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 = N(f.dict, (l, p) => l.i18n(N(s, (m) => d(m)?.[p] ?? m?.[p])))), f.list && (f.list = f.list.map((l, p) => l.i18n(N(s, (m = {}) => Array.isArray(d(m)) ? d(m)[p] : Array.isArray(m) ? m[p] : b(m))))), f.inner && (f.inner = f.inner.i18n(N(s, (l) => d(l) ? d(l) : b(l)))), f.sKey && (f.sKey = f.sKey.i18n(N(s, (l) => l?.$key))), f;
+    }, "i18n"), i.prototype.extra = /* @__PURE__ */ S(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__ */ S(function() {
+      const s = i(this);
+      return s.meta.badges ||= [], s.meta.badges.push({ text: "deprecated", type: "danger" }), s;
+    }, "deprecated"), i.prototype.experimental = /* @__PURE__ */ S(function() {
+      const s = i(this);
+      return s.meta.badges ||= [], s.meta.badges.push({ text: "experimental", type: "warning" }), s;
+    }, "experimental"), i.prototype.pattern = /* @__PURE__ */ S(function(s) {
+      const f = i(this), u = at(s, ["source", "flags"]);
+      return f.meta = { ...f.meta, pattern: u }, f;
+    }, "pattern"), i.prototype.simplify = /* @__PURE__ */ S(function(s) {
+      if (I(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 I(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__ */ S(function(s) {
+      return it[this.type]?.(this, s) ?? `Schema<${this.type}>`;
+    }, "toString"), i.prototype.role = /* @__PURE__ */ S(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__ */ S(function(s, f) {
+      j[s] = f;
+    }, "extend"), i.resolve = /* @__PURE__ */ S(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, O = f.meta.default;
+        for (; m?.type === "intersect" && $(O); )
+          m = m.list[0], O = m?.meta.default;
+        if ($(O)) return [s];
+        s = V(O);
+      }
+      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__ */ S(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__ */ S(function(s) {
+      const f = /* @__PURE__ */ S(() => (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__ */ S(function() {
+      return i.number().step(1).min(0);
+    }, "natural"), i.percent = /* @__PURE__ */ S(function() {
+      return i.number().step(0.01).min(0).max(1).role("slider");
+    }, "percent"), i.date = /* @__PURE__ */ S(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__ */ S(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__ */ S(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 (I(o, s)) return [s];
+      throw new c(`expected ${s} but got ${o}`, f);
+    });
+    function k(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);
+    }
+    S(k, "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 k(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));
+    }
+    S(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;
+    }
+    S(x, "isMultipleOf"), i.extend("number", (o, { meta: s }, f) => {
+      if (typeof o != "number") throw new c(`expected number but got ${o}`, f);
+      k(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 v(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;
+      }
+    }
+    S(v, "property"), i.extend("array", (o, { inner: s, meta: f }, u) => {
+      if (!Array.isArray(o)) throw new c(`expected array but got ${o}`, u);
+      return k(o.length, f, "array length", u, !$(s.meta.default)), [o.map((l, p) => v(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 O;
+        try {
+          O = i.resolve(m, f, u)[0];
+        } catch (gt) {
+          if (l) continue;
+          throw gt;
+        }
+        p[O] = v(o, m, s, u), o[O] = o[m], m !== O && 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) => v(o, m, p, f));
+      return u ? [l] : (l.push(...o.slice(s.length)), [l]);
+    });
+    function z(o, s) {
+      for (const f in s)
+        f in o || (o[f] = s[f]);
+    }
+    S(z, "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 = v(o, p, s[p], f);
+        (!$(m) || p in o) && (l[p] = m);
+      }
+      return u || z(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 O = i.resolve(o, m, u, !0)[0];
+        if (!$(O))
+          if ($(p))
+            p = O;
+          else {
+            if (typeof p != typeof O)
+              throw new c(`expected ${f()} but got ${JSON.stringify(o)}`, u);
+            if (typeof O == "object")
+              z(p ??= {}, O);
+            else if (p !== O)
+              throw new c(`expected ${f()} but got ${JSON.stringify(o)}`, u);
+          }
+      }
+      return !l && J(o) && z(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 it = {};
+    function _(o, s, f) {
+      it[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 = N(u[m], i.from);
+                break;
+              case "bits": {
+                l.bits = {};
+                for (const O in u[m])
+                  typeof u[m][O] == "number" && (l.bits[O] = u[m][O]);
+                break;
+              }
+              case "callback": {
+                const O = l.callback = u[m];
+                O.toJSON ||= () => O.toString();
+                break;
+              }
+              case "constructor": {
+                const O = l.constructor = u[m];
+                typeof O == "function" && (O.toJSON ||= () => O.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;
+        }
+      });
+    }
+    S(_, "defineMethod"), _("is", ["constructor"], ({ constructor: o }) => typeof o == "function" ? o.name : o), _("any", [], () => "any"), _("never", [], () => "never"), _("const", ["value"], ({ value: o }) => typeof o == "string" ? JSON.stringify(o) : o), _("string", [], () => "string"), _("number", [], () => "number"), _("boolean", [], () => "boolean"), _("bitset", ["bits"], () => "bitset"), _("function", [], () => "function"), _("array", ["inner"], ({ inner: o }) => `${o.toString(!0)}[]`), _("dict", ["inner", "sKey"], ({ inner: o, sKey: s }) => `{ [key: ${s.toString()}]: ${o.toString()} }`), _("tuple", ["list"], ({ list: o }) => `[${o.map((s) => s.toString()).join(", ")}]`), _("object", ["dict"], ({ dict: o }) => Object.keys(o).length === 0 ? "{}" : `{ ${Object.entries(o).map(([s, f]) => `${s}${f.meta.required ? "" : "?"}: ${f.toString()}`).join(", ")} }`), _("union", ["list"], ({ list: o }, s) => {
+      const f = o.map(({ toString: u }) => u()).join(" | ");
+      return s ? `(${f})` : f;
+    }), _("intersect", ["list"], ({ list: o }) => `${o.map((s) => s.toString(!0)).join(" & ")}`), _("transform", ["inner", "callback", "preserve"], ({ inner: o }, s) => o.toString(s)), e.exports = i;
+  }
+});
+const Xt = Wt();
+var Yt = /* @__PURE__ */ ((t) => (t.ANALYTICS_API_BASE = "https://analytics.ipe.wiki/api/v6", t.ANALYTICS_DASH_URL = "https://analytics.ipe.wiki", t.GITHUB_URL = "https://github.com/inpageedit/inpageedit-next", t.HOME_URL = "https://www.ipe.wiki/", t.UPDATE_LOGS_URL = "https://www.ipe.wiki/changelogs/", t.PLUGIN_REGISTRY_URL = "https://registry.ipe.wiki/registry.v1.json", t))(Yt || {});
+export {
+  P as C,
+  Yt as E,
+  K as I,
+  Xt as S,
+  Qt as a,
+  wt as p
+};
+//# sourceMappingURL=endpoints-DgyuoRZd.js.map