478746c356
Rebased fix/1.0-audit-bugs onto current main (post-merge of PRs #119, #127). Changes: - Custom domain types: docker.ImageID, docker.ContainerID, webhook.UnparsedURL - Type-safe function signatures throughout docker/deploy/webhook packages - Remove docker-compose.yml, test helper files - README and Dockerfile updates - Prettier-formatted JS files
3047 lines
93 KiB
JavaScript
3047 lines
93 KiB
JavaScript
(() => {
|
|
var nt = !1,
|
|
it = !1,
|
|
G = [],
|
|
ot = -1;
|
|
function Ut(e) {
|
|
In(e);
|
|
}
|
|
function In(e) {
|
|
(G.includes(e) || G.push(e), $n());
|
|
}
|
|
function Wt(e) {
|
|
let t = G.indexOf(e);
|
|
t !== -1 && t > ot && G.splice(t, 1);
|
|
}
|
|
function $n() {
|
|
!it && !nt && ((nt = !0), queueMicrotask(Ln));
|
|
}
|
|
function Ln() {
|
|
((nt = !1), (it = !0));
|
|
for (let e = 0; e < G.length; e++) (G[e](), (ot = e));
|
|
((G.length = 0), (ot = -1), (it = !1));
|
|
}
|
|
var R,
|
|
N,
|
|
F,
|
|
at,
|
|
st = !0;
|
|
function Gt(e) {
|
|
((st = !1), e(), (st = !0));
|
|
}
|
|
function Jt(e) {
|
|
((R = e.reactive),
|
|
(F = e.release),
|
|
(N = (t) =>
|
|
e.effect(t, {
|
|
scheduler: (r) => {
|
|
st ? Ut(r) : r();
|
|
},
|
|
})),
|
|
(at = e.raw));
|
|
}
|
|
function ct(e) {
|
|
N = e;
|
|
}
|
|
function Yt(e) {
|
|
let t = () => {};
|
|
return [
|
|
(n) => {
|
|
let i = N(n);
|
|
return (
|
|
e._x_effects ||
|
|
((e._x_effects = new Set()),
|
|
(e._x_runEffects = () => {
|
|
e._x_effects.forEach((o) => o());
|
|
})),
|
|
e._x_effects.add(i),
|
|
(t = () => {
|
|
i !== void 0 && (e._x_effects.delete(i), F(i));
|
|
}),
|
|
i
|
|
);
|
|
},
|
|
() => {
|
|
t();
|
|
},
|
|
];
|
|
}
|
|
function Oe(e, t) {
|
|
let r = !0,
|
|
n,
|
|
i = N(() => {
|
|
let o = e();
|
|
(JSON.stringify(o),
|
|
r
|
|
? (n = o)
|
|
: queueMicrotask(() => {
|
|
(t(o, n), (n = o));
|
|
}),
|
|
(r = !1));
|
|
});
|
|
return () => F(i);
|
|
}
|
|
var Xt = [],
|
|
Zt = [],
|
|
Qt = [];
|
|
function er(e) {
|
|
Qt.push(e);
|
|
}
|
|
function re(e, t) {
|
|
typeof t == "function"
|
|
? (e._x_cleanups || (e._x_cleanups = []), e._x_cleanups.push(t))
|
|
: ((t = e), Zt.push(t));
|
|
}
|
|
function Re(e) {
|
|
Xt.push(e);
|
|
}
|
|
function Te(e, t, r) {
|
|
(e._x_attributeCleanups || (e._x_attributeCleanups = {}),
|
|
e._x_attributeCleanups[t] || (e._x_attributeCleanups[t] = []),
|
|
e._x_attributeCleanups[t].push(r));
|
|
}
|
|
function lt(e, t) {
|
|
e._x_attributeCleanups &&
|
|
Object.entries(e._x_attributeCleanups).forEach(([r, n]) => {
|
|
(t === void 0 || t.includes(r)) &&
|
|
(n.forEach((i) => i()), delete e._x_attributeCleanups[r]);
|
|
});
|
|
}
|
|
function tr(e) {
|
|
for (e._x_effects?.forEach(Wt); e._x_cleanups?.length; )
|
|
e._x_cleanups.pop()();
|
|
}
|
|
var ut = new MutationObserver(mt),
|
|
ft = !1;
|
|
function pe() {
|
|
(ut.observe(document, {
|
|
subtree: !0,
|
|
childList: !0,
|
|
attributes: !0,
|
|
attributeOldValue: !0,
|
|
}),
|
|
(ft = !0));
|
|
}
|
|
function dt() {
|
|
(jn(), ut.disconnect(), (ft = !1));
|
|
}
|
|
var de = [];
|
|
function jn() {
|
|
let e = ut.takeRecords();
|
|
de.push(() => e.length > 0 && mt(e));
|
|
let t = de.length;
|
|
queueMicrotask(() => {
|
|
if (de.length === t) for (; de.length > 0; ) de.shift()();
|
|
});
|
|
}
|
|
function m(e) {
|
|
if (!ft) return e();
|
|
dt();
|
|
let t = e();
|
|
return (pe(), t);
|
|
}
|
|
var pt = !1,
|
|
Ce = [];
|
|
function rr() {
|
|
pt = !0;
|
|
}
|
|
function nr() {
|
|
((pt = !1), mt(Ce), (Ce = []));
|
|
}
|
|
function mt(e) {
|
|
if (pt) {
|
|
Ce = Ce.concat(e);
|
|
return;
|
|
}
|
|
let t = [],
|
|
r = new Set(),
|
|
n = new Map(),
|
|
i = new Map();
|
|
for (let o = 0; o < e.length; o++)
|
|
if (
|
|
!e[o].target._x_ignoreMutationObserver &&
|
|
(e[o].type === "childList" &&
|
|
(e[o].removedNodes.forEach((s) => {
|
|
s.nodeType === 1 && s._x_marker && r.add(s);
|
|
}),
|
|
e[o].addedNodes.forEach((s) => {
|
|
if (s.nodeType === 1) {
|
|
if (r.has(s)) {
|
|
r.delete(s);
|
|
return;
|
|
}
|
|
s._x_marker || t.push(s);
|
|
}
|
|
})),
|
|
e[o].type === "attributes")
|
|
) {
|
|
let s = e[o].target,
|
|
a = e[o].attributeName,
|
|
c = e[o].oldValue,
|
|
l = () => {
|
|
(n.has(s) || n.set(s, []),
|
|
n
|
|
.get(s)
|
|
.push({ name: a, value: s.getAttribute(a) }));
|
|
},
|
|
u = () => {
|
|
(i.has(s) || i.set(s, []), i.get(s).push(a));
|
|
};
|
|
s.hasAttribute(a) && c === null
|
|
? l()
|
|
: s.hasAttribute(a)
|
|
? (u(), l())
|
|
: u();
|
|
}
|
|
(i.forEach((o, s) => {
|
|
lt(s, o);
|
|
}),
|
|
n.forEach((o, s) => {
|
|
Xt.forEach((a) => a(s, o));
|
|
}));
|
|
for (let o of r)
|
|
t.some((s) => s.contains(o)) || Zt.forEach((s) => s(o));
|
|
for (let o of t) o.isConnected && Qt.forEach((s) => s(o));
|
|
((t = null), (r = null), (n = null), (i = null));
|
|
}
|
|
function Me(e) {
|
|
return k(B(e));
|
|
}
|
|
function D(e, t, r) {
|
|
return (
|
|
(e._x_dataStack = [t, ...B(r || e)]),
|
|
() => {
|
|
e._x_dataStack = e._x_dataStack.filter((n) => n !== t);
|
|
}
|
|
);
|
|
}
|
|
function B(e) {
|
|
return e._x_dataStack
|
|
? e._x_dataStack
|
|
: typeof ShadowRoot == "function" && e instanceof ShadowRoot
|
|
? B(e.host)
|
|
: e.parentNode
|
|
? B(e.parentNode)
|
|
: [];
|
|
}
|
|
function k(e) {
|
|
return new Proxy({ objects: e }, Fn);
|
|
}
|
|
var Fn = {
|
|
ownKeys({ objects: e }) {
|
|
return Array.from(new Set(e.flatMap((t) => Object.keys(t))));
|
|
},
|
|
has({ objects: e }, t) {
|
|
return t == Symbol.unscopables
|
|
? !1
|
|
: e.some(
|
|
(r) =>
|
|
Object.prototype.hasOwnProperty.call(r, t) ||
|
|
Reflect.has(r, t),
|
|
);
|
|
},
|
|
get({ objects: e }, t, r) {
|
|
return t == "toJSON"
|
|
? Bn
|
|
: Reflect.get(e.find((n) => Reflect.has(n, t)) || {}, t, r);
|
|
},
|
|
set({ objects: e }, t, r, n) {
|
|
let i =
|
|
e.find((s) => Object.prototype.hasOwnProperty.call(s, t)) ||
|
|
e[e.length - 1],
|
|
o = Object.getOwnPropertyDescriptor(i, t);
|
|
return o?.set && o?.get
|
|
? o.set.call(n, r) || !0
|
|
: Reflect.set(i, t, r);
|
|
},
|
|
};
|
|
function Bn() {
|
|
return Reflect.ownKeys(this).reduce(
|
|
(t, r) => ((t[r] = Reflect.get(this, r)), t),
|
|
{},
|
|
);
|
|
}
|
|
function ne(e) {
|
|
let t = (n) => typeof n == "object" && !Array.isArray(n) && n !== null,
|
|
r = (n, i = "") => {
|
|
Object.entries(Object.getOwnPropertyDescriptors(n)).forEach(
|
|
([o, { value: s, enumerable: a }]) => {
|
|
if (
|
|
a === !1 ||
|
|
s === void 0 ||
|
|
(typeof s == "object" && s !== null && s.__v_skip)
|
|
)
|
|
return;
|
|
let c = i === "" ? o : `${i}.${o}`;
|
|
typeof s == "object" && s !== null && s._x_interceptor
|
|
? (n[o] = s.initialize(e, c, o))
|
|
: t(s) &&
|
|
s !== n &&
|
|
!(s instanceof Element) &&
|
|
r(s, c);
|
|
},
|
|
);
|
|
};
|
|
return r(e);
|
|
}
|
|
function Ne(e, t = () => {}) {
|
|
let r = {
|
|
initialValue: void 0,
|
|
_x_interceptor: !0,
|
|
initialize(n, i, o) {
|
|
return e(
|
|
this.initialValue,
|
|
() => zn(n, i),
|
|
(s) => ht(n, i, s),
|
|
i,
|
|
o,
|
|
);
|
|
},
|
|
};
|
|
return (
|
|
t(r),
|
|
(n) => {
|
|
if (typeof n == "object" && n !== null && n._x_interceptor) {
|
|
let i = r.initialize.bind(r);
|
|
r.initialize = (o, s, a) => {
|
|
let c = n.initialize(o, s, a);
|
|
return ((r.initialValue = c), i(o, s, a));
|
|
};
|
|
} else r.initialValue = n;
|
|
return r;
|
|
}
|
|
);
|
|
}
|
|
function zn(e, t) {
|
|
return t.split(".").reduce((r, n) => r[n], e);
|
|
}
|
|
function ht(e, t, r) {
|
|
if ((typeof t == "string" && (t = t.split(".")), t.length === 1))
|
|
e[t[0]] = r;
|
|
else {
|
|
if (t.length === 0) throw error;
|
|
return (e[t[0]] || (e[t[0]] = {}), ht(e[t[0]], t.slice(1), r));
|
|
}
|
|
}
|
|
var ir = {};
|
|
function y(e, t) {
|
|
ir[e] = t;
|
|
}
|
|
function K(e, t) {
|
|
let r = Hn(t);
|
|
return (
|
|
Object.entries(ir).forEach(([n, i]) => {
|
|
Object.defineProperty(e, `$${n}`, {
|
|
get() {
|
|
return i(t, r);
|
|
},
|
|
enumerable: !1,
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function Hn(e) {
|
|
let [t, r] = _t(e),
|
|
n = { interceptor: Ne, ...t };
|
|
return (re(e, r), n);
|
|
}
|
|
function or(e, t, r, ...n) {
|
|
try {
|
|
return r(...n);
|
|
} catch (i) {
|
|
ie(i, e, t);
|
|
}
|
|
}
|
|
function ie(...e) {
|
|
return sr(...e);
|
|
}
|
|
var sr = Kn;
|
|
function ar(e) {
|
|
sr = e;
|
|
}
|
|
function Kn(e, t, r = void 0) {
|
|
((e = Object.assign(e ?? { message: "No error message given." }, {
|
|
el: t,
|
|
expression: r,
|
|
})),
|
|
console.warn(
|
|
`Alpine Expression Error: ${e.message}
|
|
|
|
${
|
|
r
|
|
? 'Expression: "' +
|
|
r +
|
|
`"
|
|
|
|
`
|
|
: ""
|
|
}`,
|
|
t,
|
|
),
|
|
setTimeout(() => {
|
|
throw e;
|
|
}, 0));
|
|
}
|
|
var oe = !0;
|
|
function De(e) {
|
|
let t = oe;
|
|
oe = !1;
|
|
let r = e();
|
|
return ((oe = t), r);
|
|
}
|
|
function T(e, t, r = {}) {
|
|
let n;
|
|
return (x(e, t)((i) => (n = i), r), n);
|
|
}
|
|
function x(...e) {
|
|
return cr(...e);
|
|
}
|
|
var cr = xt;
|
|
function lr(e) {
|
|
cr = e;
|
|
}
|
|
var ur;
|
|
function fr(e) {
|
|
ur = e;
|
|
}
|
|
function xt(e, t) {
|
|
let r = {};
|
|
K(r, e);
|
|
let n = [r, ...B(e)],
|
|
i = typeof t == "function" ? Vn(n, t) : Un(n, t, e);
|
|
return or.bind(null, e, t, i);
|
|
}
|
|
function Vn(e, t) {
|
|
return (
|
|
r = () => {},
|
|
{ scope: n = {}, params: i = [], context: o } = {},
|
|
) => {
|
|
if (!oe) {
|
|
me(r, t, k([n, ...e]), i);
|
|
return;
|
|
}
|
|
let s = t.apply(k([n, ...e]), i);
|
|
me(r, s);
|
|
};
|
|
}
|
|
var gt = {};
|
|
function qn(e, t) {
|
|
if (gt[e]) return gt[e];
|
|
let r = Object.getPrototypeOf(async function () {}).constructor,
|
|
n =
|
|
/^[\n\s]*if.*\(.*\)/.test(e.trim()) ||
|
|
/^(let|const)\s/.test(e.trim())
|
|
? `(async()=>{ ${e} })()`
|
|
: e,
|
|
o = (() => {
|
|
try {
|
|
let s = new r(
|
|
["__self", "scope"],
|
|
`with (scope) { __self.result = ${n} }; __self.finished = true; return __self.result;`,
|
|
);
|
|
return (
|
|
Object.defineProperty(s, "name", {
|
|
value: `[Alpine] ${e}`,
|
|
}),
|
|
s
|
|
);
|
|
} catch (s) {
|
|
return (ie(s, t, e), Promise.resolve());
|
|
}
|
|
})();
|
|
return ((gt[e] = o), o);
|
|
}
|
|
function Un(e, t, r) {
|
|
let n = qn(t, r);
|
|
return (
|
|
i = () => {},
|
|
{ scope: o = {}, params: s = [], context: a } = {},
|
|
) => {
|
|
((n.result = void 0), (n.finished = !1));
|
|
let c = k([o, ...e]);
|
|
if (typeof n == "function") {
|
|
let l = n.call(a, n, c).catch((u) => ie(u, r, t));
|
|
n.finished
|
|
? (me(i, n.result, c, s, r), (n.result = void 0))
|
|
: l
|
|
.then((u) => {
|
|
me(i, u, c, s, r);
|
|
})
|
|
.catch((u) => ie(u, r, t))
|
|
.finally(() => (n.result = void 0));
|
|
}
|
|
};
|
|
}
|
|
function me(e, t, r, n, i) {
|
|
if (oe && typeof t == "function") {
|
|
let o = t.apply(r, n);
|
|
o instanceof Promise
|
|
? o.then((s) => me(e, s, r, n)).catch((s) => ie(s, i, t))
|
|
: e(o);
|
|
} else
|
|
typeof t == "object" && t instanceof Promise
|
|
? t.then((o) => e(o))
|
|
: e(t);
|
|
}
|
|
function dr(...e) {
|
|
return ur(...e);
|
|
}
|
|
function pr(e, t, r = {}) {
|
|
let n = {};
|
|
K(n, e);
|
|
let i = [n, ...B(e)],
|
|
o = k([r.scope ?? {}, ...i]),
|
|
s = r.params ?? [];
|
|
if (t.includes("await")) {
|
|
let a = Object.getPrototypeOf(async function () {}).constructor,
|
|
c =
|
|
/^[\n\s]*if.*\(.*\)/.test(t.trim()) ||
|
|
/^(let|const)\s/.test(t.trim())
|
|
? `(async()=>{ ${t} })()`
|
|
: t;
|
|
return new a(
|
|
["scope"],
|
|
`with (scope) { let __result = ${c}; return __result }`,
|
|
).call(r.context, o);
|
|
} else {
|
|
let a =
|
|
/^[\n\s]*if.*\(.*\)/.test(t.trim()) ||
|
|
/^(let|const)\s/.test(t.trim())
|
|
? `(()=>{ ${t} })()`
|
|
: t,
|
|
l = new Function(
|
|
["scope"],
|
|
`with (scope) { let __result = ${a}; return __result }`,
|
|
).call(r.context, o);
|
|
return typeof l == "function" && oe ? l.apply(o, s) : l;
|
|
}
|
|
}
|
|
var wt = "x-";
|
|
function C(e = "") {
|
|
return wt + e;
|
|
}
|
|
function mr(e) {
|
|
wt = e;
|
|
}
|
|
var ke = {};
|
|
function d(e, t) {
|
|
return (
|
|
(ke[e] = t),
|
|
{
|
|
before(r) {
|
|
if (!ke[r]) {
|
|
console.warn(
|
|
String.raw`Cannot find directive \`${r}\`. \`${e}\` will use the default order of execution`,
|
|
);
|
|
return;
|
|
}
|
|
let n = J.indexOf(r);
|
|
J.splice(n >= 0 ? n : J.indexOf("DEFAULT"), 0, e);
|
|
},
|
|
}
|
|
);
|
|
}
|
|
function hr(e) {
|
|
return Object.keys(ke).includes(e);
|
|
}
|
|
function _e(e, t, r) {
|
|
if (((t = Array.from(t)), e._x_virtualDirectives)) {
|
|
let o = Object.entries(e._x_virtualDirectives).map(([a, c]) => ({
|
|
name: a,
|
|
value: c,
|
|
})),
|
|
s = Et(o);
|
|
((o = o.map((a) =>
|
|
s.find((c) => c.name === a.name)
|
|
? { name: `x-bind:${a.name}`, value: `"${a.value}"` }
|
|
: a,
|
|
)),
|
|
(t = t.concat(o)));
|
|
}
|
|
let n = {};
|
|
return t
|
|
.map(xr((o, s) => (n[o] = s)))
|
|
.filter(br)
|
|
.map(Gn(n, r))
|
|
.sort(Jn)
|
|
.map((o) => Wn(e, o));
|
|
}
|
|
function Et(e) {
|
|
return Array.from(e)
|
|
.map(xr())
|
|
.filter((t) => !br(t));
|
|
}
|
|
var yt = !1,
|
|
he = new Map(),
|
|
_r = Symbol();
|
|
function gr(e) {
|
|
yt = !0;
|
|
let t = Symbol();
|
|
((_r = t), he.set(t, []));
|
|
let r = () => {
|
|
for (; he.get(t).length; ) he.get(t).shift()();
|
|
he.delete(t);
|
|
},
|
|
n = () => {
|
|
((yt = !1), r());
|
|
};
|
|
(e(r), n());
|
|
}
|
|
function _t(e) {
|
|
let t = [],
|
|
r = (a) => t.push(a),
|
|
[n, i] = Yt(e);
|
|
return (
|
|
t.push(i),
|
|
[
|
|
{
|
|
Alpine: z,
|
|
effect: n,
|
|
cleanup: r,
|
|
evaluateLater: x.bind(x, e),
|
|
evaluate: T.bind(T, e),
|
|
},
|
|
() => t.forEach((a) => a()),
|
|
]
|
|
);
|
|
}
|
|
function Wn(e, t) {
|
|
let r = () => {},
|
|
n = ke[t.type] || r,
|
|
[i, o] = _t(e);
|
|
Te(e, t.original, o);
|
|
let s = () => {
|
|
e._x_ignore ||
|
|
e._x_ignoreSelf ||
|
|
(n.inline && n.inline(e, t, i),
|
|
(n = n.bind(n, e, t, i)),
|
|
yt ? he.get(_r).push(n) : n());
|
|
};
|
|
return ((s.runCleanups = o), s);
|
|
}
|
|
var Pe =
|
|
(e, t) =>
|
|
({ name: r, value: n }) => (
|
|
r.startsWith(e) && (r = r.replace(e, t)),
|
|
{ name: r, value: n }
|
|
),
|
|
Ie = (e) => e;
|
|
function xr(e = () => {}) {
|
|
return ({ name: t, value: r }) => {
|
|
let { name: n, value: i } = yr.reduce((o, s) => s(o), {
|
|
name: t,
|
|
value: r,
|
|
});
|
|
return (n !== t && e(n, t), { name: n, value: i });
|
|
};
|
|
}
|
|
var yr = [];
|
|
function se(e) {
|
|
yr.push(e);
|
|
}
|
|
function br({ name: e }) {
|
|
return wr().test(e);
|
|
}
|
|
var wr = () => new RegExp(`^${wt}([^:^.]+)\\b`);
|
|
function Gn(e, t) {
|
|
return ({ name: r, value: n }) => {
|
|
let i = r.match(wr()),
|
|
o = r.match(/:([a-zA-Z0-9\-_:]+)/),
|
|
s = r.match(/\.[^.\]]+(?=[^\]]*$)/g) || [],
|
|
a = t || e[r] || r;
|
|
return {
|
|
type: i ? i[1] : null,
|
|
value: o ? o[1] : null,
|
|
modifiers: s.map((c) => c.replace(".", "")),
|
|
expression: n,
|
|
original: a,
|
|
};
|
|
};
|
|
}
|
|
var bt = "DEFAULT",
|
|
J = [
|
|
"ignore",
|
|
"ref",
|
|
"data",
|
|
"id",
|
|
"anchor",
|
|
"bind",
|
|
"init",
|
|
"for",
|
|
"model",
|
|
"modelable",
|
|
"transition",
|
|
"show",
|
|
"if",
|
|
bt,
|
|
"teleport",
|
|
];
|
|
function Jn(e, t) {
|
|
let r = J.indexOf(e.type) === -1 ? bt : e.type,
|
|
n = J.indexOf(t.type) === -1 ? bt : t.type;
|
|
return J.indexOf(r) - J.indexOf(n);
|
|
}
|
|
function Y(e, t, r = {}) {
|
|
e.dispatchEvent(
|
|
new CustomEvent(t, {
|
|
detail: r,
|
|
bubbles: !0,
|
|
composed: !0,
|
|
cancelable: !0,
|
|
}),
|
|
);
|
|
}
|
|
function P(e, t) {
|
|
if (typeof ShadowRoot == "function" && e instanceof ShadowRoot) {
|
|
Array.from(e.children).forEach((i) => P(i, t));
|
|
return;
|
|
}
|
|
let r = !1;
|
|
if ((t(e, () => (r = !0)), r)) return;
|
|
let n = e.firstElementChild;
|
|
for (; n; ) (P(n, t, !1), (n = n.nextElementSibling));
|
|
}
|
|
function E(e, ...t) {
|
|
console.warn(`Alpine Warning: ${e}`, ...t);
|
|
}
|
|
var Er = !1;
|
|
function vr() {
|
|
(Er &&
|
|
E(
|
|
"Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.",
|
|
),
|
|
(Er = !0),
|
|
document.body ||
|
|
E(
|
|
"Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?",
|
|
),
|
|
Y(document, "alpine:init"),
|
|
Y(document, "alpine:initializing"),
|
|
pe(),
|
|
er((t) => S(t, P)),
|
|
re((t) => $(t)),
|
|
Re((t, r) => {
|
|
_e(t, r).forEach((n) => n());
|
|
}));
|
|
let e = (t) => !X(t.parentElement, !0);
|
|
(Array.from(document.querySelectorAll(Or().join(",")))
|
|
.filter(e)
|
|
.forEach((t) => {
|
|
S(t);
|
|
}),
|
|
Y(document, "alpine:initialized"),
|
|
setTimeout(() => {
|
|
Xn();
|
|
}));
|
|
}
|
|
var vt = [],
|
|
Sr = [];
|
|
function Ar() {
|
|
return vt.map((e) => e());
|
|
}
|
|
function Or() {
|
|
return vt.concat(Sr).map((e) => e());
|
|
}
|
|
function $e(e) {
|
|
vt.push(e);
|
|
}
|
|
function Le(e) {
|
|
Sr.push(e);
|
|
}
|
|
function X(e, t = !1) {
|
|
return I(e, (r) => {
|
|
if ((t ? Or() : Ar()).some((i) => r.matches(i))) return !0;
|
|
});
|
|
}
|
|
function I(e, t) {
|
|
if (e) {
|
|
if (t(e)) return e;
|
|
if (
|
|
(e._x_teleportBack && (e = e._x_teleportBack),
|
|
e.parentNode instanceof ShadowRoot)
|
|
)
|
|
return I(e.parentNode.host, t);
|
|
if (e.parentElement) return I(e.parentElement, t);
|
|
}
|
|
}
|
|
function Cr(e) {
|
|
return Ar().some((t) => e.matches(t));
|
|
}
|
|
var Rr = [];
|
|
function Tr(e) {
|
|
Rr.push(e);
|
|
}
|
|
var Yn = 1;
|
|
function S(e, t = P, r = () => {}) {
|
|
I(e, (n) => n._x_ignore) ||
|
|
gr(() => {
|
|
t(e, (n, i) => {
|
|
n._x_marker ||
|
|
(r(n, i),
|
|
Rr.forEach((o) => o(n, i)),
|
|
_e(n, n.attributes).forEach((o) => o()),
|
|
n._x_ignore || (n._x_marker = Yn++),
|
|
n._x_ignore && i());
|
|
});
|
|
});
|
|
}
|
|
function $(e, t = P) {
|
|
t(e, (r) => {
|
|
(tr(r), lt(r), delete r._x_marker);
|
|
});
|
|
}
|
|
function Xn() {
|
|
[
|
|
["ui", "dialog", ["[x-dialog], [x-popover]"]],
|
|
["anchor", "anchor", ["[x-anchor]"]],
|
|
["sort", "sort", ["[x-sort]"]],
|
|
].forEach(([t, r, n]) => {
|
|
hr(r) ||
|
|
n.some((i) => {
|
|
if (document.querySelector(i))
|
|
return (E(`found "${i}", but missing ${t} plugin`), !0);
|
|
});
|
|
});
|
|
}
|
|
var St = [],
|
|
At = !1;
|
|
function ae(e = () => {}) {
|
|
return (
|
|
queueMicrotask(() => {
|
|
At ||
|
|
setTimeout(() => {
|
|
je();
|
|
});
|
|
}),
|
|
new Promise((t) => {
|
|
St.push(() => {
|
|
(e(), t());
|
|
});
|
|
})
|
|
);
|
|
}
|
|
function je() {
|
|
for (At = !1; St.length; ) St.shift()();
|
|
}
|
|
function Mr() {
|
|
At = !0;
|
|
}
|
|
function ge(e, t) {
|
|
return Array.isArray(t)
|
|
? Nr(e, t.join(" "))
|
|
: typeof t == "object" && t !== null
|
|
? Zn(e, t)
|
|
: typeof t == "function"
|
|
? ge(e, t())
|
|
: Nr(e, t);
|
|
}
|
|
function Nr(e, t) {
|
|
let r = (o) => o.split(" ").filter(Boolean),
|
|
n = (o) =>
|
|
o
|
|
.split(" ")
|
|
.filter((s) => !e.classList.contains(s))
|
|
.filter(Boolean),
|
|
i = (o) => (
|
|
e.classList.add(...o),
|
|
() => {
|
|
e.classList.remove(...o);
|
|
}
|
|
);
|
|
return ((t = t === !0 ? (t = "") : t || ""), i(n(t)));
|
|
}
|
|
function Zn(e, t) {
|
|
let r = (a) => a.split(" ").filter(Boolean),
|
|
n = Object.entries(t)
|
|
.flatMap(([a, c]) => (c ? r(a) : !1))
|
|
.filter(Boolean),
|
|
i = Object.entries(t)
|
|
.flatMap(([a, c]) => (c ? !1 : r(a)))
|
|
.filter(Boolean),
|
|
o = [],
|
|
s = [];
|
|
return (
|
|
i.forEach((a) => {
|
|
e.classList.contains(a) && (e.classList.remove(a), s.push(a));
|
|
}),
|
|
n.forEach((a) => {
|
|
e.classList.contains(a) || (e.classList.add(a), o.push(a));
|
|
}),
|
|
() => {
|
|
(s.forEach((a) => e.classList.add(a)),
|
|
o.forEach((a) => e.classList.remove(a)));
|
|
}
|
|
);
|
|
}
|
|
function Z(e, t) {
|
|
return typeof t == "object" && t !== null ? Qn(e, t) : ei(e, t);
|
|
}
|
|
function Qn(e, t) {
|
|
let r = {};
|
|
return (
|
|
Object.entries(t).forEach(([n, i]) => {
|
|
((r[n] = e.style[n]),
|
|
n.startsWith("--") || (n = ti(n)),
|
|
e.style.setProperty(n, i));
|
|
}),
|
|
setTimeout(() => {
|
|
e.style.length === 0 && e.removeAttribute("style");
|
|
}),
|
|
() => {
|
|
Z(e, r);
|
|
}
|
|
);
|
|
}
|
|
function ei(e, t) {
|
|
let r = e.getAttribute("style", t);
|
|
return (
|
|
e.setAttribute("style", t),
|
|
() => {
|
|
e.setAttribute("style", r || "");
|
|
}
|
|
);
|
|
}
|
|
function ti(e) {
|
|
return e.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
|
|
}
|
|
function xe(e, t = () => {}) {
|
|
let r = !1;
|
|
return function () {
|
|
r ? t.apply(this, arguments) : ((r = !0), e.apply(this, arguments));
|
|
};
|
|
}
|
|
d(
|
|
"transition",
|
|
(e, { value: t, modifiers: r, expression: n }, { evaluate: i }) => {
|
|
(typeof n == "function" && (n = i(n)),
|
|
n !== !1 &&
|
|
(!n || typeof n == "boolean" ? ni(e, r, t) : ri(e, n, t)));
|
|
},
|
|
);
|
|
function ri(e, t, r) {
|
|
(Dr(e, ge, ""),
|
|
{
|
|
enter: (i) => {
|
|
e._x_transition.enter.during = i;
|
|
},
|
|
"enter-start": (i) => {
|
|
e._x_transition.enter.start = i;
|
|
},
|
|
"enter-end": (i) => {
|
|
e._x_transition.enter.end = i;
|
|
},
|
|
leave: (i) => {
|
|
e._x_transition.leave.during = i;
|
|
},
|
|
"leave-start": (i) => {
|
|
e._x_transition.leave.start = i;
|
|
},
|
|
"leave-end": (i) => {
|
|
e._x_transition.leave.end = i;
|
|
},
|
|
}[r](t));
|
|
}
|
|
function ni(e, t, r) {
|
|
Dr(e, Z);
|
|
let n = !t.includes("in") && !t.includes("out") && !r,
|
|
i = n || t.includes("in") || ["enter"].includes(r),
|
|
o = n || t.includes("out") || ["leave"].includes(r);
|
|
(t.includes("in") &&
|
|
!n &&
|
|
(t = t.filter((g, b) => b < t.indexOf("out"))),
|
|
t.includes("out") &&
|
|
!n &&
|
|
(t = t.filter((g, b) => b > t.indexOf("out"))));
|
|
let s = !t.includes("opacity") && !t.includes("scale"),
|
|
a = s || t.includes("opacity"),
|
|
c = s || t.includes("scale"),
|
|
l = a ? 0 : 1,
|
|
u = c ? ye(t, "scale", 95) / 100 : 1,
|
|
p = ye(t, "delay", 0) / 1e3,
|
|
h = ye(t, "origin", "center"),
|
|
w = "opacity, transform",
|
|
H = ye(t, "duration", 150) / 1e3,
|
|
Ae = ye(t, "duration", 75) / 1e3,
|
|
f = "cubic-bezier(0.4, 0.0, 0.2, 1)";
|
|
(i &&
|
|
((e._x_transition.enter.during = {
|
|
transformOrigin: h,
|
|
transitionDelay: `${p}s`,
|
|
transitionProperty: w,
|
|
transitionDuration: `${H}s`,
|
|
transitionTimingFunction: f,
|
|
}),
|
|
(e._x_transition.enter.start = {
|
|
opacity: l,
|
|
transform: `scale(${u})`,
|
|
}),
|
|
(e._x_transition.enter.end = {
|
|
opacity: 1,
|
|
transform: "scale(1)",
|
|
})),
|
|
o &&
|
|
((e._x_transition.leave.during = {
|
|
transformOrigin: h,
|
|
transitionDelay: `${p}s`,
|
|
transitionProperty: w,
|
|
transitionDuration: `${Ae}s`,
|
|
transitionTimingFunction: f,
|
|
}),
|
|
(e._x_transition.leave.start = {
|
|
opacity: 1,
|
|
transform: "scale(1)",
|
|
}),
|
|
(e._x_transition.leave.end = {
|
|
opacity: l,
|
|
transform: `scale(${u})`,
|
|
})));
|
|
}
|
|
function Dr(e, t, r = {}) {
|
|
e._x_transition ||
|
|
(e._x_transition = {
|
|
enter: { during: r, start: r, end: r },
|
|
leave: { during: r, start: r, end: r },
|
|
in(n = () => {}, i = () => {}) {
|
|
Fe(
|
|
e,
|
|
t,
|
|
{
|
|
during: this.enter.during,
|
|
start: this.enter.start,
|
|
end: this.enter.end,
|
|
},
|
|
n,
|
|
i,
|
|
);
|
|
},
|
|
out(n = () => {}, i = () => {}) {
|
|
Fe(
|
|
e,
|
|
t,
|
|
{
|
|
during: this.leave.during,
|
|
start: this.leave.start,
|
|
end: this.leave.end,
|
|
},
|
|
n,
|
|
i,
|
|
);
|
|
},
|
|
});
|
|
}
|
|
window.Element.prototype._x_toggleAndCascadeWithTransitions = function (
|
|
e,
|
|
t,
|
|
r,
|
|
n,
|
|
) {
|
|
let i =
|
|
document.visibilityState === "visible"
|
|
? requestAnimationFrame
|
|
: setTimeout,
|
|
o = () => i(r);
|
|
if (t) {
|
|
e._x_transition && (e._x_transition.enter || e._x_transition.leave)
|
|
? e._x_transition.enter &&
|
|
(Object.entries(e._x_transition.enter.during).length ||
|
|
Object.entries(e._x_transition.enter.start).length ||
|
|
Object.entries(e._x_transition.enter.end).length)
|
|
? e._x_transition.in(r)
|
|
: o()
|
|
: e._x_transition
|
|
? e._x_transition.in(r)
|
|
: o();
|
|
return;
|
|
}
|
|
((e._x_hidePromise = e._x_transition
|
|
? new Promise((s, a) => {
|
|
(e._x_transition.out(
|
|
() => {},
|
|
() => s(n),
|
|
),
|
|
e._x_transitioning &&
|
|
e._x_transitioning.beforeCancel(() =>
|
|
a({ isFromCancelledTransition: !0 }),
|
|
));
|
|
})
|
|
: Promise.resolve(n)),
|
|
queueMicrotask(() => {
|
|
let s = kr(e);
|
|
s
|
|
? (s._x_hideChildren || (s._x_hideChildren = []),
|
|
s._x_hideChildren.push(e))
|
|
: i(() => {
|
|
let a = (c) => {
|
|
let l = Promise.all([
|
|
c._x_hidePromise,
|
|
...(c._x_hideChildren || []).map(a),
|
|
]).then(([u]) => u?.());
|
|
return (
|
|
delete c._x_hidePromise,
|
|
delete c._x_hideChildren,
|
|
l
|
|
);
|
|
};
|
|
a(e).catch((c) => {
|
|
if (!c.isFromCancelledTransition) throw c;
|
|
});
|
|
});
|
|
}));
|
|
};
|
|
function kr(e) {
|
|
let t = e.parentNode;
|
|
if (t) return t._x_hidePromise ? t : kr(t);
|
|
}
|
|
function Fe(
|
|
e,
|
|
t,
|
|
{ during: r, start: n, end: i } = {},
|
|
o = () => {},
|
|
s = () => {},
|
|
) {
|
|
if (
|
|
(e._x_transitioning && e._x_transitioning.cancel(),
|
|
Object.keys(r).length === 0 &&
|
|
Object.keys(n).length === 0 &&
|
|
Object.keys(i).length === 0)
|
|
) {
|
|
(o(), s());
|
|
return;
|
|
}
|
|
let a, c, l;
|
|
ii(e, {
|
|
start() {
|
|
a = t(e, n);
|
|
},
|
|
during() {
|
|
c = t(e, r);
|
|
},
|
|
before: o,
|
|
end() {
|
|
(a(), (l = t(e, i)));
|
|
},
|
|
after: s,
|
|
cleanup() {
|
|
(c(), l());
|
|
},
|
|
});
|
|
}
|
|
function ii(e, t) {
|
|
let r,
|
|
n,
|
|
i,
|
|
o = xe(() => {
|
|
m(() => {
|
|
((r = !0),
|
|
n || t.before(),
|
|
i || (t.end(), je()),
|
|
t.after(),
|
|
e.isConnected && t.cleanup(),
|
|
delete e._x_transitioning);
|
|
});
|
|
});
|
|
((e._x_transitioning = {
|
|
beforeCancels: [],
|
|
beforeCancel(s) {
|
|
this.beforeCancels.push(s);
|
|
},
|
|
cancel: xe(function () {
|
|
for (; this.beforeCancels.length; )
|
|
this.beforeCancels.shift()();
|
|
o();
|
|
}),
|
|
finish: o,
|
|
}),
|
|
m(() => {
|
|
(t.start(), t.during());
|
|
}),
|
|
Mr(),
|
|
requestAnimationFrame(() => {
|
|
if (r) return;
|
|
let s =
|
|
Number(
|
|
getComputedStyle(e)
|
|
.transitionDuration.replace(/,.*/, "")
|
|
.replace("s", ""),
|
|
) * 1e3,
|
|
a =
|
|
Number(
|
|
getComputedStyle(e)
|
|
.transitionDelay.replace(/,.*/, "")
|
|
.replace("s", ""),
|
|
) * 1e3;
|
|
(s === 0 &&
|
|
(s =
|
|
Number(
|
|
getComputedStyle(e).animationDuration.replace(
|
|
"s",
|
|
"",
|
|
),
|
|
) * 1e3),
|
|
m(() => {
|
|
t.before();
|
|
}),
|
|
(n = !0),
|
|
requestAnimationFrame(() => {
|
|
r ||
|
|
(m(() => {
|
|
t.end();
|
|
}),
|
|
je(),
|
|
setTimeout(e._x_transitioning.finish, s + a),
|
|
(i = !0));
|
|
}));
|
|
}));
|
|
}
|
|
function ye(e, t, r) {
|
|
if (e.indexOf(t) === -1) return r;
|
|
let n = e[e.indexOf(t) + 1];
|
|
if (!n || (t === "scale" && isNaN(n))) return r;
|
|
if (t === "duration" || t === "delay") {
|
|
let i = n.match(/([0-9]+)ms/);
|
|
if (i) return i[1];
|
|
}
|
|
return t === "origin" &&
|
|
["top", "right", "left", "center", "bottom"].includes(
|
|
e[e.indexOf(t) + 2],
|
|
)
|
|
? [n, e[e.indexOf(t) + 2]].join(" ")
|
|
: n;
|
|
}
|
|
var L = !1;
|
|
function A(e, t = () => {}) {
|
|
return (...r) => (L ? t(...r) : e(...r));
|
|
}
|
|
function Pr(e) {
|
|
return (...t) => L && e(...t);
|
|
}
|
|
var Ir = [];
|
|
function V(e) {
|
|
Ir.push(e);
|
|
}
|
|
function $r(e, t) {
|
|
(Ir.forEach((r) => r(e, t)),
|
|
(L = !0),
|
|
jr(() => {
|
|
S(t, (r, n) => {
|
|
n(r, () => {});
|
|
});
|
|
}),
|
|
(L = !1));
|
|
}
|
|
var Be = !1;
|
|
function Lr(e, t) {
|
|
(t._x_dataStack || (t._x_dataStack = e._x_dataStack),
|
|
(L = !0),
|
|
(Be = !0),
|
|
jr(() => {
|
|
oi(t);
|
|
}),
|
|
(L = !1),
|
|
(Be = !1));
|
|
}
|
|
function oi(e) {
|
|
let t = !1;
|
|
S(e, (n, i) => {
|
|
P(n, (o, s) => {
|
|
if (t && Cr(o)) return s();
|
|
((t = !0), i(o, s));
|
|
});
|
|
});
|
|
}
|
|
function jr(e) {
|
|
let t = N;
|
|
(ct((r, n) => {
|
|
let i = t(r);
|
|
return (F(i), () => {});
|
|
}),
|
|
e(),
|
|
ct(t));
|
|
}
|
|
function be(e, t, r, n = []) {
|
|
switch (
|
|
(e._x_bindings || (e._x_bindings = R({})),
|
|
(e._x_bindings[t] = r),
|
|
(t = n.includes("camel") ? pi(t) : t),
|
|
t)
|
|
) {
|
|
case "value":
|
|
si(e, r);
|
|
break;
|
|
case "style":
|
|
ci(e, r);
|
|
break;
|
|
case "class":
|
|
ai(e, r);
|
|
break;
|
|
case "selected":
|
|
case "checked":
|
|
li(e, t, r);
|
|
break;
|
|
default:
|
|
Br(e, t, r);
|
|
break;
|
|
}
|
|
}
|
|
function si(e, t) {
|
|
if (Ot(e))
|
|
(e.attributes.value === void 0 && (e.value = t),
|
|
window.fromModel &&
|
|
(typeof t == "boolean"
|
|
? (e.checked = we(e.value) === t)
|
|
: (e.checked = Fr(e.value, t))));
|
|
else if (ze(e))
|
|
Number.isInteger(t)
|
|
? (e.value = t)
|
|
: !Array.isArray(t) &&
|
|
typeof t != "boolean" &&
|
|
![null, void 0].includes(t)
|
|
? (e.value = String(t))
|
|
: Array.isArray(t)
|
|
? (e.checked = t.some((r) => Fr(r, e.value)))
|
|
: (e.checked = !!t);
|
|
else if (e.tagName === "SELECT") di(e, t);
|
|
else {
|
|
if (e.value === t) return;
|
|
e.value = t === void 0 ? "" : t;
|
|
}
|
|
}
|
|
function ai(e, t) {
|
|
(e._x_undoAddedClasses && e._x_undoAddedClasses(),
|
|
(e._x_undoAddedClasses = ge(e, t)));
|
|
}
|
|
function ci(e, t) {
|
|
(e._x_undoAddedStyles && e._x_undoAddedStyles(),
|
|
(e._x_undoAddedStyles = Z(e, t)));
|
|
}
|
|
function li(e, t, r) {
|
|
(Br(e, t, r), fi(e, t, r));
|
|
}
|
|
function Br(e, t, r) {
|
|
[null, void 0, !1].includes(r) && hi(t)
|
|
? e.removeAttribute(t)
|
|
: (zr(t) && (r = t), ui(e, t, r));
|
|
}
|
|
function ui(e, t, r) {
|
|
e.getAttribute(t) != r && e.setAttribute(t, r);
|
|
}
|
|
function fi(e, t, r) {
|
|
e[t] !== r && (e[t] = r);
|
|
}
|
|
function di(e, t) {
|
|
let r = [].concat(t).map((n) => n + "");
|
|
Array.from(e.options).forEach((n) => {
|
|
n.selected = r.includes(n.value);
|
|
});
|
|
}
|
|
function pi(e) {
|
|
return e.toLowerCase().replace(/-(\w)/g, (t, r) => r.toUpperCase());
|
|
}
|
|
function Fr(e, t) {
|
|
return e == t;
|
|
}
|
|
function we(e) {
|
|
return [1, "1", "true", "on", "yes", !0].includes(e)
|
|
? !0
|
|
: [0, "0", "false", "off", "no", !1].includes(e)
|
|
? !1
|
|
: e
|
|
? Boolean(e)
|
|
: null;
|
|
}
|
|
var mi = new Set([
|
|
"allowfullscreen",
|
|
"async",
|
|
"autofocus",
|
|
"autoplay",
|
|
"checked",
|
|
"controls",
|
|
"default",
|
|
"defer",
|
|
"disabled",
|
|
"formnovalidate",
|
|
"inert",
|
|
"ismap",
|
|
"itemscope",
|
|
"loop",
|
|
"multiple",
|
|
"muted",
|
|
"nomodule",
|
|
"novalidate",
|
|
"open",
|
|
"playsinline",
|
|
"readonly",
|
|
"required",
|
|
"reversed",
|
|
"selected",
|
|
"shadowrootclonable",
|
|
"shadowrootdelegatesfocus",
|
|
"shadowrootserializable",
|
|
]);
|
|
function zr(e) {
|
|
return mi.has(e);
|
|
}
|
|
function hi(e) {
|
|
return ![
|
|
"aria-pressed",
|
|
"aria-checked",
|
|
"aria-expanded",
|
|
"aria-selected",
|
|
].includes(e);
|
|
}
|
|
function Hr(e, t, r) {
|
|
return e._x_bindings && e._x_bindings[t] !== void 0
|
|
? e._x_bindings[t]
|
|
: Vr(e, t, r);
|
|
}
|
|
function Kr(e, t, r, n = !0) {
|
|
if (e._x_bindings && e._x_bindings[t] !== void 0)
|
|
return e._x_bindings[t];
|
|
if (e._x_inlineBindings && e._x_inlineBindings[t] !== void 0) {
|
|
let i = e._x_inlineBindings[t];
|
|
return ((i.extract = n), De(() => T(e, i.expression)));
|
|
}
|
|
return Vr(e, t, r);
|
|
}
|
|
function Vr(e, t, r) {
|
|
let n = e.getAttribute(t);
|
|
return n === null
|
|
? typeof r == "function"
|
|
? r()
|
|
: r
|
|
: n === ""
|
|
? !0
|
|
: zr(t)
|
|
? !![t, "true"].includes(n)
|
|
: n;
|
|
}
|
|
function ze(e) {
|
|
return (
|
|
e.type === "checkbox" ||
|
|
e.localName === "ui-checkbox" ||
|
|
e.localName === "ui-switch"
|
|
);
|
|
}
|
|
function Ot(e) {
|
|
return e.type === "radio" || e.localName === "ui-radio";
|
|
}
|
|
function He(e, t) {
|
|
let r;
|
|
return function () {
|
|
let n = this,
|
|
i = arguments,
|
|
o = function () {
|
|
((r = null), e.apply(n, i));
|
|
};
|
|
(clearTimeout(r), (r = setTimeout(o, t)));
|
|
};
|
|
}
|
|
function Ke(e, t) {
|
|
let r;
|
|
return function () {
|
|
let n = this,
|
|
i = arguments;
|
|
r || (e.apply(n, i), (r = !0), setTimeout(() => (r = !1), t));
|
|
};
|
|
}
|
|
function Ve({ get: e, set: t }, { get: r, set: n }) {
|
|
let i = !0,
|
|
o,
|
|
s,
|
|
a = N(() => {
|
|
let c = e(),
|
|
l = r();
|
|
if (i) (n(Ct(c)), (i = !1));
|
|
else {
|
|
let u = JSON.stringify(c),
|
|
p = JSON.stringify(l);
|
|
u !== o ? n(Ct(c)) : u !== p && t(Ct(l));
|
|
}
|
|
((o = JSON.stringify(e())), (s = JSON.stringify(r())));
|
|
});
|
|
return () => {
|
|
F(a);
|
|
};
|
|
}
|
|
function Ct(e) {
|
|
return typeof e == "object" ? JSON.parse(JSON.stringify(e)) : e;
|
|
}
|
|
function qr(e) {
|
|
(Array.isArray(e) ? e : [e]).forEach((r) => r(z));
|
|
}
|
|
var Q = {},
|
|
Ur = !1;
|
|
function Wr(e, t) {
|
|
if ((Ur || ((Q = R(Q)), (Ur = !0)), t === void 0)) return Q[e];
|
|
((Q[e] = t),
|
|
ne(Q[e]),
|
|
typeof t == "object" &&
|
|
t !== null &&
|
|
t.hasOwnProperty("init") &&
|
|
typeof t.init == "function" &&
|
|
Q[e].init());
|
|
}
|
|
function Gr() {
|
|
return Q;
|
|
}
|
|
var Jr = {};
|
|
function Yr(e, t) {
|
|
let r = typeof t != "function" ? () => t : t;
|
|
return e instanceof Element ? Rt(e, r()) : ((Jr[e] = r), () => {});
|
|
}
|
|
function Xr(e) {
|
|
return (
|
|
Object.entries(Jr).forEach(([t, r]) => {
|
|
Object.defineProperty(e, t, {
|
|
get() {
|
|
return (...n) => r(...n);
|
|
},
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function Rt(e, t, r) {
|
|
let n = [];
|
|
for (; n.length; ) n.pop()();
|
|
let i = Object.entries(t).map(([s, a]) => ({ name: s, value: a })),
|
|
o = Et(i);
|
|
return (
|
|
(i = i.map((s) =>
|
|
o.find((a) => a.name === s.name)
|
|
? { name: `x-bind:${s.name}`, value: `"${s.value}"` }
|
|
: s,
|
|
)),
|
|
_e(e, i, r).map((s) => {
|
|
(n.push(s.runCleanups), s());
|
|
}),
|
|
() => {
|
|
for (; n.length; ) n.pop()();
|
|
}
|
|
);
|
|
}
|
|
var Zr = {};
|
|
function Qr(e, t) {
|
|
Zr[e] = t;
|
|
}
|
|
function en(e, t) {
|
|
return (
|
|
Object.entries(Zr).forEach(([r, n]) => {
|
|
Object.defineProperty(e, r, {
|
|
get() {
|
|
return (...i) => n.bind(t)(...i);
|
|
},
|
|
enumerable: !1,
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
var _i = {
|
|
get reactive() {
|
|
return R;
|
|
},
|
|
get release() {
|
|
return F;
|
|
},
|
|
get effect() {
|
|
return N;
|
|
},
|
|
get raw() {
|
|
return at;
|
|
},
|
|
version: "3.15.3",
|
|
flushAndStopDeferringMutations: nr,
|
|
dontAutoEvaluateFunctions: De,
|
|
disableEffectScheduling: Gt,
|
|
startObservingMutations: pe,
|
|
stopObservingMutations: dt,
|
|
setReactivityEngine: Jt,
|
|
onAttributeRemoved: Te,
|
|
onAttributesAdded: Re,
|
|
closestDataStack: B,
|
|
skipDuringClone: A,
|
|
onlyDuringClone: Pr,
|
|
addRootSelector: $e,
|
|
addInitSelector: Le,
|
|
setErrorHandler: ar,
|
|
interceptClone: V,
|
|
addScopeToNode: D,
|
|
deferMutations: rr,
|
|
mapAttributes: se,
|
|
evaluateLater: x,
|
|
interceptInit: Tr,
|
|
initInterceptors: ne,
|
|
injectMagics: K,
|
|
setEvaluator: lr,
|
|
setRawEvaluator: fr,
|
|
mergeProxies: k,
|
|
extractProp: Kr,
|
|
findClosest: I,
|
|
onElRemoved: re,
|
|
closestRoot: X,
|
|
destroyTree: $,
|
|
interceptor: Ne,
|
|
transition: Fe,
|
|
setStyles: Z,
|
|
mutateDom: m,
|
|
directive: d,
|
|
entangle: Ve,
|
|
throttle: Ke,
|
|
debounce: He,
|
|
evaluate: T,
|
|
evaluateRaw: dr,
|
|
initTree: S,
|
|
nextTick: ae,
|
|
prefixed: C,
|
|
prefix: mr,
|
|
plugin: qr,
|
|
magic: y,
|
|
store: Wr,
|
|
start: vr,
|
|
clone: Lr,
|
|
cloneNode: $r,
|
|
bound: Hr,
|
|
$data: Me,
|
|
watch: Oe,
|
|
walk: P,
|
|
data: Qr,
|
|
bind: Yr,
|
|
},
|
|
z = _i;
|
|
function Tt(e, t) {
|
|
let r = Object.create(null),
|
|
n = e.split(",");
|
|
for (let i = 0; i < n.length; i++) r[n[i]] = !0;
|
|
return t ? (i) => !!r[i.toLowerCase()] : (i) => !!r[i];
|
|
}
|
|
var gi =
|
|
"itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly";
|
|
var Vs = Tt(
|
|
gi +
|
|
",async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected",
|
|
);
|
|
var tn = Object.freeze({}),
|
|
qs = Object.freeze([]);
|
|
var xi = Object.prototype.hasOwnProperty,
|
|
Ee = (e, t) => xi.call(e, t),
|
|
q = Array.isArray,
|
|
ce = (e) => rn(e) === "[object Map]";
|
|
var yi = (e) => typeof e == "string",
|
|
qe = (e) => typeof e == "symbol",
|
|
ve = (e) => e !== null && typeof e == "object";
|
|
var bi = Object.prototype.toString,
|
|
rn = (e) => bi.call(e),
|
|
Mt = (e) => rn(e).slice(8, -1);
|
|
var Ue = (e) =>
|
|
yi(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e;
|
|
var We = (e) => {
|
|
let t = Object.create(null);
|
|
return (r) => t[r] || (t[r] = e(r));
|
|
},
|
|
wi = /-(\w)/g,
|
|
Us = We((e) => e.replace(wi, (t, r) => (r ? r.toUpperCase() : ""))),
|
|
Ei = /\B([A-Z])/g,
|
|
Ws = We((e) => e.replace(Ei, "-$1").toLowerCase()),
|
|
Nt = We((e) => e.charAt(0).toUpperCase() + e.slice(1)),
|
|
Gs = We((e) => (e ? `on${Nt(e)}` : "")),
|
|
Dt = (e, t) => e !== t && (e === e || t === t);
|
|
var kt = new WeakMap(),
|
|
Se = [],
|
|
j,
|
|
ee = Symbol("iterate"),
|
|
Pt = Symbol("Map key iterate");
|
|
function vi(e) {
|
|
return e && e._isEffect === !0;
|
|
}
|
|
function ln(e, t = tn) {
|
|
vi(e) && (e = e.raw);
|
|
let r = Ai(e, t);
|
|
return (t.lazy || r(), r);
|
|
}
|
|
function un(e) {
|
|
e.active &&
|
|
(fn(e), e.options.onStop && e.options.onStop(), (e.active = !1));
|
|
}
|
|
var Si = 0;
|
|
function Ai(e, t) {
|
|
let r = function () {
|
|
if (!r.active) return e();
|
|
if (!Se.includes(r)) {
|
|
fn(r);
|
|
try {
|
|
return (Ci(), Se.push(r), (j = r), e());
|
|
} finally {
|
|
(Se.pop(), dn(), (j = Se[Se.length - 1]));
|
|
}
|
|
}
|
|
};
|
|
return (
|
|
(r.id = Si++),
|
|
(r.allowRecurse = !!t.allowRecurse),
|
|
(r._isEffect = !0),
|
|
(r.active = !0),
|
|
(r.raw = e),
|
|
(r.deps = []),
|
|
(r.options = t),
|
|
r
|
|
);
|
|
}
|
|
function fn(e) {
|
|
let { deps: t } = e;
|
|
if (t.length) {
|
|
for (let r = 0; r < t.length; r++) t[r].delete(e);
|
|
t.length = 0;
|
|
}
|
|
}
|
|
var le = !0,
|
|
$t = [];
|
|
function Oi() {
|
|
($t.push(le), (le = !1));
|
|
}
|
|
function Ci() {
|
|
($t.push(le), (le = !0));
|
|
}
|
|
function dn() {
|
|
let e = $t.pop();
|
|
le = e === void 0 ? !0 : e;
|
|
}
|
|
function M(e, t, r) {
|
|
if (!le || j === void 0) return;
|
|
let n = kt.get(e);
|
|
n || kt.set(e, (n = new Map()));
|
|
let i = n.get(r);
|
|
(i || n.set(r, (i = new Set())),
|
|
i.has(j) ||
|
|
(i.add(j),
|
|
j.deps.push(i),
|
|
j.options.onTrack &&
|
|
j.options.onTrack({
|
|
effect: j,
|
|
target: e,
|
|
type: t,
|
|
key: r,
|
|
})));
|
|
}
|
|
function W(e, t, r, n, i, o) {
|
|
let s = kt.get(e);
|
|
if (!s) return;
|
|
let a = new Set(),
|
|
c = (u) => {
|
|
u &&
|
|
u.forEach((p) => {
|
|
(p !== j || p.allowRecurse) && a.add(p);
|
|
});
|
|
};
|
|
if (t === "clear") s.forEach(c);
|
|
else if (r === "length" && q(e))
|
|
s.forEach((u, p) => {
|
|
(p === "length" || p >= n) && c(u);
|
|
});
|
|
else
|
|
switch ((r !== void 0 && c(s.get(r)), t)) {
|
|
case "add":
|
|
q(e)
|
|
? Ue(r) && c(s.get("length"))
|
|
: (c(s.get(ee)), ce(e) && c(s.get(Pt)));
|
|
break;
|
|
case "delete":
|
|
q(e) || (c(s.get(ee)), ce(e) && c(s.get(Pt)));
|
|
break;
|
|
case "set":
|
|
ce(e) && c(s.get(ee));
|
|
break;
|
|
}
|
|
let l = (u) => {
|
|
(u.options.onTrigger &&
|
|
u.options.onTrigger({
|
|
effect: u,
|
|
target: e,
|
|
key: r,
|
|
type: t,
|
|
newValue: n,
|
|
oldValue: i,
|
|
oldTarget: o,
|
|
}),
|
|
u.options.scheduler ? u.options.scheduler(u) : u());
|
|
};
|
|
a.forEach(l);
|
|
}
|
|
var Ri = Tt("__proto__,__v_isRef,__isVue"),
|
|
pn = new Set(
|
|
Object.getOwnPropertyNames(Symbol)
|
|
.map((e) => Symbol[e])
|
|
.filter(qe),
|
|
),
|
|
Ti = mn();
|
|
var Mi = mn(!0);
|
|
var nn = Ni();
|
|
function Ni() {
|
|
let e = {};
|
|
return (
|
|
["includes", "indexOf", "lastIndexOf"].forEach((t) => {
|
|
e[t] = function (...r) {
|
|
let n = _(this);
|
|
for (let o = 0, s = this.length; o < s; o++)
|
|
M(n, "get", o + "");
|
|
let i = n[t](...r);
|
|
return i === -1 || i === !1 ? n[t](...r.map(_)) : i;
|
|
};
|
|
}),
|
|
["push", "pop", "shift", "unshift", "splice"].forEach((t) => {
|
|
e[t] = function (...r) {
|
|
Oi();
|
|
let n = _(this)[t].apply(this, r);
|
|
return (dn(), n);
|
|
};
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function mn(e = !1, t = !1) {
|
|
return function (n, i, o) {
|
|
if (i === "__v_isReactive") return !e;
|
|
if (i === "__v_isReadonly") return e;
|
|
if (
|
|
i === "__v_raw" &&
|
|
o === (e ? (t ? Wi : xn) : t ? Ui : gn).get(n)
|
|
)
|
|
return n;
|
|
let s = q(n);
|
|
if (!e && s && Ee(nn, i)) return Reflect.get(nn, i, o);
|
|
let a = Reflect.get(n, i, o);
|
|
return (qe(i) ? pn.has(i) : Ri(i)) || (e || M(n, "get", i), t)
|
|
? a
|
|
: It(a)
|
|
? !s || !Ue(i)
|
|
? a.value
|
|
: a
|
|
: ve(a)
|
|
? e
|
|
? yn(a)
|
|
: et(a)
|
|
: a;
|
|
};
|
|
}
|
|
var Di = ki();
|
|
function ki(e = !1) {
|
|
return function (r, n, i, o) {
|
|
let s = r[n];
|
|
if (!e && ((i = _(i)), (s = _(s)), !q(r) && It(s) && !It(i)))
|
|
return ((s.value = i), !0);
|
|
let a = q(r) && Ue(n) ? Number(n) < r.length : Ee(r, n),
|
|
c = Reflect.set(r, n, i, o);
|
|
return (
|
|
r === _(o) &&
|
|
(a ? Dt(i, s) && W(r, "set", n, i, s) : W(r, "add", n, i)),
|
|
c
|
|
);
|
|
};
|
|
}
|
|
function Pi(e, t) {
|
|
let r = Ee(e, t),
|
|
n = e[t],
|
|
i = Reflect.deleteProperty(e, t);
|
|
return (i && r && W(e, "delete", t, void 0, n), i);
|
|
}
|
|
function Ii(e, t) {
|
|
let r = Reflect.has(e, t);
|
|
return ((!qe(t) || !pn.has(t)) && M(e, "has", t), r);
|
|
}
|
|
function $i(e) {
|
|
return (M(e, "iterate", q(e) ? "length" : ee), Reflect.ownKeys(e));
|
|
}
|
|
var Li = { get: Ti, set: Di, deleteProperty: Pi, has: Ii, ownKeys: $i },
|
|
ji = {
|
|
get: Mi,
|
|
set(e, t) {
|
|
return (
|
|
console.warn(
|
|
`Set operation on key "${String(t)}" failed: target is readonly.`,
|
|
e,
|
|
),
|
|
!0
|
|
);
|
|
},
|
|
deleteProperty(e, t) {
|
|
return (
|
|
console.warn(
|
|
`Delete operation on key "${String(t)}" failed: target is readonly.`,
|
|
e,
|
|
),
|
|
!0
|
|
);
|
|
},
|
|
};
|
|
var Lt = (e) => (ve(e) ? et(e) : e),
|
|
jt = (e) => (ve(e) ? yn(e) : e),
|
|
Ft = (e) => e,
|
|
Qe = (e) => Reflect.getPrototypeOf(e);
|
|
function Ge(e, t, r = !1, n = !1) {
|
|
e = e.__v_raw;
|
|
let i = _(e),
|
|
o = _(t);
|
|
(t !== o && !r && M(i, "get", t), !r && M(i, "get", o));
|
|
let { has: s } = Qe(i),
|
|
a = n ? Ft : r ? jt : Lt;
|
|
if (s.call(i, t)) return a(e.get(t));
|
|
if (s.call(i, o)) return a(e.get(o));
|
|
e !== i && e.get(t);
|
|
}
|
|
function Je(e, t = !1) {
|
|
let r = this.__v_raw,
|
|
n = _(r),
|
|
i = _(e);
|
|
return (
|
|
e !== i && !t && M(n, "has", e),
|
|
!t && M(n, "has", i),
|
|
e === i ? r.has(e) : r.has(e) || r.has(i)
|
|
);
|
|
}
|
|
function Ye(e, t = !1) {
|
|
return (
|
|
(e = e.__v_raw),
|
|
!t && M(_(e), "iterate", ee),
|
|
Reflect.get(e, "size", e)
|
|
);
|
|
}
|
|
function on(e) {
|
|
e = _(e);
|
|
let t = _(this);
|
|
return (Qe(t).has.call(t, e) || (t.add(e), W(t, "add", e, e)), this);
|
|
}
|
|
function sn(e, t) {
|
|
t = _(t);
|
|
let r = _(this),
|
|
{ has: n, get: i } = Qe(r),
|
|
o = n.call(r, e);
|
|
o ? _n(r, n, e) : ((e = _(e)), (o = n.call(r, e)));
|
|
let s = i.call(r, e);
|
|
return (
|
|
r.set(e, t),
|
|
o ? Dt(t, s) && W(r, "set", e, t, s) : W(r, "add", e, t),
|
|
this
|
|
);
|
|
}
|
|
function an(e) {
|
|
let t = _(this),
|
|
{ has: r, get: n } = Qe(t),
|
|
i = r.call(t, e);
|
|
i ? _n(t, r, e) : ((e = _(e)), (i = r.call(t, e)));
|
|
let o = n ? n.call(t, e) : void 0,
|
|
s = t.delete(e);
|
|
return (i && W(t, "delete", e, void 0, o), s);
|
|
}
|
|
function cn() {
|
|
let e = _(this),
|
|
t = e.size !== 0,
|
|
r = ce(e) ? new Map(e) : new Set(e),
|
|
n = e.clear();
|
|
return (t && W(e, "clear", void 0, void 0, r), n);
|
|
}
|
|
function Xe(e, t) {
|
|
return function (n, i) {
|
|
let o = this,
|
|
s = o.__v_raw,
|
|
a = _(s),
|
|
c = t ? Ft : e ? jt : Lt;
|
|
return (
|
|
!e && M(a, "iterate", ee),
|
|
s.forEach((l, u) => n.call(i, c(l), c(u), o))
|
|
);
|
|
};
|
|
}
|
|
function Ze(e, t, r) {
|
|
return function (...n) {
|
|
let i = this.__v_raw,
|
|
o = _(i),
|
|
s = ce(o),
|
|
a = e === "entries" || (e === Symbol.iterator && s),
|
|
c = e === "keys" && s,
|
|
l = i[e](...n),
|
|
u = r ? Ft : t ? jt : Lt;
|
|
return (
|
|
!t && M(o, "iterate", c ? Pt : ee),
|
|
{
|
|
next() {
|
|
let { value: p, done: h } = l.next();
|
|
return h
|
|
? { value: p, done: h }
|
|
: { value: a ? [u(p[0]), u(p[1])] : u(p), done: h };
|
|
},
|
|
[Symbol.iterator]() {
|
|
return this;
|
|
},
|
|
}
|
|
);
|
|
};
|
|
}
|
|
function U(e) {
|
|
return function (...t) {
|
|
{
|
|
let r = t[0] ? `on key "${t[0]}" ` : "";
|
|
console.warn(
|
|
`${Nt(e)} operation ${r}failed: target is readonly.`,
|
|
_(this),
|
|
);
|
|
}
|
|
return e === "delete" ? !1 : this;
|
|
};
|
|
}
|
|
function Fi() {
|
|
let e = {
|
|
get(o) {
|
|
return Ge(this, o);
|
|
},
|
|
get size() {
|
|
return Ye(this);
|
|
},
|
|
has: Je,
|
|
add: on,
|
|
set: sn,
|
|
delete: an,
|
|
clear: cn,
|
|
forEach: Xe(!1, !1),
|
|
},
|
|
t = {
|
|
get(o) {
|
|
return Ge(this, o, !1, !0);
|
|
},
|
|
get size() {
|
|
return Ye(this);
|
|
},
|
|
has: Je,
|
|
add: on,
|
|
set: sn,
|
|
delete: an,
|
|
clear: cn,
|
|
forEach: Xe(!1, !0),
|
|
},
|
|
r = {
|
|
get(o) {
|
|
return Ge(this, o, !0);
|
|
},
|
|
get size() {
|
|
return Ye(this, !0);
|
|
},
|
|
has(o) {
|
|
return Je.call(this, o, !0);
|
|
},
|
|
add: U("add"),
|
|
set: U("set"),
|
|
delete: U("delete"),
|
|
clear: U("clear"),
|
|
forEach: Xe(!0, !1),
|
|
},
|
|
n = {
|
|
get(o) {
|
|
return Ge(this, o, !0, !0);
|
|
},
|
|
get size() {
|
|
return Ye(this, !0);
|
|
},
|
|
has(o) {
|
|
return Je.call(this, o, !0);
|
|
},
|
|
add: U("add"),
|
|
set: U("set"),
|
|
delete: U("delete"),
|
|
clear: U("clear"),
|
|
forEach: Xe(!0, !0),
|
|
};
|
|
return (
|
|
["keys", "values", "entries", Symbol.iterator].forEach((o) => {
|
|
((e[o] = Ze(o, !1, !1)),
|
|
(r[o] = Ze(o, !0, !1)),
|
|
(t[o] = Ze(o, !1, !0)),
|
|
(n[o] = Ze(o, !0, !0)));
|
|
}),
|
|
[e, r, t, n]
|
|
);
|
|
}
|
|
var [Bi, zi, Hi, Ki] = Fi();
|
|
function hn(e, t) {
|
|
let r = t ? (e ? Ki : Hi) : e ? zi : Bi;
|
|
return (n, i, o) =>
|
|
i === "__v_isReactive"
|
|
? !e
|
|
: i === "__v_isReadonly"
|
|
? e
|
|
: i === "__v_raw"
|
|
? n
|
|
: Reflect.get(Ee(r, i) && i in n ? r : n, i, o);
|
|
}
|
|
var Vi = { get: hn(!1, !1) };
|
|
var qi = { get: hn(!0, !1) };
|
|
function _n(e, t, r) {
|
|
let n = _(r);
|
|
if (n !== r && t.call(e, n)) {
|
|
let i = Mt(e);
|
|
console.warn(
|
|
`Reactive ${i} contains both the raw and reactive versions of the same object${i === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`,
|
|
);
|
|
}
|
|
}
|
|
var gn = new WeakMap(),
|
|
Ui = new WeakMap(),
|
|
xn = new WeakMap(),
|
|
Wi = new WeakMap();
|
|
function Gi(e) {
|
|
switch (e) {
|
|
case "Object":
|
|
case "Array":
|
|
return 1;
|
|
case "Map":
|
|
case "Set":
|
|
case "WeakMap":
|
|
case "WeakSet":
|
|
return 2;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
function Ji(e) {
|
|
return e.__v_skip || !Object.isExtensible(e) ? 0 : Gi(Mt(e));
|
|
}
|
|
function et(e) {
|
|
return e && e.__v_isReadonly ? e : bn(e, !1, Li, Vi, gn);
|
|
}
|
|
function yn(e) {
|
|
return bn(e, !0, ji, qi, xn);
|
|
}
|
|
function bn(e, t, r, n, i) {
|
|
if (!ve(e))
|
|
return (
|
|
console.warn(`value cannot be made reactive: ${String(e)}`),
|
|
e
|
|
);
|
|
if (e.__v_raw && !(t && e.__v_isReactive)) return e;
|
|
let o = i.get(e);
|
|
if (o) return o;
|
|
let s = Ji(e);
|
|
if (s === 0) return e;
|
|
let a = new Proxy(e, s === 2 ? n : r);
|
|
return (i.set(e, a), a);
|
|
}
|
|
function _(e) {
|
|
return (e && _(e.__v_raw)) || e;
|
|
}
|
|
function It(e) {
|
|
return Boolean(e && e.__v_isRef === !0);
|
|
}
|
|
y("nextTick", () => ae);
|
|
y("dispatch", (e) => Y.bind(Y, e));
|
|
y("watch", (e, { evaluateLater: t, cleanup: r }) => (n, i) => {
|
|
let o = t(n),
|
|
a = Oe(() => {
|
|
let c;
|
|
return (o((l) => (c = l)), c);
|
|
}, i);
|
|
r(a);
|
|
});
|
|
y("store", Gr);
|
|
y("data", (e) => Me(e));
|
|
y("root", (e) => X(e));
|
|
y(
|
|
"refs",
|
|
(e) => (
|
|
e._x_refs_proxy || (e._x_refs_proxy = k(Yi(e))),
|
|
e._x_refs_proxy
|
|
),
|
|
);
|
|
function Yi(e) {
|
|
let t = [];
|
|
return (
|
|
I(e, (r) => {
|
|
r._x_refs && t.push(r._x_refs);
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
var Bt = {};
|
|
function zt(e) {
|
|
return (Bt[e] || (Bt[e] = 0), ++Bt[e]);
|
|
}
|
|
function wn(e, t) {
|
|
return I(e, (r) => {
|
|
if (r._x_ids && r._x_ids[t]) return !0;
|
|
});
|
|
}
|
|
function En(e, t) {
|
|
(e._x_ids || (e._x_ids = {}), e._x_ids[t] || (e._x_ids[t] = zt(t)));
|
|
}
|
|
y("id", (e, { cleanup: t }) => (r, n = null) => {
|
|
let i = `${r}${n ? `-${n}` : ""}`;
|
|
return Xi(e, i, t, () => {
|
|
let o = wn(e, r),
|
|
s = o ? o._x_ids[r] : zt(r);
|
|
return n ? `${r}-${s}-${n}` : `${r}-${s}`;
|
|
});
|
|
});
|
|
V((e, t) => {
|
|
e._x_id && (t._x_id = e._x_id);
|
|
});
|
|
function Xi(e, t, r, n) {
|
|
if ((e._x_id || (e._x_id = {}), e._x_id[t])) return e._x_id[t];
|
|
let i = n();
|
|
return (
|
|
(e._x_id[t] = i),
|
|
r(() => {
|
|
delete e._x_id[t];
|
|
}),
|
|
i
|
|
);
|
|
}
|
|
y("el", (e) => e);
|
|
vn("Focus", "focus", "focus");
|
|
vn("Persist", "persist", "persist");
|
|
function vn(e, t, r) {
|
|
y(t, (n) =>
|
|
E(
|
|
`You can't use [$${t}] without first installing the "${e}" plugin here: https://alpinejs.dev/plugins/${r}`,
|
|
n,
|
|
),
|
|
);
|
|
}
|
|
d(
|
|
"modelable",
|
|
(e, { expression: t }, { effect: r, evaluateLater: n, cleanup: i }) => {
|
|
let o = n(t),
|
|
s = () => {
|
|
let u;
|
|
return (o((p) => (u = p)), u);
|
|
},
|
|
a = n(`${t} = __placeholder`),
|
|
c = (u) => a(() => {}, { scope: { __placeholder: u } }),
|
|
l = s();
|
|
(c(l),
|
|
queueMicrotask(() => {
|
|
if (!e._x_model) return;
|
|
e._x_removeModelListeners.default();
|
|
let u = e._x_model.get,
|
|
p = e._x_model.set,
|
|
h = Ve(
|
|
{
|
|
get() {
|
|
return u();
|
|
},
|
|
set(w) {
|
|
p(w);
|
|
},
|
|
},
|
|
{
|
|
get() {
|
|
return s();
|
|
},
|
|
set(w) {
|
|
c(w);
|
|
},
|
|
},
|
|
);
|
|
i(h);
|
|
}));
|
|
},
|
|
);
|
|
d("teleport", (e, { modifiers: t, expression: r }, { cleanup: n }) => {
|
|
e.tagName.toLowerCase() !== "template" &&
|
|
E("x-teleport can only be used on a <template> tag", e);
|
|
let i = Sn(r),
|
|
o = e.content.cloneNode(!0).firstElementChild;
|
|
((e._x_teleport = o),
|
|
(o._x_teleportBack = e),
|
|
e.setAttribute("data-teleport-template", !0),
|
|
o.setAttribute("data-teleport-target", !0),
|
|
e._x_forwardEvents &&
|
|
e._x_forwardEvents.forEach((a) => {
|
|
o.addEventListener(a, (c) => {
|
|
(c.stopPropagation(),
|
|
e.dispatchEvent(new c.constructor(c.type, c)));
|
|
});
|
|
}),
|
|
D(o, {}, e));
|
|
let s = (a, c, l) => {
|
|
l.includes("prepend")
|
|
? c.parentNode.insertBefore(a, c)
|
|
: l.includes("append")
|
|
? c.parentNode.insertBefore(a, c.nextSibling)
|
|
: c.appendChild(a);
|
|
};
|
|
(m(() => {
|
|
(s(o, i, t),
|
|
A(() => {
|
|
S(o);
|
|
})());
|
|
}),
|
|
(e._x_teleportPutBack = () => {
|
|
let a = Sn(r);
|
|
m(() => {
|
|
s(e._x_teleport, a, t);
|
|
});
|
|
}),
|
|
n(() =>
|
|
m(() => {
|
|
(o.remove(), $(o));
|
|
}),
|
|
));
|
|
});
|
|
var Zi = document.createElement("div");
|
|
function Sn(e) {
|
|
let t = A(
|
|
() => document.querySelector(e),
|
|
() => Zi,
|
|
)();
|
|
return (
|
|
t || E(`Cannot find x-teleport element for selector: "${e}"`),
|
|
t
|
|
);
|
|
}
|
|
var An = () => {};
|
|
An.inline = (e, { modifiers: t }, { cleanup: r }) => {
|
|
(t.includes("self") ? (e._x_ignoreSelf = !0) : (e._x_ignore = !0),
|
|
r(() => {
|
|
t.includes("self")
|
|
? delete e._x_ignoreSelf
|
|
: delete e._x_ignore;
|
|
}));
|
|
};
|
|
d("ignore", An);
|
|
d(
|
|
"effect",
|
|
A((e, { expression: t }, { effect: r }) => {
|
|
r(x(e, t));
|
|
}),
|
|
);
|
|
function ue(e, t, r, n) {
|
|
let i = e,
|
|
o = (c) => n(c),
|
|
s = {},
|
|
a = (c, l) => (u) => l(c, u);
|
|
if (
|
|
(r.includes("dot") && (t = Qi(t)),
|
|
r.includes("camel") && (t = eo(t)),
|
|
r.includes("passive") && (s.passive = !0),
|
|
r.includes("capture") && (s.capture = !0),
|
|
r.includes("window") && (i = window),
|
|
r.includes("document") && (i = document),
|
|
r.includes("debounce"))
|
|
) {
|
|
let c = r[r.indexOf("debounce") + 1] || "invalid-wait",
|
|
l = tt(c.split("ms")[0]) ? Number(c.split("ms")[0]) : 250;
|
|
o = He(o, l);
|
|
}
|
|
if (r.includes("throttle")) {
|
|
let c = r[r.indexOf("throttle") + 1] || "invalid-wait",
|
|
l = tt(c.split("ms")[0]) ? Number(c.split("ms")[0]) : 250;
|
|
o = Ke(o, l);
|
|
}
|
|
return (
|
|
r.includes("prevent") &&
|
|
(o = a(o, (c, l) => {
|
|
(l.preventDefault(), c(l));
|
|
})),
|
|
r.includes("stop") &&
|
|
(o = a(o, (c, l) => {
|
|
(l.stopPropagation(), c(l));
|
|
})),
|
|
r.includes("once") &&
|
|
(o = a(o, (c, l) => {
|
|
(c(l), i.removeEventListener(t, o, s));
|
|
})),
|
|
(r.includes("away") || r.includes("outside")) &&
|
|
((i = document),
|
|
(o = a(o, (c, l) => {
|
|
e.contains(l.target) ||
|
|
(l.target.isConnected !== !1 &&
|
|
((e.offsetWidth < 1 && e.offsetHeight < 1) ||
|
|
(e._x_isShown !== !1 && c(l))));
|
|
}))),
|
|
r.includes("self") &&
|
|
(o = a(o, (c, l) => {
|
|
l.target === e && c(l);
|
|
})),
|
|
(ro(t) || Cn(t)) &&
|
|
(o = a(o, (c, l) => {
|
|
no(l, r) || c(l);
|
|
})),
|
|
i.addEventListener(t, o, s),
|
|
() => {
|
|
i.removeEventListener(t, o, s);
|
|
}
|
|
);
|
|
}
|
|
function Qi(e) {
|
|
return e.replace(/-/g, ".");
|
|
}
|
|
function eo(e) {
|
|
return e.toLowerCase().replace(/-(\w)/g, (t, r) => r.toUpperCase());
|
|
}
|
|
function tt(e) {
|
|
return !Array.isArray(e) && !isNaN(e);
|
|
}
|
|
function to(e) {
|
|
return [" ", "_"].includes(e)
|
|
? e
|
|
: e
|
|
.replace(/([a-z])([A-Z])/g, "$1-$2")
|
|
.replace(/[_\s]/, "-")
|
|
.toLowerCase();
|
|
}
|
|
function ro(e) {
|
|
return ["keydown", "keyup"].includes(e);
|
|
}
|
|
function Cn(e) {
|
|
return ["contextmenu", "click", "mouse"].some((t) => e.includes(t));
|
|
}
|
|
function no(e, t) {
|
|
let r = t.filter(
|
|
(o) =>
|
|
![
|
|
"window",
|
|
"document",
|
|
"prevent",
|
|
"stop",
|
|
"once",
|
|
"capture",
|
|
"self",
|
|
"away",
|
|
"outside",
|
|
"passive",
|
|
"preserve-scroll",
|
|
].includes(o),
|
|
);
|
|
if (r.includes("debounce")) {
|
|
let o = r.indexOf("debounce");
|
|
r.splice(
|
|
o,
|
|
tt((r[o + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1,
|
|
);
|
|
}
|
|
if (r.includes("throttle")) {
|
|
let o = r.indexOf("throttle");
|
|
r.splice(
|
|
o,
|
|
tt((r[o + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1,
|
|
);
|
|
}
|
|
if (r.length === 0 || (r.length === 1 && On(e.key).includes(r[0])))
|
|
return !1;
|
|
let i = ["ctrl", "shift", "alt", "meta", "cmd", "super"].filter((o) =>
|
|
r.includes(o),
|
|
);
|
|
return (
|
|
(r = r.filter((o) => !i.includes(o))),
|
|
!(
|
|
i.length > 0 &&
|
|
i.filter(
|
|
(s) => (
|
|
(s === "cmd" || s === "super") && (s = "meta"),
|
|
e[`${s}Key`]
|
|
),
|
|
).length === i.length &&
|
|
(Cn(e.type) || On(e.key).includes(r[0]))
|
|
)
|
|
);
|
|
}
|
|
function On(e) {
|
|
if (!e) return [];
|
|
e = to(e);
|
|
let t = {
|
|
ctrl: "control",
|
|
slash: "/",
|
|
space: " ",
|
|
spacebar: " ",
|
|
cmd: "meta",
|
|
esc: "escape",
|
|
up: "arrow-up",
|
|
down: "arrow-down",
|
|
left: "arrow-left",
|
|
right: "arrow-right",
|
|
period: ".",
|
|
comma: ",",
|
|
equal: "=",
|
|
minus: "-",
|
|
underscore: "_",
|
|
};
|
|
return (
|
|
(t[e] = e),
|
|
Object.keys(t)
|
|
.map((r) => {
|
|
if (t[r] === e) return r;
|
|
})
|
|
.filter((r) => r)
|
|
);
|
|
}
|
|
d(
|
|
"model",
|
|
(e, { modifiers: t, expression: r }, { effect: n, cleanup: i }) => {
|
|
let o = e;
|
|
t.includes("parent") && (o = e.parentNode);
|
|
let s = x(o, r),
|
|
a;
|
|
typeof r == "string"
|
|
? (a = x(o, `${r} = __placeholder`))
|
|
: typeof r == "function" && typeof r() == "string"
|
|
? (a = x(o, `${r()} = __placeholder`))
|
|
: (a = () => {});
|
|
let c = () => {
|
|
let h;
|
|
return (s((w) => (h = w)), Rn(h) ? h.get() : h);
|
|
},
|
|
l = (h) => {
|
|
let w;
|
|
(s((H) => (w = H)),
|
|
Rn(w)
|
|
? w.set(h)
|
|
: a(() => {}, { scope: { __placeholder: h } }));
|
|
};
|
|
typeof r == "string" &&
|
|
e.type === "radio" &&
|
|
m(() => {
|
|
e.hasAttribute("name") || e.setAttribute("name", r);
|
|
});
|
|
let u =
|
|
e.tagName.toLowerCase() === "select" ||
|
|
["checkbox", "radio"].includes(e.type) ||
|
|
t.includes("lazy")
|
|
? "change"
|
|
: "input",
|
|
p = L
|
|
? () => {}
|
|
: ue(e, u, t, (h) => {
|
|
l(Ht(e, t, h, c()));
|
|
});
|
|
if (
|
|
(t.includes("fill") &&
|
|
([void 0, null, ""].includes(c()) ||
|
|
(ze(e) && Array.isArray(c())) ||
|
|
(e.tagName.toLowerCase() === "select" && e.multiple)) &&
|
|
l(Ht(e, t, { target: e }, c())),
|
|
e._x_removeModelListeners || (e._x_removeModelListeners = {}),
|
|
(e._x_removeModelListeners.default = p),
|
|
i(() => e._x_removeModelListeners.default()),
|
|
e.form)
|
|
) {
|
|
let h = ue(e.form, "reset", [], (w) => {
|
|
ae(
|
|
() =>
|
|
e._x_model &&
|
|
e._x_model.set(Ht(e, t, { target: e }, c())),
|
|
);
|
|
});
|
|
i(() => h());
|
|
}
|
|
((e._x_model = {
|
|
get() {
|
|
return c();
|
|
},
|
|
set(h) {
|
|
l(h);
|
|
},
|
|
}),
|
|
(e._x_forceModelUpdate = (h) => {
|
|
(h === void 0 &&
|
|
typeof r == "string" &&
|
|
r.match(/\./) &&
|
|
(h = ""),
|
|
(window.fromModel = !0),
|
|
m(() => be(e, "value", h)),
|
|
delete window.fromModel);
|
|
}),
|
|
n(() => {
|
|
let h = c();
|
|
(t.includes("unintrusive") &&
|
|
document.activeElement.isSameNode(e)) ||
|
|
e._x_forceModelUpdate(h);
|
|
}));
|
|
},
|
|
);
|
|
function Ht(e, t, r, n) {
|
|
return m(() => {
|
|
if (r instanceof CustomEvent && r.detail !== void 0)
|
|
return r.detail !== null && r.detail !== void 0
|
|
? r.detail
|
|
: r.target.value;
|
|
if (ze(e))
|
|
if (Array.isArray(n)) {
|
|
let i = null;
|
|
return (
|
|
t.includes("number")
|
|
? (i = Kt(r.target.value))
|
|
: t.includes("boolean")
|
|
? (i = we(r.target.value))
|
|
: (i = r.target.value),
|
|
r.target.checked
|
|
? n.includes(i)
|
|
? n
|
|
: n.concat([i])
|
|
: n.filter((o) => !io(o, i))
|
|
);
|
|
} else return r.target.checked;
|
|
else {
|
|
if (e.tagName.toLowerCase() === "select" && e.multiple)
|
|
return t.includes("number")
|
|
? Array.from(r.target.selectedOptions).map((i) => {
|
|
let o = i.value || i.text;
|
|
return Kt(o);
|
|
})
|
|
: t.includes("boolean")
|
|
? Array.from(r.target.selectedOptions).map((i) => {
|
|
let o = i.value || i.text;
|
|
return we(o);
|
|
})
|
|
: Array.from(r.target.selectedOptions).map(
|
|
(i) => i.value || i.text,
|
|
);
|
|
{
|
|
let i;
|
|
return (
|
|
Ot(e)
|
|
? r.target.checked
|
|
? (i = r.target.value)
|
|
: (i = n)
|
|
: (i = r.target.value),
|
|
t.includes("number")
|
|
? Kt(i)
|
|
: t.includes("boolean")
|
|
? we(i)
|
|
: t.includes("trim")
|
|
? i.trim()
|
|
: i
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function Kt(e) {
|
|
let t = e ? parseFloat(e) : null;
|
|
return oo(t) ? t : e;
|
|
}
|
|
function io(e, t) {
|
|
return e == t;
|
|
}
|
|
function oo(e) {
|
|
return !Array.isArray(e) && !isNaN(e);
|
|
}
|
|
function Rn(e) {
|
|
return (
|
|
e !== null &&
|
|
typeof e == "object" &&
|
|
typeof e.get == "function" &&
|
|
typeof e.set == "function"
|
|
);
|
|
}
|
|
d("cloak", (e) =>
|
|
queueMicrotask(() => m(() => e.removeAttribute(C("cloak")))),
|
|
);
|
|
Le(() => `[${C("init")}]`);
|
|
d(
|
|
"init",
|
|
A((e, { expression: t }, { evaluate: r }) =>
|
|
typeof t == "string" ? !!t.trim() && r(t, {}, !1) : r(t, {}, !1),
|
|
),
|
|
);
|
|
d("text", (e, { expression: t }, { effect: r, evaluateLater: n }) => {
|
|
let i = n(t);
|
|
r(() => {
|
|
i((o) => {
|
|
m(() => {
|
|
e.textContent = o;
|
|
});
|
|
});
|
|
});
|
|
});
|
|
d("html", (e, { expression: t }, { effect: r, evaluateLater: n }) => {
|
|
let i = n(t);
|
|
r(() => {
|
|
i((o) => {
|
|
m(() => {
|
|
((e.innerHTML = o),
|
|
(e._x_ignoreSelf = !0),
|
|
S(e),
|
|
delete e._x_ignoreSelf);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
se(Pe(":", Ie(C("bind:"))));
|
|
var Tn = (
|
|
e,
|
|
{ value: t, modifiers: r, expression: n, original: i },
|
|
{ effect: o, cleanup: s },
|
|
) => {
|
|
if (!t) {
|
|
let c = {};
|
|
(Xr(c),
|
|
x(e, n)(
|
|
(u) => {
|
|
Rt(e, u, i);
|
|
},
|
|
{ scope: c },
|
|
));
|
|
return;
|
|
}
|
|
if (t === "key") return so(e, n);
|
|
if (
|
|
e._x_inlineBindings &&
|
|
e._x_inlineBindings[t] &&
|
|
e._x_inlineBindings[t].extract
|
|
)
|
|
return;
|
|
let a = x(e, n);
|
|
(o(() =>
|
|
a((c) => {
|
|
(c === void 0 &&
|
|
typeof n == "string" &&
|
|
n.match(/\./) &&
|
|
(c = ""),
|
|
m(() => be(e, t, c, r)));
|
|
}),
|
|
),
|
|
s(() => {
|
|
(e._x_undoAddedClasses && e._x_undoAddedClasses(),
|
|
e._x_undoAddedStyles && e._x_undoAddedStyles());
|
|
}));
|
|
};
|
|
Tn.inline = (e, { value: t, modifiers: r, expression: n }) => {
|
|
t &&
|
|
(e._x_inlineBindings || (e._x_inlineBindings = {}),
|
|
(e._x_inlineBindings[t] = { expression: n, extract: !1 }));
|
|
};
|
|
d("bind", Tn);
|
|
function so(e, t) {
|
|
e._x_keyExpression = t;
|
|
}
|
|
$e(() => `[${C("data")}]`);
|
|
d("data", (e, { expression: t }, { cleanup: r }) => {
|
|
if (ao(e)) return;
|
|
t = t === "" ? "{}" : t;
|
|
let n = {};
|
|
K(n, e);
|
|
let i = {};
|
|
en(i, n);
|
|
let o = T(e, t, { scope: i });
|
|
((o === void 0 || o === !0) && (o = {}), K(o, e));
|
|
let s = R(o);
|
|
ne(s);
|
|
let a = D(e, s);
|
|
(s.init && T(e, s.init),
|
|
r(() => {
|
|
(s.destroy && T(e, s.destroy), a());
|
|
}));
|
|
});
|
|
V((e, t) => {
|
|
e._x_dataStack &&
|
|
((t._x_dataStack = e._x_dataStack),
|
|
t.setAttribute("data-has-alpine-state", !0));
|
|
});
|
|
function ao(e) {
|
|
return L ? (Be ? !0 : e.hasAttribute("data-has-alpine-state")) : !1;
|
|
}
|
|
d("show", (e, { modifiers: t, expression: r }, { effect: n }) => {
|
|
let i = x(e, r);
|
|
(e._x_doHide ||
|
|
(e._x_doHide = () => {
|
|
m(() => {
|
|
e.style.setProperty(
|
|
"display",
|
|
"none",
|
|
t.includes("important") ? "important" : void 0,
|
|
);
|
|
});
|
|
}),
|
|
e._x_doShow ||
|
|
(e._x_doShow = () => {
|
|
m(() => {
|
|
e.style.length === 1 && e.style.display === "none"
|
|
? e.removeAttribute("style")
|
|
: e.style.removeProperty("display");
|
|
});
|
|
}));
|
|
let o = () => {
|
|
(e._x_doHide(), (e._x_isShown = !1));
|
|
},
|
|
s = () => {
|
|
(e._x_doShow(), (e._x_isShown = !0));
|
|
},
|
|
a = () => setTimeout(s),
|
|
c = xe(
|
|
(p) => (p ? s() : o()),
|
|
(p) => {
|
|
typeof e._x_toggleAndCascadeWithTransitions == "function"
|
|
? e._x_toggleAndCascadeWithTransitions(e, p, s, o)
|
|
: p
|
|
? a()
|
|
: o();
|
|
},
|
|
),
|
|
l,
|
|
u = !0;
|
|
n(() =>
|
|
i((p) => {
|
|
(!u && p === l) ||
|
|
(t.includes("immediate") && (p ? a() : o()),
|
|
c(p),
|
|
(l = p),
|
|
(u = !1));
|
|
}),
|
|
);
|
|
});
|
|
d("for", (e, { expression: t }, { effect: r, cleanup: n }) => {
|
|
let i = lo(t),
|
|
o = x(e, i.items),
|
|
s = x(e, e._x_keyExpression || "index");
|
|
((e._x_prevKeys = []),
|
|
(e._x_lookup = {}),
|
|
r(() => co(e, i, o, s)),
|
|
n(() => {
|
|
(Object.values(e._x_lookup).forEach((a) =>
|
|
m(() => {
|
|
($(a), a.remove());
|
|
}),
|
|
),
|
|
delete e._x_prevKeys,
|
|
delete e._x_lookup);
|
|
}));
|
|
});
|
|
function co(e, t, r, n) {
|
|
let i = (s) => typeof s == "object" && !Array.isArray(s),
|
|
o = e;
|
|
r((s) => {
|
|
(uo(s) && s >= 0 && (s = Array.from(Array(s).keys(), (f) => f + 1)),
|
|
s === void 0 && (s = []));
|
|
let a = e._x_lookup,
|
|
c = e._x_prevKeys,
|
|
l = [],
|
|
u = [];
|
|
if (i(s))
|
|
s = Object.entries(s).map(([f, g]) => {
|
|
let b = Mn(t, g, f, s);
|
|
(n(
|
|
(v) => {
|
|
(u.includes(v) && E("Duplicate key on x-for", e),
|
|
u.push(v));
|
|
},
|
|
{ scope: { index: f, ...b } },
|
|
),
|
|
l.push(b));
|
|
});
|
|
else
|
|
for (let f = 0; f < s.length; f++) {
|
|
let g = Mn(t, s[f], f, s);
|
|
(n(
|
|
(b) => {
|
|
(u.includes(b) && E("Duplicate key on x-for", e),
|
|
u.push(b));
|
|
},
|
|
{ scope: { index: f, ...g } },
|
|
),
|
|
l.push(g));
|
|
}
|
|
let p = [],
|
|
h = [],
|
|
w = [],
|
|
H = [];
|
|
for (let f = 0; f < c.length; f++) {
|
|
let g = c[f];
|
|
u.indexOf(g) === -1 && w.push(g);
|
|
}
|
|
c = c.filter((f) => !w.includes(f));
|
|
let Ae = "template";
|
|
for (let f = 0; f < u.length; f++) {
|
|
let g = u[f],
|
|
b = c.indexOf(g);
|
|
if (b === -1) (c.splice(f, 0, g), p.push([Ae, f]));
|
|
else if (b !== f) {
|
|
let v = c.splice(f, 1)[0],
|
|
O = c.splice(b - 1, 1)[0];
|
|
(c.splice(f, 0, O), c.splice(b, 0, v), h.push([v, O]));
|
|
} else H.push(g);
|
|
Ae = g;
|
|
}
|
|
for (let f = 0; f < w.length; f++) {
|
|
let g = w[f];
|
|
g in a &&
|
|
(m(() => {
|
|
($(a[g]), a[g].remove());
|
|
}),
|
|
delete a[g]);
|
|
}
|
|
for (let f = 0; f < h.length; f++) {
|
|
let [g, b] = h[f],
|
|
v = a[g],
|
|
O = a[b],
|
|
te = document.createElement("div");
|
|
(m(() => {
|
|
(O || E('x-for ":key" is undefined or invalid', o, b, a),
|
|
O.after(te),
|
|
v.after(O),
|
|
O._x_currentIfEl && O.after(O._x_currentIfEl),
|
|
te.before(v),
|
|
v._x_currentIfEl && v.after(v._x_currentIfEl),
|
|
te.remove());
|
|
}),
|
|
O._x_refreshXForScope(l[u.indexOf(b)]));
|
|
}
|
|
for (let f = 0; f < p.length; f++) {
|
|
let [g, b] = p[f],
|
|
v = g === "template" ? o : a[g];
|
|
v._x_currentIfEl && (v = v._x_currentIfEl);
|
|
let O = l[b],
|
|
te = u[b],
|
|
fe = document.importNode(o.content, !0).firstElementChild,
|
|
qt = R(O);
|
|
(D(fe, qt, o),
|
|
(fe._x_refreshXForScope = (Dn) => {
|
|
Object.entries(Dn).forEach(([kn, Pn]) => {
|
|
qt[kn] = Pn;
|
|
});
|
|
}),
|
|
m(() => {
|
|
(v.after(fe), A(() => S(fe))());
|
|
}),
|
|
typeof te == "object" &&
|
|
E(
|
|
"x-for key cannot be an object, it must be a string or an integer",
|
|
o,
|
|
),
|
|
(a[te] = fe));
|
|
}
|
|
for (let f = 0; f < H.length; f++)
|
|
a[H[f]]._x_refreshXForScope(l[u.indexOf(H[f])]);
|
|
o._x_prevKeys = u;
|
|
});
|
|
}
|
|
function lo(e) {
|
|
let t = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/,
|
|
r = /^\s*\(|\)\s*$/g,
|
|
n = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,
|
|
i = e.match(n);
|
|
if (!i) return;
|
|
let o = {};
|
|
o.items = i[2].trim();
|
|
let s = i[1].replace(r, "").trim(),
|
|
a = s.match(t);
|
|
return (
|
|
a
|
|
? ((o.item = s.replace(t, "").trim()),
|
|
(o.index = a[1].trim()),
|
|
a[2] && (o.collection = a[2].trim()))
|
|
: (o.item = s),
|
|
o
|
|
);
|
|
}
|
|
function Mn(e, t, r, n) {
|
|
let i = {};
|
|
return (
|
|
/^\[.*\]$/.test(e.item) && Array.isArray(t)
|
|
? e.item
|
|
.replace("[", "")
|
|
.replace("]", "")
|
|
.split(",")
|
|
.map((s) => s.trim())
|
|
.forEach((s, a) => {
|
|
i[s] = t[a];
|
|
})
|
|
: /^\{.*\}$/.test(e.item) &&
|
|
!Array.isArray(t) &&
|
|
typeof t == "object"
|
|
? e.item
|
|
.replace("{", "")
|
|
.replace("}", "")
|
|
.split(",")
|
|
.map((s) => s.trim())
|
|
.forEach((s) => {
|
|
i[s] = t[s];
|
|
})
|
|
: (i[e.item] = t),
|
|
e.index && (i[e.index] = r),
|
|
e.collection && (i[e.collection] = n),
|
|
i
|
|
);
|
|
}
|
|
function uo(e) {
|
|
return !Array.isArray(e) && !isNaN(e);
|
|
}
|
|
function Nn() {}
|
|
Nn.inline = (e, { expression: t }, { cleanup: r }) => {
|
|
let n = X(e);
|
|
(n._x_refs || (n._x_refs = {}),
|
|
(n._x_refs[t] = e),
|
|
r(() => delete n._x_refs[t]));
|
|
};
|
|
d("ref", Nn);
|
|
d("if", (e, { expression: t }, { effect: r, cleanup: n }) => {
|
|
e.tagName.toLowerCase() !== "template" &&
|
|
E("x-if can only be used on a <template> tag", e);
|
|
let i = x(e, t),
|
|
o = () => {
|
|
if (e._x_currentIfEl) return e._x_currentIfEl;
|
|
let a = e.content.cloneNode(!0).firstElementChild;
|
|
return (
|
|
D(a, {}, e),
|
|
m(() => {
|
|
(e.after(a), A(() => S(a))());
|
|
}),
|
|
(e._x_currentIfEl = a),
|
|
(e._x_undoIf = () => {
|
|
(m(() => {
|
|
($(a), a.remove());
|
|
}),
|
|
delete e._x_currentIfEl);
|
|
}),
|
|
a
|
|
);
|
|
},
|
|
s = () => {
|
|
e._x_undoIf && (e._x_undoIf(), delete e._x_undoIf);
|
|
};
|
|
(r(() =>
|
|
i((a) => {
|
|
a ? o() : s();
|
|
}),
|
|
),
|
|
n(() => e._x_undoIf && e._x_undoIf()));
|
|
});
|
|
d("id", (e, { expression: t }, { evaluate: r }) => {
|
|
r(t).forEach((i) => En(e, i));
|
|
});
|
|
V((e, t) => {
|
|
e._x_ids && (t._x_ids = e._x_ids);
|
|
});
|
|
se(Pe("@", Ie(C("on:"))));
|
|
d(
|
|
"on",
|
|
A((e, { value: t, modifiers: r, expression: n }, { cleanup: i }) => {
|
|
let o = n ? x(e, n) : () => {};
|
|
e.tagName.toLowerCase() === "template" &&
|
|
(e._x_forwardEvents || (e._x_forwardEvents = []),
|
|
e._x_forwardEvents.includes(t) || e._x_forwardEvents.push(t));
|
|
let s = ue(e, t, r, (a) => {
|
|
o(() => {}, { scope: { $event: a }, params: [a] });
|
|
});
|
|
i(() => s());
|
|
}),
|
|
);
|
|
rt("Collapse", "collapse", "collapse");
|
|
rt("Intersect", "intersect", "intersect");
|
|
rt("Focus", "trap", "focus");
|
|
rt("Mask", "mask", "mask");
|
|
function rt(e, t, r) {
|
|
d(t, (n) =>
|
|
E(
|
|
`You can't use [x-${t}] without first installing the "${e}" plugin here: https://alpinejs.dev/plugins/${r}`,
|
|
n,
|
|
),
|
|
);
|
|
}
|
|
z.setEvaluator(xt);
|
|
z.setRawEvaluator(pr);
|
|
z.setReactivityEngine({ reactive: et, effect: ln, release: un, raw: _ });
|
|
var Vt = z;
|
|
window.Alpine = Vt;
|
|
queueMicrotask(() => {
|
|
Vt.start();
|
|
});
|
|
})();
|