|
|
(() => { |
|
|
var pe = (t, f) => () => ( |
|
|
f || t((f = { exports: {} }).exports, f), f.exports |
|
|
); |
|
|
var Ye = pe(() => { |
|
|
window.tram = (function(t) { |
|
|
|
|
|
function f(e, r) { |
|
|
var a = new g.Bare(); |
|
|
return a.init(e, r); |
|
|
} |
|
|
|
|
|
|
|
|
function h(e) { |
|
|
return e.replace(/[A-Z]/g, function(r) { |
|
|
return "-" + r.toLowerCase(); |
|
|
}); |
|
|
} |
|
|
|
|
|
function S(e) { |
|
|
var r = parseInt(e.slice(1), 16), |
|
|
a = (r >> 16) & 255, |
|
|
s = (r >> 8) & 255, |
|
|
i = 255 & r; |
|
|
return [a, s, i]; |
|
|
} |
|
|
|
|
|
function R(e, r, a) { |
|
|
return ( |
|
|
"#" + ((1 << 24) | (e << 16) | (r << 8) | a).toString(16).slice(1) |
|
|
); |
|
|
} |
|
|
|
|
|
function m() {} |
|
|
|
|
|
function F(e, r) { |
|
|
X("Type warning: Expected: [" + e + "] Got: [" + typeof r + "] " + r); |
|
|
} |
|
|
|
|
|
function _(e, r, a) { |
|
|
X("Units do not match [" + e + "]: " + r + ", " + a); |
|
|
} |
|
|
|
|
|
function H(e, r, a) { |
|
|
if ((r !== void 0 && (a = r), e === void 0)) return a; |
|
|
var s = a; |
|
|
return ( |
|
|
We.test(e) || !Ce.test(e) ? |
|
|
(s = parseInt(e, 10)) : |
|
|
Ce.test(e) && (s = 1e3 * parseFloat(e)), |
|
|
0 > s && (s = 0), |
|
|
s === s ? s : a |
|
|
); |
|
|
} |
|
|
|
|
|
function X(e) { |
|
|
re.debug && window && window.console.warn(e); |
|
|
} |
|
|
|
|
|
function te(e) { |
|
|
for (var r = -1, a = e ? e.length : 0, s = []; ++r < a;) { |
|
|
var i = e[r]; |
|
|
i && s.push(i); |
|
|
} |
|
|
return s; |
|
|
} |
|
|
var z = (function(e, r, a) { |
|
|
function s(K) { |
|
|
return typeof K == "object"; |
|
|
} |
|
|
|
|
|
function i(K) { |
|
|
return typeof K == "function"; |
|
|
} |
|
|
|
|
|
function u() {} |
|
|
|
|
|
function I(K, se) { |
|
|
function y() { |
|
|
var ge = new J(); |
|
|
return i(ge.init) && ge.init.apply(ge, arguments), ge; |
|
|
} |
|
|
|
|
|
function J() {} |
|
|
se === a && ((se = K), (K = Object)), (y.Bare = J); |
|
|
var ee, |
|
|
he = (u[e] = K[e]), |
|
|
Oe = (J[e] = y[e] = new u()); |
|
|
return ( |
|
|
(Oe.constructor = y), |
|
|
(y.mixin = function(ge) { |
|
|
return (J[e] = y[e] = I(y, ge)[e]), y; |
|
|
}), |
|
|
(y.open = function(ge) { |
|
|
if ( |
|
|
((ee = {}), |
|
|
i(ge) ? |
|
|
(ee = ge.call(y, Oe, he, y, K)) : |
|
|
s(ge) && (ee = ge), |
|
|
s(ee)) |
|
|
) |
|
|
for (var Ne in ee) r.call(ee, Ne) && (Oe[Ne] = ee[Ne]); |
|
|
return i(Oe.init) || (Oe.init = K), y; |
|
|
}), |
|
|
y.open(se) |
|
|
); |
|
|
} |
|
|
return I; |
|
|
})("prototype", {}.hasOwnProperty), |
|
|
Q = { |
|
|
ease: [ |
|
|
"ease", |
|
|
function(e, r, a, s) { |
|
|
var i = (e /= s) * e, |
|
|
u = i * e; |
|
|
return ( |
|
|
r + |
|
|
a * |
|
|
(-2.75 * u * i + 11 * i * i + -15.5 * u + 8 * i + 0.25 * e) |
|
|
); |
|
|
}, |
|
|
], |
|
|
"ease-in": [ |
|
|
"ease-in", |
|
|
function(e, r, a, s) { |
|
|
var i = (e /= s) * e, |
|
|
u = i * e; |
|
|
return r + a * (-1 * u * i + 3 * i * i + -3 * u + 2 * i); |
|
|
}, |
|
|
], |
|
|
"ease-out": [ |
|
|
"ease-out", |
|
|
function(e, r, a, s) { |
|
|
var i = (e /= s) * e, |
|
|
u = i * e; |
|
|
return ( |
|
|
r + |
|
|
a * |
|
|
(0.3 * u * i + -1.6 * i * i + 2.2 * u + -1.8 * i + 1.9 * e) |
|
|
); |
|
|
}, |
|
|
], |
|
|
"ease-in-out": [ |
|
|
"ease-in-out", |
|
|
function(e, r, a, s) { |
|
|
var i = (e /= s) * e, |
|
|
u = i * e; |
|
|
return r + a * (2 * u * i + -5 * i * i + 2 * u + 2 * i); |
|
|
}, |
|
|
], |
|
|
linear: [ |
|
|
"linear", |
|
|
function(e, r, a, s) { |
|
|
return (a * e) / s + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-quad": [ |
|
|
"cubic-bezier(0.550, 0.085, 0.680, 0.530)", |
|
|
function(e, r, a, s) { |
|
|
return a * (e /= s) * e + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-quad": [ |
|
|
"cubic-bezier(0.250, 0.460, 0.450, 0.940)", |
|
|
function(e, r, a, s) { |
|
|
return -a * (e /= s) * (e - 2) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-quad": [ |
|
|
"cubic-bezier(0.455, 0.030, 0.515, 0.955)", |
|
|
function(e, r, a, s) { |
|
|
return (e /= s / 2) < 1 ? |
|
|
(a / 2) * e * e + r : |
|
|
(-a / 2) * (--e * (e - 2) - 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-cubic": [ |
|
|
"cubic-bezier(0.550, 0.055, 0.675, 0.190)", |
|
|
function(e, r, a, s) { |
|
|
return a * (e /= s) * e * e + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-cubic": [ |
|
|
"cubic-bezier(0.215, 0.610, 0.355, 1)", |
|
|
function(e, r, a, s) { |
|
|
return a * ((e = e / s - 1) * e * e + 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-cubic": [ |
|
|
"cubic-bezier(0.645, 0.045, 0.355, 1)", |
|
|
function(e, r, a, s) { |
|
|
return (e /= s / 2) < 1 ? |
|
|
(a / 2) * e * e * e + r : |
|
|
(a / 2) * ((e -= 2) * e * e + 2) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-quart": [ |
|
|
"cubic-bezier(0.895, 0.030, 0.685, 0.220)", |
|
|
function(e, r, a, s) { |
|
|
return a * (e /= s) * e * e * e + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-quart": [ |
|
|
"cubic-bezier(0.165, 0.840, 0.440, 1)", |
|
|
function(e, r, a, s) { |
|
|
return -a * ((e = e / s - 1) * e * e * e - 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-quart": [ |
|
|
"cubic-bezier(0.770, 0, 0.175, 1)", |
|
|
function(e, r, a, s) { |
|
|
return (e /= s / 2) < 1 ? |
|
|
(a / 2) * e * e * e * e + r : |
|
|
(-a / 2) * ((e -= 2) * e * e * e - 2) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-quint": [ |
|
|
"cubic-bezier(0.755, 0.050, 0.855, 0.060)", |
|
|
function(e, r, a, s) { |
|
|
return a * (e /= s) * e * e * e * e + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-quint": [ |
|
|
"cubic-bezier(0.230, 1, 0.320, 1)", |
|
|
function(e, r, a, s) { |
|
|
return a * ((e = e / s - 1) * e * e * e * e + 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-quint": [ |
|
|
"cubic-bezier(0.860, 0, 0.070, 1)", |
|
|
function(e, r, a, s) { |
|
|
return (e /= s / 2) < 1 ? |
|
|
(a / 2) * e * e * e * e * e + r : |
|
|
(a / 2) * ((e -= 2) * e * e * e * e + 2) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-sine": [ |
|
|
"cubic-bezier(0.470, 0, 0.745, 0.715)", |
|
|
function(e, r, a, s) { |
|
|
return -a * Math.cos((e / s) * (Math.PI / 2)) + a + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-sine": [ |
|
|
"cubic-bezier(0.390, 0.575, 0.565, 1)", |
|
|
function(e, r, a, s) { |
|
|
return a * Math.sin((e / s) * (Math.PI / 2)) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-sine": [ |
|
|
"cubic-bezier(0.445, 0.050, 0.550, 0.950)", |
|
|
function(e, r, a, s) { |
|
|
return (-a / 2) * (Math.cos((Math.PI * e) / s) - 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-expo": [ |
|
|
"cubic-bezier(0.950, 0.050, 0.795, 0.035)", |
|
|
function(e, r, a, s) { |
|
|
return e === 0 ? r : a * Math.pow(2, 10 * (e / s - 1)) + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-expo": [ |
|
|
"cubic-bezier(0.190, 1, 0.220, 1)", |
|
|
function(e, r, a, s) { |
|
|
return e === s ? |
|
|
r + a : |
|
|
a * (-Math.pow(2, (-10 * e) / s) + 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-expo": [ |
|
|
"cubic-bezier(1, 0, 0, 1)", |
|
|
function(e, r, a, s) { |
|
|
return e === 0 ? |
|
|
r : |
|
|
e === s ? |
|
|
r + a : |
|
|
(e /= s / 2) < 1 ? |
|
|
(a / 2) * Math.pow(2, 10 * (e - 1)) + r : |
|
|
(a / 2) * (-Math.pow(2, -10 * --e) + 2) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-circ": [ |
|
|
"cubic-bezier(0.600, 0.040, 0.980, 0.335)", |
|
|
function(e, r, a, s) { |
|
|
return -a * (Math.sqrt(1 - (e /= s) * e) - 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-out-circ": [ |
|
|
"cubic-bezier(0.075, 0.820, 0.165, 1)", |
|
|
function(e, r, a, s) { |
|
|
return a * Math.sqrt(1 - (e = e / s - 1) * e) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-out-circ": [ |
|
|
"cubic-bezier(0.785, 0.135, 0.150, 0.860)", |
|
|
function(e, r, a, s) { |
|
|
return (e /= s / 2) < 1 ? |
|
|
(-a / 2) * (Math.sqrt(1 - e * e) - 1) + r : |
|
|
(a / 2) * (Math.sqrt(1 - (e -= 2) * e) + 1) + r; |
|
|
}, |
|
|
], |
|
|
"ease-in-back": [ |
|
|
"cubic-bezier(0.600, -0.280, 0.735, 0.045)", |
|
|
function(e, r, a, s, i) { |
|
|
return ( |
|
|
i === void 0 && (i = 1.70158), |
|
|
a * (e /= s) * e * ((i + 1) * e - i) + r |
|
|
); |
|
|
}, |
|
|
], |
|
|
"ease-out-back": [ |
|
|
"cubic-bezier(0.175, 0.885, 0.320, 1.275)", |
|
|
function(e, r, a, s, i) { |
|
|
return ( |
|
|
i === void 0 && (i = 1.70158), |
|
|
a * ((e = e / s - 1) * e * ((i + 1) * e + i) + 1) + r |
|
|
); |
|
|
}, |
|
|
], |
|
|
"ease-in-out-back": [ |
|
|
"cubic-bezier(0.680, -0.550, 0.265, 1.550)", |
|
|
function(e, r, a, s, i) { |
|
|
return ( |
|
|
i === void 0 && (i = 1.70158), |
|
|
(e /= s / 2) < 1 ? |
|
|
(a / 2) * e * e * (((i *= 1.525) + 1) * e - i) + r : |
|
|
(a / 2) * |
|
|
((e -= 2) * e * (((i *= 1.525) + 1) * e + i) + 2) + |
|
|
r |
|
|
); |
|
|
}, |
|
|
], |
|
|
}, |
|
|
A = { |
|
|
"ease-in-back": "cubic-bezier(0.600, 0, 0.735, 0.045)", |
|
|
"ease-out-back": "cubic-bezier(0.175, 0.885, 0.320, 1)", |
|
|
"ease-in-out-back": "cubic-bezier(0.680, 0, 0.265, 1)", |
|
|
}, |
|
|
D = document, |
|
|
j = window, |
|
|
Z = "bkwld-tram", |
|
|
B = /[\-\.0-9]/g, |
|
|
M = /[A-Z]/, |
|
|
E = "number", |
|
|
W = /^(rgb|#)/, |
|
|
L = /(em|cm|mm|in|pt|pc|px)$/, |
|
|
Y = /(em|cm|mm|in|pt|pc|px|%)$/, |
|
|
ue = /(deg|rad|turn)$/, |
|
|
le = "unitless", |
|
|
de = /(all|none) 0s ease 0s/, |
|
|
ye = /^(width|height)$/, |
|
|
$ = " ", |
|
|
v = D.createElement("a"), |
|
|
o = ["Webkit", "Moz", "O", "ms"], |
|
|
c = ["-webkit-", "-moz-", "-o-", "-ms-"], |
|
|
d = function(e) { |
|
|
if (e in v.style) return { dom: e, css: e }; |
|
|
var r, |
|
|
a, |
|
|
s = "", |
|
|
i = e.split("-"); |
|
|
for (r = 0; r < i.length; r++) |
|
|
s += i[r].charAt(0).toUpperCase() + i[r].slice(1); |
|
|
for (r = 0; r < o.length; r++) |
|
|
if (((a = o[r] + s), a in v.style)) |
|
|
return { dom: a, css: c[r] + e }; |
|
|
}, |
|
|
w = (f.support = { |
|
|
bind: Function.prototype.bind, |
|
|
transform: d("transform"), |
|
|
transition: d("transition"), |
|
|
backface: d("backface-visibility"), |
|
|
timing: d("transition-timing-function"), |
|
|
}); |
|
|
if (w.transition) { |
|
|
var P = w.timing.dom; |
|
|
if (((v.style[P] = Q["ease-in-back"][0]), !v.style[P])) |
|
|
for (var q in A) Q[q][0] = A[q]; |
|
|
} |
|
|
var l = (f.frame = (function() { |
|
|
var e = |
|
|
j.requestAnimationFrame || |
|
|
j.webkitRequestAnimationFrame || |
|
|
j.mozRequestAnimationFrame || |
|
|
j.oRequestAnimationFrame || |
|
|
j.msRequestAnimationFrame; |
|
|
return e && w.bind ? |
|
|
e.bind(j) : |
|
|
function(r) { |
|
|
j.setTimeout(r, 16); |
|
|
}; |
|
|
})()), |
|
|
x = (f.now = (function() { |
|
|
var e = j.performance, |
|
|
r = e && (e.now || e.webkitNow || e.msNow || e.mozNow); |
|
|
return r && w.bind ? |
|
|
r.bind(e) : |
|
|
Date.now || |
|
|
function() { |
|
|
return +new Date(); |
|
|
}; |
|
|
})()), |
|
|
T = z(function(e) { |
|
|
function r(N, ne) { |
|
|
var fe = te(("" + N).split($)), |
|
|
ie = fe[0]; |
|
|
ne = ne || {}; |
|
|
var we = k[ie]; |
|
|
if (!we) return X("Unsupported property: " + ie); |
|
|
if (!ne.weak || !this.props[ie]) { |
|
|
var ke = we[0], |
|
|
be = this.props[ie]; |
|
|
return ( |
|
|
be || (be = this.props[ie] = new ke.Bare()), |
|
|
be.init(this.$el, fe, we, ne), |
|
|
be |
|
|
); |
|
|
} |
|
|
} |
|
|
|
|
|
function a(N, ne, fe) { |
|
|
if (N) { |
|
|
var ie = typeof N; |
|
|
if ( |
|
|
(ne || |
|
|
(this.timer && this.timer.destroy(), |
|
|
(this.queue = []), |
|
|
(this.active = !1)), |
|
|
ie == "number" && ne) |
|
|
) |
|
|
return ( |
|
|
(this.timer = new ae({ |
|
|
duration: N, |
|
|
context: this, |
|
|
complete: u, |
|
|
})), |
|
|
void(this.active = !0) |
|
|
); |
|
|
if (ie == "string" && ne) { |
|
|
switch (N) { |
|
|
case "hide": |
|
|
y.call(this); |
|
|
break; |
|
|
case "stop": |
|
|
I.call(this); |
|
|
break; |
|
|
case "redraw": |
|
|
J.call(this); |
|
|
break; |
|
|
default: |
|
|
r.call(this, N, fe && fe[1]); |
|
|
} |
|
|
return u.call(this); |
|
|
} |
|
|
if (ie == "function") return void N.call(this, this); |
|
|
if (ie == "object") { |
|
|
var we = 0; |
|
|
Oe.call( |
|
|
this, |
|
|
N, |
|
|
function(ve, Vt) { |
|
|
ve.span > we && (we = ve.span), ve.stop(), ve.animate(Vt); |
|
|
}, |
|
|
function(ve) { |
|
|
"wait" in ve && (we = H(ve.wait, 0)); |
|
|
} |
|
|
), |
|
|
he.call(this), |
|
|
we > 0 && |
|
|
((this.timer = new ae({ duration: we, context: this })), |
|
|
(this.active = !0), |
|
|
ne && (this.timer.complete = u)); |
|
|
var ke = this, |
|
|
be = !1, |
|
|
ze = {}; |
|
|
l(function() { |
|
|
Oe.call(ke, N, function(ve) { |
|
|
ve.active && ((be = !0), (ze[ve.name] = ve.nextStyle)); |
|
|
}), |
|
|
be && ke.$el.css(ze); |
|
|
}); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function s(N) { |
|
|
(N = H(N, 0)), |
|
|
this.active ? |
|
|
this.queue.push({ options: N }) : |
|
|
((this.timer = new ae({ |
|
|
duration: N, |
|
|
context: this, |
|
|
complete: u, |
|
|
})), |
|
|
(this.active = !0)); |
|
|
} |
|
|
|
|
|
function i(N) { |
|
|
return this.active ? |
|
|
(this.queue.push({ options: N, args: arguments }), |
|
|
void(this.timer.complete = u)) : |
|
|
X( |
|
|
"No active transition timer. Use start() or wait() before then()." |
|
|
); |
|
|
} |
|
|
|
|
|
function u() { |
|
|
if ( |
|
|
(this.timer && this.timer.destroy(), |
|
|
(this.active = !1), |
|
|
this.queue.length) |
|
|
) { |
|
|
var N = this.queue.shift(); |
|
|
a.call(this, N.options, !0, N.args); |
|
|
} |
|
|
} |
|
|
|
|
|
function I(N) { |
|
|
this.timer && this.timer.destroy(), |
|
|
(this.queue = []), |
|
|
(this.active = !1); |
|
|
var ne; |
|
|
typeof N == "string" ? |
|
|
((ne = {}), (ne[N] = 1)) : |
|
|
(ne = typeof N == "object" && N != null ? N : this.props), |
|
|
Oe.call(this, ne, ge), |
|
|
he.call(this); |
|
|
} |
|
|
|
|
|
function K(N) { |
|
|
I.call(this, N), Oe.call(this, N, Ne, Xt); |
|
|
} |
|
|
|
|
|
function se(N) { |
|
|
typeof N != "string" && (N = "block"), |
|
|
(this.el.style.display = N); |
|
|
} |
|
|
|
|
|
function y() { |
|
|
I.call(this), (this.el.style.display = "none"); |
|
|
} |
|
|
|
|
|
function J() { |
|
|
this.el.offsetHeight; |
|
|
} |
|
|
|
|
|
function ee() { |
|
|
I.call(this), |
|
|
t.removeData(this.el, Z), |
|
|
(this.$el = this.el = null); |
|
|
} |
|
|
|
|
|
function he() { |
|
|
var N, |
|
|
ne, |
|
|
fe = []; |
|
|
this.upstream && fe.push(this.upstream); |
|
|
for (N in this.props) |
|
|
(ne = this.props[N]), ne.active && fe.push(ne.string); |
|
|
(fe = fe.join(",")), |
|
|
this.style !== fe && |
|
|
((this.style = fe), (this.el.style[w.transition.dom] = fe)); |
|
|
} |
|
|
|
|
|
function Oe(N, ne, fe) { |
|
|
var ie, |
|
|
we, |
|
|
ke, |
|
|
be, |
|
|
ze = ne !== ge, |
|
|
ve = {}; |
|
|
for (ie in N) |
|
|
(ke = N[ie]), |
|
|
ie in ce ? |
|
|
(ve.transform || (ve.transform = {}), |
|
|
(ve.transform[ie] = ke)) : |
|
|
(M.test(ie) && (ie = h(ie)), |
|
|
ie in k ? |
|
|
(ve[ie] = ke) : |
|
|
(be || (be = {}), (be[ie] = ke))); |
|
|
for (ie in ve) { |
|
|
if (((ke = ve[ie]), (we = this.props[ie]), !we)) { |
|
|
if (!ze) continue; |
|
|
we = r.call(this, ie); |
|
|
} |
|
|
ne.call(this, we, ke); |
|
|
} |
|
|
fe && be && fe.call(this, be); |
|
|
} |
|
|
|
|
|
function ge(N) { |
|
|
N.stop(); |
|
|
} |
|
|
|
|
|
function Ne(N, ne) { |
|
|
N.set(ne); |
|
|
} |
|
|
|
|
|
function Xt(N) { |
|
|
this.$el.css(N); |
|
|
} |
|
|
|
|
|
function xe(N, ne) { |
|
|
e[N] = function() { |
|
|
return this.children ? |
|
|
Kt.call(this, ne, arguments) : |
|
|
(this.el && ne.apply(this, arguments), this); |
|
|
}; |
|
|
} |
|
|
|
|
|
function Kt(N, ne) { |
|
|
var fe, |
|
|
ie = this.children.length; |
|
|
for (fe = 0; ie > fe; fe++) N.apply(this.children[fe], ne); |
|
|
return this; |
|
|
} |
|
|
(e.init = function(N) { |
|
|
if ( |
|
|
((this.$el = t(N)), |
|
|
(this.el = this.$el[0]), |
|
|
(this.props = {}), |
|
|
(this.queue = []), |
|
|
(this.style = ""), |
|
|
(this.active = !1), |
|
|
re.keepInherited && !re.fallback) |
|
|
) { |
|
|
var ne = b(this.el, "transition"); |
|
|
ne && !de.test(ne) && (this.upstream = ne); |
|
|
} |
|
|
w.backface && |
|
|
re.hideBackface && |
|
|
n(this.el, w.backface.css, "hidden"); |
|
|
}), |
|
|
xe("add", r), |
|
|
xe("start", a), |
|
|
xe("wait", s), |
|
|
xe("then", i), |
|
|
xe("next", u), |
|
|
xe("stop", I), |
|
|
xe("set", K), |
|
|
xe("show", se), |
|
|
xe("hide", y), |
|
|
xe("redraw", J), |
|
|
xe("destroy", ee); |
|
|
}), |
|
|
g = z(T, function(e) { |
|
|
function r(a, s) { |
|
|
var i = t.data(a, Z) || t.data(a, Z, new T.Bare()); |
|
|
return i.el || i.init(a), s ? i.start(s) : i; |
|
|
} |
|
|
e.init = function(a, s) { |
|
|
var i = t(a); |
|
|
if (!i.length) return this; |
|
|
if (i.length === 1) return r(i[0], s); |
|
|
var u = []; |
|
|
return ( |
|
|
i.each(function(I, K) { |
|
|
u.push(r(K, s)); |
|
|
}), |
|
|
(this.children = u), |
|
|
this |
|
|
); |
|
|
}; |
|
|
}), |
|
|
p = z(function(e) { |
|
|
function r() { |
|
|
var u = this.get(); |
|
|
this.update("auto"); |
|
|
var I = this.get(); |
|
|
return this.update(u), I; |
|
|
} |
|
|
|
|
|
function a(u, I, K) { |
|
|
return I !== void 0 && (K = I), u in Q ? u : K; |
|
|
} |
|
|
|
|
|
function s(u) { |
|
|
var I = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(u); |
|
|
return (I ? R(I[1], I[2], I[3]) : u).replace( |
|
|
/#(\w)(\w)(\w)$/, |
|
|
"#$1$1$2$2$3$3" |
|
|
); |
|
|
} |
|
|
var i = { duration: 500, ease: "ease", delay: 0 }; |
|
|
(e.init = function(u, I, K, se) { |
|
|
(this.$el = u), (this.el = u[0]); |
|
|
var y = I[0]; |
|
|
K[2] && (y = K[2]), |
|
|
C[y] && (y = C[y]), |
|
|
(this.name = y), |
|
|
(this.type = K[1]), |
|
|
(this.duration = H(I[1], this.duration, i.duration)), |
|
|
(this.ease = a(I[2], this.ease, i.ease)), |
|
|
(this.delay = H(I[3], this.delay, i.delay)), |
|
|
(this.span = this.duration + this.delay), |
|
|
(this.active = !1), |
|
|
(this.nextStyle = null), |
|
|
(this.auto = ye.test(this.name)), |
|
|
(this.unit = se.unit || this.unit || re.defaultUnit), |
|
|
(this.angle = se.angle || this.angle || re.defaultAngle), |
|
|
re.fallback || se.fallback ? |
|
|
(this.animate = this.fallback) : |
|
|
((this.animate = this.transition), |
|
|
(this.string = |
|
|
this.name + |
|
|
$ + |
|
|
this.duration + |
|
|
"ms" + |
|
|
(this.ease != "ease" ? $ + Q[this.ease][0] : "") + |
|
|
(this.delay ? $ + this.delay + "ms" : ""))); |
|
|
}), |
|
|
(e.set = function(u) { |
|
|
(u = this.convert(u, this.type)), this.update(u), this.redraw(); |
|
|
}), |
|
|
(e.transition = function(u) { |
|
|
(this.active = !0), |
|
|
(u = this.convert(u, this.type)), |
|
|
this.auto && |
|
|
(this.el.style[this.name] == "auto" && |
|
|
(this.update(this.get()), this.redraw()), |
|
|
u == "auto" && (u = r.call(this))), |
|
|
(this.nextStyle = u); |
|
|
}), |
|
|
(e.fallback = function(u) { |
|
|
var I = |
|
|
this.el.style[this.name] || |
|
|
this.convert(this.get(), this.type); |
|
|
(u = this.convert(u, this.type)), |
|
|
this.auto && |
|
|
(I == "auto" && (I = this.convert(this.get(), this.type)), |
|
|
u == "auto" && (u = r.call(this))), |
|
|
(this.tween = new U({ |
|
|
from: I, |
|
|
to: u, |
|
|
duration: this.duration, |
|
|
delay: this.delay, |
|
|
ease: this.ease, |
|
|
update: this.update, |
|
|
context: this, |
|
|
})); |
|
|
}), |
|
|
(e.get = function() { |
|
|
return b(this.el, this.name); |
|
|
}), |
|
|
(e.update = function(u) { |
|
|
n(this.el, this.name, u); |
|
|
}), |
|
|
(e.stop = function() { |
|
|
(this.active || this.nextStyle) && |
|
|
((this.active = !1), |
|
|
(this.nextStyle = null), |
|
|
n(this.el, this.name, this.get())); |
|
|
var u = this.tween; |
|
|
u && u.context && u.destroy(); |
|
|
}), |
|
|
(e.convert = function(u, I) { |
|
|
if (u == "auto" && this.auto) return u; |
|
|
var K, |
|
|
se = typeof u == "number", |
|
|
y = typeof u == "string"; |
|
|
switch (I) { |
|
|
case E: |
|
|
if (se) return u; |
|
|
if (y && u.replace(B, "") === "") return +u; |
|
|
K = "number(unitless)"; |
|
|
break; |
|
|
case W: |
|
|
if (y) { |
|
|
if (u === "" && this.original) return this.original; |
|
|
if (I.test(u)) |
|
|
return u.charAt(0) == "#" && u.length == 7 ? u : s(u); |
|
|
} |
|
|
K = "hex or rgb string"; |
|
|
break; |
|
|
case L: |
|
|
if (se) return u + this.unit; |
|
|
if (y && I.test(u)) return u; |
|
|
K = "number(px) or string(unit)"; |
|
|
break; |
|
|
case Y: |
|
|
if (se) return u + this.unit; |
|
|
if (y && I.test(u)) return u; |
|
|
K = "number(px) or string(unit or %)"; |
|
|
break; |
|
|
case ue: |
|
|
if (se) return u + this.angle; |
|
|
if (y && I.test(u)) return u; |
|
|
K = "number(deg) or string(angle)"; |
|
|
break; |
|
|
case le: |
|
|
if (se || (y && Y.test(u))) return u; |
|
|
K = "number(unitless) or string(unit or %)"; |
|
|
} |
|
|
return F(K, u), u; |
|
|
}), |
|
|
(e.redraw = function() { |
|
|
this.el.offsetHeight; |
|
|
}); |
|
|
}), |
|
|
O = z(p, function(e, r) { |
|
|
e.init = function() { |
|
|
r.init.apply(this, arguments), |
|
|
this.original || (this.original = this.convert(this.get(), W)); |
|
|
}; |
|
|
}), |
|
|
G = z(p, function(e, r) { |
|
|
(e.init = function() { |
|
|
r.init.apply(this, arguments), (this.animate = this.fallback); |
|
|
}), |
|
|
(e.get = function() { |
|
|
return this.$el[this.name](); |
|
|
}), |
|
|
(e.update = function(a) { |
|
|
this.$el[this.name](a); |
|
|
}); |
|
|
}), |
|
|
V = z(p, function(e, r) { |
|
|
function a(s, i) { |
|
|
var u, I, K, se, y; |
|
|
for (u in s) |
|
|
(se = ce[u]), |
|
|
(K = se[0]), |
|
|
(I = se[1] || u), |
|
|
(y = this.convert(s[u], K)), |
|
|
i.call(this, I, y, K); |
|
|
} |
|
|
(e.init = function() { |
|
|
r.init.apply(this, arguments), |
|
|
this.current || |
|
|
((this.current = {}), |
|
|
ce.perspective && |
|
|
re.perspective && |
|
|
((this.current.perspective = re.perspective), |
|
|
n(this.el, this.name, this.style(this.current)), |
|
|
this.redraw())); |
|
|
}), |
|
|
(e.set = function(s) { |
|
|
a.call(this, s, function(i, u) { |
|
|
this.current[i] = u; |
|
|
}), |
|
|
n(this.el, this.name, this.style(this.current)), |
|
|
this.redraw(); |
|
|
}), |
|
|
(e.transition = function(s) { |
|
|
var i = this.values(s); |
|
|
this.tween = new Te({ |
|
|
current: this.current, |
|
|
values: i, |
|
|
duration: this.duration, |
|
|
delay: this.delay, |
|
|
ease: this.ease, |
|
|
}); |
|
|
var u, |
|
|
I = {}; |
|
|
for (u in this.current) I[u] = u in i ? i[u] : this.current[u]; |
|
|
(this.active = !0), (this.nextStyle = this.style(I)); |
|
|
}), |
|
|
(e.fallback = function(s) { |
|
|
var i = this.values(s); |
|
|
this.tween = new Te({ |
|
|
current: this.current, |
|
|
values: i, |
|
|
duration: this.duration, |
|
|
delay: this.delay, |
|
|
ease: this.ease, |
|
|
update: this.update, |
|
|
context: this, |
|
|
}); |
|
|
}), |
|
|
(e.update = function() { |
|
|
n(this.el, this.name, this.style(this.current)); |
|
|
}), |
|
|
(e.style = function(s) { |
|
|
var i, |
|
|
u = ""; |
|
|
for (i in s) u += i + "(" + s[i] + ") "; |
|
|
return u; |
|
|
}), |
|
|
(e.values = function(s) { |
|
|
var i, |
|
|
u = {}; |
|
|
return ( |
|
|
a.call(this, s, function(I, K, se) { |
|
|
(u[I] = K), |
|
|
this.current[I] === void 0 && |
|
|
((i = 0), ~I.indexOf("scale") && (i = 1), |
|
|
(this.current[I] = this.convert(i, se))); |
|
|
}), |
|
|
u |
|
|
); |
|
|
}); |
|
|
}), |
|
|
U = z(function(e) { |
|
|
function r(y) { |
|
|
K.push(y) === 1 && l(a); |
|
|
} |
|
|
|
|
|
function a() { |
|
|
var y, |
|
|
J, |
|
|
ee, |
|
|
he = K.length; |
|
|
if (he) |
|
|
for (l(a), J = x(), y = he; y--;) |
|
|
(ee = K[y]), ee && ee.render(J); |
|
|
} |
|
|
|
|
|
function s(y) { |
|
|
var J, |
|
|
ee = t.inArray(y, K); |
|
|
ee >= 0 && |
|
|
((J = K.slice(ee + 1)), |
|
|
(K.length = ee), |
|
|
J.length && (K = K.concat(J))); |
|
|
} |
|
|
|
|
|
function i(y) { |
|
|
return Math.round(y * se) / se; |
|
|
} |
|
|
|
|
|
function u(y, J, ee) { |
|
|
return R( |
|
|
y[0] + ee * (J[0] - y[0]), |
|
|
y[1] + ee * (J[1] - y[1]), |
|
|
y[2] + ee * (J[2] - y[2]) |
|
|
); |
|
|
} |
|
|
var I = { ease: Q.ease[1], from: 0, to: 1 }; |
|
|
(e.init = function(y) { |
|
|
(this.duration = y.duration || 0), (this.delay = y.delay || 0); |
|
|
var J = y.ease || I.ease; |
|
|
Q[J] && (J = Q[J][1]), |
|
|
typeof J != "function" && (J = I.ease), |
|
|
(this.ease = J), |
|
|
(this.update = y.update || m), |
|
|
(this.complete = y.complete || m), |
|
|
(this.context = y.context || this), |
|
|
(this.name = y.name); |
|
|
var ee = y.from, |
|
|
he = y.to; |
|
|
ee === void 0 && (ee = I.from), |
|
|
he === void 0 && (he = I.to), |
|
|
(this.unit = y.unit || ""), |
|
|
typeof ee == "number" && typeof he == "number" ? |
|
|
((this.begin = ee), (this.change = he - ee)) : |
|
|
this.format(he, ee), |
|
|
(this.value = this.begin + this.unit), |
|
|
(this.start = x()), |
|
|
y.autoplay !== !1 && this.play(); |
|
|
}), |
|
|
(e.play = function() { |
|
|
this.active || |
|
|
(this.start || (this.start = x()), |
|
|
(this.active = !0), |
|
|
r(this)); |
|
|
}), |
|
|
(e.stop = function() { |
|
|
this.active && ((this.active = !1), s(this)); |
|
|
}), |
|
|
(e.render = function(y) { |
|
|
var J, |
|
|
ee = y - this.start; |
|
|
if (this.delay) { |
|
|
if (ee <= this.delay) return; |
|
|
ee -= this.delay; |
|
|
} |
|
|
if (ee < this.duration) { |
|
|
var he = this.ease(ee, 0, 1, this.duration); |
|
|
return ( |
|
|
(J = this.startRGB ? |
|
|
u(this.startRGB, this.endRGB, he) : |
|
|
i(this.begin + he * this.change)), |
|
|
(this.value = J + this.unit), |
|
|
void this.update.call(this.context, this.value) |
|
|
); |
|
|
} |
|
|
(J = this.endHex || this.begin + this.change), |
|
|
(this.value = J + this.unit), |
|
|
this.update.call(this.context, this.value), |
|
|
this.complete.call(this.context), |
|
|
this.destroy(); |
|
|
}), |
|
|
(e.format = function(y, J) { |
|
|
if (((J += ""), (y += ""), y.charAt(0) == "#")) |
|
|
return ( |
|
|
(this.startRGB = S(J)), |
|
|
(this.endRGB = S(y)), |
|
|
(this.endHex = y), |
|
|
(this.begin = 0), |
|
|
void(this.change = 1) |
|
|
); |
|
|
if (!this.unit) { |
|
|
var ee = J.replace(B, ""), |
|
|
he = y.replace(B, ""); |
|
|
ee !== he && _("tween", J, y), (this.unit = ee); |
|
|
} |
|
|
(J = parseFloat(J)), |
|
|
(y = parseFloat(y)), |
|
|
(this.begin = this.value = J), |
|
|
(this.change = y - J); |
|
|
}), |
|
|
(e.destroy = function() { |
|
|
this.stop(), |
|
|
(this.context = null), |
|
|
(this.ease = this.update = this.complete = m); |
|
|
}); |
|
|
var K = [], |
|
|
se = 1e3; |
|
|
}), |
|
|
ae = z(U, function(e) { |
|
|
(e.init = function(r) { |
|
|
(this.duration = r.duration || 0), |
|
|
(this.complete = r.complete || m), |
|
|
(this.context = r.context), |
|
|
this.play(); |
|
|
}), |
|
|
(e.render = function(r) { |
|
|
var a = r - this.start; |
|
|
a < this.duration || |
|
|
(this.complete.call(this.context), this.destroy()); |
|
|
}); |
|
|
}), |
|
|
Te = z(U, function(e, r) { |
|
|
(e.init = function(a) { |
|
|
(this.context = a.context), |
|
|
(this.update = a.update), |
|
|
(this.tweens = []), |
|
|
(this.current = a.current); |
|
|
var s, i; |
|
|
for (s in a.values) |
|
|
(i = a.values[s]), |
|
|
this.current[s] !== i && |
|
|
this.tweens.push( |
|
|
new U({ |
|
|
name: s, |
|
|
from: this.current[s], |
|
|
to: i, |
|
|
duration: a.duration, |
|
|
delay: a.delay, |
|
|
ease: a.ease, |
|
|
autoplay: !1, |
|
|
}) |
|
|
); |
|
|
this.play(); |
|
|
}), |
|
|
(e.render = function(a) { |
|
|
var s, |
|
|
i, |
|
|
u = this.tweens.length, |
|
|
I = !1; |
|
|
for (s = u; s--;) |
|
|
(i = this.tweens[s]), |
|
|
i.context && |
|
|
(i.render(a), (this.current[i.name] = i.value), (I = !0)); |
|
|
return I ? |
|
|
void(this.update && this.update.call(this.context)) : |
|
|
this.destroy(); |
|
|
}), |
|
|
(e.destroy = function() { |
|
|
if ((r.destroy.call(this), this.tweens)) { |
|
|
var a, |
|
|
s = this.tweens.length; |
|
|
for (a = s; a--;) this.tweens[a].destroy(); |
|
|
(this.tweens = null), (this.current = null); |
|
|
} |
|
|
}); |
|
|
}), |
|
|
re = (f.config = { |
|
|
debug: !1, |
|
|
defaultUnit: "px", |
|
|
defaultAngle: "deg", |
|
|
keepInherited: !1, |
|
|
hideBackface: !1, |
|
|
perspective: "", |
|
|
fallback: !w.transition, |
|
|
agentTests: [], |
|
|
}); |
|
|
(f.fallback = function(e) { |
|
|
if (!w.transition) return (re.fallback = !0); |
|
|
re.agentTests.push("(" + e + ")"); |
|
|
var r = new RegExp(re.agentTests.join("|"), "i"); |
|
|
re.fallback = r.test(navigator.userAgent); |
|
|
}), |
|
|
f.fallback("6.0.[2-5] Safari"), |
|
|
(f.tween = function(e) { |
|
|
return new U(e); |
|
|
}), |
|
|
(f.delay = function(e, r, a) { |
|
|
return new ae({ complete: r, duration: e, context: a }); |
|
|
}), |
|
|
(t.fn.tram = function(e) { |
|
|
return f.call(null, this, e); |
|
|
}); |
|
|
var n = t.style, |
|
|
b = t.css, |
|
|
C = { transform: w.transform && w.transform.css }, |
|
|
k = { |
|
|
color: [O, W], |
|
|
background: [O, W, "background-color"], |
|
|
"outline-color": [O, W], |
|
|
"border-color": [O, W], |
|
|
"border-top-color": [O, W], |
|
|
"border-right-color": [O, W], |
|
|
"border-bottom-color": [O, W], |
|
|
"border-left-color": [O, W], |
|
|
"border-width": [p, L], |
|
|
"border-top-width": [p, L], |
|
|
"border-right-width": [p, L], |
|
|
"border-bottom-width": [p, L], |
|
|
"border-left-width": [p, L], |
|
|
"border-spacing": [p, L], |
|
|
"letter-spacing": [p, L], |
|
|
margin: [p, L], |
|
|
"margin-top": [p, L], |
|
|
"margin-right": [p, L], |
|
|
"margin-bottom": [p, L], |
|
|
"margin-left": [p, L], |
|
|
padding: [p, L], |
|
|
"padding-top": [p, L], |
|
|
"padding-right": [p, L], |
|
|
"padding-bottom": [p, L], |
|
|
"padding-left": [p, L], |
|
|
"outline-width": [p, L], |
|
|
opacity: [p, E], |
|
|
top: [p, Y], |
|
|
right: [p, Y], |
|
|
bottom: [p, Y], |
|
|
left: [p, Y], |
|
|
"font-size": [p, Y], |
|
|
"text-indent": [p, Y], |
|
|
"word-spacing": [p, Y], |
|
|
width: [p, Y], |
|
|
"min-width": [p, Y], |
|
|
"max-width": [p, Y], |
|
|
height: [p, Y], |
|
|
"min-height": [p, Y], |
|
|
"max-height": [p, Y], |
|
|
"line-height": [p, le], |
|
|
"scroll-top": [G, E, "scrollTop"], |
|
|
"scroll-left": [G, E, "scrollLeft"], |
|
|
}, |
|
|
ce = {}; |
|
|
w.transform && |
|
|
((k.transform = [V]), |
|
|
(ce = { |
|
|
x: [Y, "translateX"], |
|
|
y: [Y, "translateY"], |
|
|
rotate: [ue], |
|
|
rotateX: [ue], |
|
|
rotateY: [ue], |
|
|
scale: [E], |
|
|
scaleX: [E], |
|
|
scaleY: [E], |
|
|
skew: [ue], |
|
|
skewX: [ue], |
|
|
skewY: [ue], |
|
|
})), |
|
|
w.transform && |
|
|
w.backface && |
|
|
((ce.z = [Y, "translateZ"]), |
|
|
(ce.rotateZ = [ue]), |
|
|
(ce.scaleZ = [E]), |
|
|
(ce.perspective = [L])); |
|
|
var We = /ms/, |
|
|
Ce = /s|\./; |
|
|
return (t.tram = f); |
|
|
})(window.jQuery); |
|
|
}); |
|
|
var ot = pe((mn, it) => { |
|
|
var Yt = window.$, |
|
|
Gt = Ye() && Yt.tram; |
|
|
it.exports = (function() { |
|
|
var t = {}; |
|
|
t.VERSION = "1.6.0-Webflow"; |
|
|
var f = {}, |
|
|
h = Array.prototype, |
|
|
S = Object.prototype, |
|
|
R = Function.prototype, |
|
|
m = h.push, |
|
|
F = h.slice, |
|
|
_ = h.concat, |
|
|
H = S.toString, |
|
|
X = S.hasOwnProperty, |
|
|
te = h.forEach, |
|
|
z = h.map, |
|
|
Q = h.reduce, |
|
|
A = h.reduceRight, |
|
|
D = h.filter, |
|
|
j = h.every, |
|
|
Z = h.some, |
|
|
B = h.indexOf, |
|
|
M = h.lastIndexOf, |
|
|
E = Array.isArray, |
|
|
W = Object.keys, |
|
|
L = R.bind, |
|
|
Y = |
|
|
(t.each = |
|
|
t.forEach = |
|
|
function(o, c, d) { |
|
|
if (o == null) return o; |
|
|
if (te && o.forEach === te) o.forEach(c, d); |
|
|
else if (o.length === +o.length) { |
|
|
for (var w = 0, P = o.length; w < P; w++) |
|
|
if (c.call(d, o[w], w, o) === f) return; |
|
|
} else |
|
|
for (var q = t.keys(o), w = 0, P = q.length; w < P; w++) |
|
|
if (c.call(d, o[q[w]], q[w], o) === f) return; |
|
|
return o; |
|
|
}); |
|
|
(t.map = t.collect = |
|
|
function(o, c, d) { |
|
|
var w = []; |
|
|
return o == null ? |
|
|
w : |
|
|
z && o.map === z ? |
|
|
o.map(c, d) : |
|
|
(Y(o, function(P, q, l) { |
|
|
w.push(c.call(d, P, q, l)); |
|
|
}), |
|
|
w); |
|
|
}), |
|
|
(t.find = t.detect = |
|
|
function(o, c, d) { |
|
|
var w; |
|
|
return ( |
|
|
ue(o, function(P, q, l) { |
|
|
if (c.call(d, P, q, l)) return (w = P), !0; |
|
|
}), |
|
|
w |
|
|
); |
|
|
}), |
|
|
(t.filter = t.select = |
|
|
function(o, c, d) { |
|
|
var w = []; |
|
|
return o == null ? |
|
|
w : |
|
|
D && o.filter === D ? |
|
|
o.filter(c, d) : |
|
|
(Y(o, function(P, q, l) { |
|
|
c.call(d, P, q, l) && w.push(P); |
|
|
}), |
|
|
w); |
|
|
}); |
|
|
var ue = |
|
|
(t.some = |
|
|
t.any = |
|
|
function(o, c, d) { |
|
|
c || (c = t.identity); |
|
|
var w = !1; |
|
|
return o == null ? |
|
|
w : |
|
|
Z && o.some === Z ? |
|
|
o.some(c, d) : |
|
|
(Y(o, function(P, q, l) { |
|
|
if (w || (w = c.call(d, P, q, l))) return f; |
|
|
}), !!w); |
|
|
}); |
|
|
(t.contains = t.include = |
|
|
function(o, c) { |
|
|
return o == null ? |
|
|
!1 : |
|
|
B && o.indexOf === B ? |
|
|
o.indexOf(c) != -1 : |
|
|
ue(o, function(d) { |
|
|
return d === c; |
|
|
}); |
|
|
}), |
|
|
(t.delay = function(o, c) { |
|
|
var d = F.call(arguments, 2); |
|
|
return setTimeout(function() { |
|
|
return o.apply(null, d); |
|
|
}, c); |
|
|
}), |
|
|
(t.defer = function(o) { |
|
|
return t.delay.apply(t, [o, 1].concat(F.call(arguments, 1))); |
|
|
}), |
|
|
(t.throttle = function(o) { |
|
|
var c, d, w; |
|
|
return function() { |
|
|
c || |
|
|
((c = !0), |
|
|
(d = arguments), |
|
|
(w = this), |
|
|
Gt.frame(function() { |
|
|
(c = !1), o.apply(w, d); |
|
|
})); |
|
|
}; |
|
|
}), |
|
|
(t.debounce = function(o, c, d) { |
|
|
var w, |
|
|
P, |
|
|
q, |
|
|
l, |
|
|
x, |
|
|
T = function() { |
|
|
var g = t.now() - l; |
|
|
g < c ? |
|
|
(w = setTimeout(T, c - g)) : |
|
|
((w = null), d || ((x = o.apply(q, P)), (q = P = null))); |
|
|
}; |
|
|
return function() { |
|
|
(q = this), (P = arguments), (l = t.now()); |
|
|
var g = d && !w; |
|
|
return ( |
|
|
w || (w = setTimeout(T, c)), |
|
|
g && ((x = o.apply(q, P)), (q = P = null)), |
|
|
x |
|
|
); |
|
|
}; |
|
|
}), |
|
|
(t.defaults = function(o) { |
|
|
if (!t.isObject(o)) return o; |
|
|
for (var c = 1, d = arguments.length; c < d; c++) { |
|
|
var w = arguments[c]; |
|
|
for (var P in w) o[P] === void 0 && (o[P] = w[P]); |
|
|
} |
|
|
return o; |
|
|
}), |
|
|
(t.keys = function(o) { |
|
|
if (!t.isObject(o)) return []; |
|
|
if (W) return W(o); |
|
|
var c = []; |
|
|
for (var d in o) t.has(o, d) && c.push(d); |
|
|
return c; |
|
|
}), |
|
|
(t.has = function(o, c) { |
|
|
return X.call(o, c); |
|
|
}), |
|
|
(t.isObject = function(o) { |
|
|
return o === Object(o); |
|
|
}), |
|
|
(t.now = |
|
|
Date.now || |
|
|
function() { |
|
|
return new Date().getTime(); |
|
|
}), |
|
|
(t.templateSettings = { |
|
|
evaluate: /<%([\s\S]+?)%>/g, |
|
|
interpolate: /<%=([\s\S]+?)%>/g, |
|
|
escape: /<%-([\s\S]+?)%>/g, |
|
|
}); |
|
|
var le = /(.)^/, |
|
|
de = { |
|
|
"'": "'", |
|
|
"\\": "\\", |
|
|
"\r": "r", |
|
|
"\n": "n", |
|
|
"\u2028": "u2028", |
|
|
"\u2029": "u2029", |
|
|
}, |
|
|
ye = /\\|'|\r|\n|\u2028|\u2029/g, |
|
|
$ = function(o) { |
|
|
return "\\" + de[o]; |
|
|
}, |
|
|
v = /^\s*(\w|\$)+\s*$/; |
|
|
return ( |
|
|
(t.template = function(o, c, d) { |
|
|
!c && d && (c = d), (c = t.defaults({}, c, t.templateSettings)); |
|
|
var w = RegExp( |
|
|
[ |
|
|
(c.escape || le).source, |
|
|
(c.interpolate || le).source, |
|
|
(c.evaluate || le).source, |
|
|
].join("|") + "|$", |
|
|
"g" |
|
|
), |
|
|
P = 0, |
|
|
q = "__p+='"; |
|
|
o.replace(w, function(g, p, O, G, V) { |
|
|
return ( |
|
|
(q += o.slice(P, V).replace(ye, $)), |
|
|
(P = V + g.length), |
|
|
p ? |
|
|
(q += |
|
|
`'+ |
|
|
((__t=(` + |
|
|
p + |
|
|
`))==null?'':_.escape(__t))+ |
|
|
'`) : |
|
|
O ? |
|
|
(q += |
|
|
`'+ |
|
|
((__t=(` + |
|
|
O + |
|
|
`))==null?'':__t)+ |
|
|
'`) : |
|
|
G && |
|
|
(q += |
|
|
`'; |
|
|
` + |
|
|
G + |
|
|
` |
|
|
__p+='`), |
|
|
g |
|
|
); |
|
|
}), |
|
|
(q += `'; |
|
|
`); |
|
|
var l = c.variable; |
|
|
if (l) { |
|
|
if (!v.test(l)) |
|
|
throw new Error("variable is not a bare identifier: " + l); |
|
|
} else |
|
|
(q = |
|
|
`with(obj||{}){ |
|
|
` + |
|
|
q + |
|
|
`} |
|
|
`), |
|
|
(l = "obj"); |
|
|
q = |
|
|
`var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');}; |
|
|
` + |
|
|
q + |
|
|
`return __p; |
|
|
`; |
|
|
var x; |
|
|
try { |
|
|
x = new Function(c.variable || "obj", "_", q); |
|
|
} catch (g) { |
|
|
throw ((g.source = q), g); |
|
|
} |
|
|
var T = function(g) { |
|
|
return x.call(this, g, t); |
|
|
}; |
|
|
return ( |
|
|
(T.source = |
|
|
"function(" + |
|
|
l + |
|
|
`){ |
|
|
` + |
|
|
q + |
|
|
"}"), |
|
|
T |
|
|
); |
|
|
}), |
|
|
t |
|
|
); |
|
|
})(); |
|
|
}); |
|
|
var Ee = pe((gn, ht) => { |
|
|
var oe = {}, |
|
|
De = {}, |
|
|
Pe = [], |
|
|
je = window.Webflow || [], |
|
|
Ie = window.jQuery, |
|
|
Ae = Ie(window), |
|
|
jt = Ie(document), |
|
|
Le = Ie.isFunction, |
|
|
_e = (oe._ = ot()), |
|
|
st = (oe.tram = Ye() && Ie.tram), |
|
|
Ue = !1, |
|
|
Ze = !1; |
|
|
st.config.hideBackface = !1; |
|
|
st.config.keepInherited = !0; |
|
|
oe.define = function(t, f, h) { |
|
|
De[t] && ct(De[t]); |
|
|
var S = (De[t] = f(Ie, _e, h) || {}); |
|
|
return ut(S), S; |
|
|
}; |
|
|
oe.require = function(t) { |
|
|
return De[t]; |
|
|
}; |
|
|
|
|
|
function ut(t) { |
|
|
oe.env() && |
|
|
(Le(t.design) && Ae.on("__wf_design", t.design), |
|
|
Le(t.preview) && Ae.on("__wf_preview", t.preview)), |
|
|
Le(t.destroy) && Ae.on("__wf_destroy", t.destroy), |
|
|
t.ready && Le(t.ready) && Zt(t); |
|
|
} |
|
|
|
|
|
function Zt(t) { |
|
|
if (Ue) { |
|
|
t.ready(); |
|
|
return; |
|
|
} |
|
|
_e.contains(Pe, t.ready) || Pe.push(t.ready); |
|
|
} |
|
|
|
|
|
function ct(t) { |
|
|
Le(t.design) && Ae.off("__wf_design", t.design), |
|
|
Le(t.preview) && Ae.off("__wf_preview", t.preview), |
|
|
Le(t.destroy) && Ae.off("__wf_destroy", t.destroy), |
|
|
t.ready && Le(t.ready) && Qt(t); |
|
|
} |
|
|
|
|
|
function Qt(t) { |
|
|
Pe = _e.filter(Pe, function(f) { |
|
|
return f !== t.ready; |
|
|
}); |
|
|
} |
|
|
oe.push = function(t) { |
|
|
if (Ue) { |
|
|
Le(t) && t(); |
|
|
return; |
|
|
} |
|
|
je.push(t); |
|
|
}; |
|
|
oe.env = function(t) { |
|
|
var f = window.__wf_design, |
|
|
h = typeof f < "u"; |
|
|
if (!t) return h; |
|
|
if (t === "design") return h && f; |
|
|
if (t === "preview") return h && !f; |
|
|
if (t === "slug") return h && window.__wf_slug; |
|
|
if (t === "editor") return window.WebflowEditor; |
|
|
if (t === "test") return window.__wf_test; |
|
|
if (t === "frame") return window !== window.top; |
|
|
}; |
|
|
var He = navigator.userAgent.toLowerCase(), |
|
|
ft = (oe.env.touch = |
|
|
"ontouchstart" in window || |
|
|
(window.DocumentTouch && document instanceof window.DocumentTouch)), |
|
|
Jt = (oe.env.chrome = |
|
|
/chrome/.test(He) && |
|
|
/Google/.test(navigator.vendor) && |
|
|
parseInt(He.match(/chrome\/(\d+)\./)[1], 10)), |
|
|
en = (oe.env.ios = /(ipod|iphone|ipad)/.test(He)); |
|
|
oe.env.safari = /safari/.test(He) && !Jt && !en; |
|
|
var Ge; |
|
|
ft && |
|
|
jt.on("touchstart mousedown", function(t) { |
|
|
Ge = t.target; |
|
|
}); |
|
|
oe.validClick = ft ? |
|
|
|
|
|
function(t) { |
|
|
return t === Ge || Ie.contains(t, Ge); |
|
|
} : |
|
|
function() { |
|
|
return !0; |
|
|
}; |
|
|
var lt = "resize.webflow orientationchange.webflow load.webflow", |
|
|
tn = "scroll.webflow " + lt; |
|
|
oe.resize = Qe(Ae, lt); |
|
|
oe.scroll = Qe(Ae, tn); |
|
|
oe.redraw = Qe(); |
|
|
|
|
|
function Qe(t, f) { |
|
|
var h = [], |
|
|
S = {}; |
|
|
return ( |
|
|
(S.up = _e.throttle(function(R) { |
|
|
_e.each(h, function(m) { |
|
|
m(R); |
|
|
}); |
|
|
})), |
|
|
t && f && t.on(f, S.up), |
|
|
(S.on = function(R) { |
|
|
typeof R == "function" && (_e.contains(h, R) || h.push(R)); |
|
|
}), |
|
|
(S.off = function(R) { |
|
|
if (!arguments.length) { |
|
|
h = []; |
|
|
return; |
|
|
} |
|
|
h = _e.filter(h, function(m) { |
|
|
return m !== R; |
|
|
}); |
|
|
}), |
|
|
S |
|
|
); |
|
|
} |
|
|
oe.location = function(t) { |
|
|
window.location = t; |
|
|
}; |
|
|
oe.env() && (oe.location = function() {}); |
|
|
oe.ready = function() { |
|
|
(Ue = !0), Ze ? nn() : _e.each(Pe, at), _e.each(je, at), oe.resize.up(); |
|
|
}; |
|
|
|
|
|
function at(t) { |
|
|
Le(t) && t(); |
|
|
} |
|
|
|
|
|
function nn() { |
|
|
(Ze = !1), _e.each(De, ut); |
|
|
} |
|
|
var Re; |
|
|
oe.load = function(t) { |
|
|
Re.then(t); |
|
|
}; |
|
|
|
|
|
function dt() { |
|
|
Re && (Re.reject(), Ae.off("load", Re.resolve)), |
|
|
(Re = new Ie.Deferred()), |
|
|
Ae.on("load", Re.resolve); |
|
|
} |
|
|
oe.destroy = function(t) { |
|
|
(t = t || {}), |
|
|
(Ze = !0), |
|
|
Ae.triggerHandler("__wf_destroy"), |
|
|
t.domready != null && (Ue = t.domready), |
|
|
_e.each(De, ct), |
|
|
oe.resize.off(), |
|
|
oe.scroll.off(), |
|
|
oe.redraw.off(), |
|
|
(Pe = []), |
|
|
(je = []), |
|
|
Re.state() === "pending" && dt(); |
|
|
}; |
|
|
Ie(oe.ready); |
|
|
dt(); |
|
|
ht.exports = window.Webflow = oe; |
|
|
}); |
|
|
var pt = pe((wn, vt) => { |
|
|
var Be = Ee(); |
|
|
Be.define( |
|
|
"scroll", |
|
|
(vt.exports = function(t) { |
|
|
var f = { |
|
|
WF_CLICK_EMPTY: "click.wf-empty-link", |
|
|
WF_CLICK_SCROLL: "click.wf-scroll", |
|
|
}, |
|
|
h = window.location, |
|
|
S = D() ? null : window.history, |
|
|
R = t(window), |
|
|
m = t(document), |
|
|
F = t(document.body), |
|
|
_ = |
|
|
window.requestAnimationFrame || |
|
|
window.mozRequestAnimationFrame || |
|
|
window.webkitRequestAnimationFrame || |
|
|
function(v) { |
|
|
window.setTimeout(v, 15); |
|
|
}, |
|
|
H = Be.env("editor") ? ".w-editor-body" : "body", |
|
|
X = |
|
|
"header, " + |
|
|
H + |
|
|
" > .header, " + |
|
|
H + |
|
|
" > .w-nav:not([data-no-scroll])", |
|
|
te = 'a[href="#"]', |
|
|
z = 'a[href*="#"]:not(.w-tab-link):not(' + te + ")", |
|
|
Q = '.wf-force-outline-none[tabindex="-1"]:focus{outline:none;}', |
|
|
A = document.createElement("style"); |
|
|
A.appendChild(document.createTextNode(Q)); |
|
|
|
|
|
function D() { |
|
|
try { |
|
|
return !!window.frameElement; |
|
|
} catch { |
|
|
return !0; |
|
|
} |
|
|
} |
|
|
var j = /^#[a-zA-Z0-9][\w:.-]*$/; |
|
|
|
|
|
function Z(v) { |
|
|
return ( |
|
|
j.test(v.hash) && v.host + v.pathname === h.host + h.pathname |
|
|
); |
|
|
} |
|
|
let B = |
|
|
typeof window.matchMedia == "function" && |
|
|
window.matchMedia("(prefers-reduced-motion: reduce)"); |
|
|
|
|
|
function M() { |
|
|
return ( |
|
|
document.body.getAttribute("data-wf-scroll-motion") === "none" || |
|
|
B.matches |
|
|
); |
|
|
} |
|
|
|
|
|
function E(v, o) { |
|
|
var c; |
|
|
switch (o) { |
|
|
case "add": |
|
|
(c = v.attr("tabindex")), |
|
|
c |
|
|
? |
|
|
v.attr("data-wf-tabindex-swap", c) : |
|
|
v.attr("tabindex", "-1"); |
|
|
break; |
|
|
case "remove": |
|
|
(c = v.attr("data-wf-tabindex-swap")), |
|
|
c |
|
|
? |
|
|
(v.attr("tabindex", c), |
|
|
v.removeAttr("data-wf-tabindex-swap")) : |
|
|
v.removeAttr("tabindex"); |
|
|
break; |
|
|
} |
|
|
v.toggleClass("wf-force-outline-none", o === "add"); |
|
|
} |
|
|
|
|
|
function W(v) { |
|
|
var o = v.currentTarget; |
|
|
if (!( |
|
|
Be.env("design") || |
|
|
(window.$.mobile && /(?:^|\s)ui-link(?:$|\s)/.test(o.className)) |
|
|
)) { |
|
|
var c = Z(o) ? o.hash : ""; |
|
|
if (c !== "") { |
|
|
var d = t(c); |
|
|
d.length && |
|
|
(v && (v.preventDefault(), v.stopPropagation()), |
|
|
L(c, v), |
|
|
window.setTimeout( |
|
|
function() { |
|
|
Y(d, function() { |
|
|
E(d, "add"), |
|
|
d.get(0).focus({ preventScroll: !0 }), |
|
|
E(d, "remove"); |
|
|
}); |
|
|
}, |
|
|
v ? 0 : 300 |
|
|
)); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function L(v) { |
|
|
if ( |
|
|
h.hash !== v && |
|
|
S && |
|
|
S.pushState && |
|
|
!(Be.env.chrome && h.protocol === "file:") |
|
|
) { |
|
|
var o = S.state && S.state.hash; |
|
|
o !== v && S.pushState({ hash: v }, "", v); |
|
|
} |
|
|
} |
|
|
|
|
|
function Y(v, o) { |
|
|
var c = R.scrollTop(), |
|
|
d = ue(v); |
|
|
if (c !== d) { |
|
|
var w = le(v, c, d), |
|
|
P = Date.now(), |
|
|
q = function() { |
|
|
var l = Date.now() - P; |
|
|
window.scroll(0, de(c, d, l, w)), |
|
|
l <= w ? _(q) : typeof o == "function" && o(); |
|
|
}; |
|
|
_(q); |
|
|
} |
|
|
} |
|
|
|
|
|
function ue(v) { |
|
|
var o = t(X), |
|
|
c = o.css("position") === "fixed" ? o.outerHeight() : 0, |
|
|
d = v.offset().top - c; |
|
|
if (v.data("scroll") === "mid") { |
|
|
var w = R.height() - c, |
|
|
P = v.outerHeight(); |
|
|
P < w && (d -= Math.round((w - P) / 2)); |
|
|
} |
|
|
return d; |
|
|
} |
|
|
|
|
|
function le(v, o, c) { |
|
|
if (M()) return 0; |
|
|
var d = 1; |
|
|
return ( |
|
|
F.add(v).each(function(w, P) { |
|
|
var q = parseFloat(P.getAttribute("data-scroll-time")); |
|
|
!isNaN(q) && q >= 0 && (d = q); |
|
|
}), |
|
|
(472.143 * Math.log(Math.abs(o - c) + 125) - 2e3) * d |
|
|
); |
|
|
} |
|
|
|
|
|
function de(v, o, c, d) { |
|
|
return c > d ? o : v + (o - v) * ye(c / d); |
|
|
} |
|
|
|
|
|
function ye(v) { |
|
|
return v < 0.5 ? |
|
|
4 * v * v * v : |
|
|
(v - 1) * (2 * v - 2) * (2 * v - 2) + 1; |
|
|
} |
|
|
|
|
|
function $() { |
|
|
var { WF_CLICK_EMPTY: v, WF_CLICK_SCROLL: o } = f; |
|
|
m.on(o, z, W), |
|
|
m.on(v, te, function(c) { |
|
|
c.preventDefault(); |
|
|
}), |
|
|
document.head.insertBefore(A, document.head.firstChild); |
|
|
} |
|
|
return { ready: $ }; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var gt = pe((bn, mt) => { |
|
|
var rn = Ee(); |
|
|
rn.define( |
|
|
"touch", |
|
|
(mt.exports = function(t) { |
|
|
var f = {}, |
|
|
h = window.getSelection; |
|
|
(t.event.special.tap = { bindType: "click", delegateType: "click" }), |
|
|
(f.init = function(m) { |
|
|
return ( |
|
|
(m = typeof m == "string" ? t(m).get(0) : m), |
|
|
m ? new S(m) : null |
|
|
); |
|
|
}); |
|
|
|
|
|
function S(m) { |
|
|
var F = !1, |
|
|
_ = !1, |
|
|
H = Math.min(Math.round(window.innerWidth * 0.04), 40), |
|
|
X, |
|
|
te; |
|
|
m.addEventListener("touchstart", z, !1), |
|
|
m.addEventListener("touchmove", Q, !1), |
|
|
m.addEventListener("touchend", A, !1), |
|
|
m.addEventListener("touchcancel", D, !1), |
|
|
m.addEventListener("mousedown", z, !1), |
|
|
m.addEventListener("mousemove", Q, !1), |
|
|
m.addEventListener("mouseup", A, !1), |
|
|
m.addEventListener("mouseout", D, !1); |
|
|
|
|
|
function z(Z) { |
|
|
var B = Z.touches; |
|
|
(B && B.length > 1) || |
|
|
((F = !0), |
|
|
B ? ((_ = !0), (X = B[0].clientX)) : (X = Z.clientX), |
|
|
(te = X)); |
|
|
} |
|
|
|
|
|
function Q(Z) { |
|
|
if (F) { |
|
|
if (_ && Z.type === "mousemove") { |
|
|
Z.preventDefault(), Z.stopPropagation(); |
|
|
return; |
|
|
} |
|
|
var B = Z.touches, |
|
|
M = B ? B[0].clientX : Z.clientX, |
|
|
E = M - te; |
|
|
(te = M), |
|
|
Math.abs(E) > H && |
|
|
h && |
|
|
String(h()) === "" && |
|
|
(R("swipe", Z, { direction: E > 0 ? "right" : "left" }), |
|
|
D()); |
|
|
} |
|
|
} |
|
|
|
|
|
function A(Z) { |
|
|
if (F && ((F = !1), _ && Z.type === "mouseup")) { |
|
|
Z.preventDefault(), Z.stopPropagation(), (_ = !1); |
|
|
return; |
|
|
} |
|
|
} |
|
|
|
|
|
function D() { |
|
|
F = !1; |
|
|
} |
|
|
|
|
|
function j() { |
|
|
m.removeEventListener("touchstart", z, !1), |
|
|
m.removeEventListener("touchmove", Q, !1), |
|
|
m.removeEventListener("touchend", A, !1), |
|
|
m.removeEventListener("touchcancel", D, !1), |
|
|
m.removeEventListener("mousedown", z, !1), |
|
|
m.removeEventListener("mousemove", Q, !1), |
|
|
m.removeEventListener("mouseup", A, !1), |
|
|
m.removeEventListener("mouseout", D, !1), |
|
|
(m = null); |
|
|
} |
|
|
this.destroy = j; |
|
|
} |
|
|
|
|
|
function R(m, F, _) { |
|
|
var H = t.Event(m, { originalEvent: F }); |
|
|
t(F.target).trigger(H, _); |
|
|
} |
|
|
return (f.instance = f.init(document)), f; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var bt = pe((yn, wt) => { |
|
|
var Je = Ee(); |
|
|
Je.define( |
|
|
"edit", |
|
|
(wt.exports = function(t, f, h) { |
|
|
if ( |
|
|
((h = h || {}), |
|
|
(Je.env("test") || Je.env("frame")) && !h.fixture && !on()) |
|
|
) |
|
|
return { exit: 1 }; |
|
|
var S = {}, |
|
|
R = t(window), |
|
|
m = t(document.documentElement), |
|
|
F = document.location, |
|
|
_ = "hashchange", |
|
|
H, |
|
|
X = h.load || Q, |
|
|
te = !1; |
|
|
try { |
|
|
te = |
|
|
localStorage && |
|
|
localStorage.getItem && |
|
|
localStorage.getItem("WebflowEditor"); |
|
|
} catch {} |
|
|
te |
|
|
? |
|
|
X() : |
|
|
F.search ? |
|
|
(/[?&](edit)(?:[=&?]|$)/.test(F.search) || |
|
|
/\?edit$/.test(F.href)) && |
|
|
X() : |
|
|
R.on(_, z).triggerHandler(_); |
|
|
|
|
|
function z() { |
|
|
H || (/\?edit/.test(F.hash) && X()); |
|
|
} |
|
|
|
|
|
function Q() { |
|
|
(H = !0), |
|
|
(window.WebflowEditor = !0), |
|
|
R.off(_, z), |
|
|
M(function(W) { |
|
|
t.ajax({ |
|
|
url: B("https://editor-api.webflow.com/api/editor/view"), |
|
|
data: { siteId: m.attr("data-wf-site") }, |
|
|
xhrFields: { withCredentials: !0 }, |
|
|
dataType: "json", |
|
|
crossDomain: !0, |
|
|
success: A(W), |
|
|
}); |
|
|
}); |
|
|
} |
|
|
|
|
|
function A(W) { |
|
|
return function(L) { |
|
|
if (!L) { |
|
|
console.error("Could not load editor data"); |
|
|
return; |
|
|
} |
|
|
(L.thirdPartyCookiesSupported = W), |
|
|
D(Z(L.bugReporterScriptPath), function() { |
|
|
D(Z(L.scriptPath), function() { |
|
|
window.WebflowEditor(L); |
|
|
}); |
|
|
}); |
|
|
}; |
|
|
} |
|
|
|
|
|
function D(W, L) { |
|
|
t.ajax({ type: "GET", url: W, dataType: "script", cache: !0 }).then( |
|
|
L, |
|
|
j |
|
|
); |
|
|
} |
|
|
|
|
|
function j(W, L, Y) { |
|
|
throw (console.error("Could not load editor script: " + L), Y); |
|
|
} |
|
|
|
|
|
function Z(W) { |
|
|
return W.indexOf("//") >= 0 ? |
|
|
W : |
|
|
B("https://editor-api.webflow.com" + W); |
|
|
} |
|
|
|
|
|
function B(W) { |
|
|
return W.replace(/([^:])\/\//g, "$1/"); |
|
|
} |
|
|
|
|
|
function M(W) { |
|
|
var L = window.document.createElement("iframe"); |
|
|
(L.src = "https://webflow.com/site/third-party-cookie-check.html"), |
|
|
(L.style.display = "none"), |
|
|
(L.sandbox = "allow-scripts allow-same-origin"); |
|
|
var Y = function(ue) { |
|
|
ue.data === "WF_third_party_cookies_unsupported" ? |
|
|
(E(L, Y), W(!1)) : |
|
|
ue.data === "WF_third_party_cookies_supported" && |
|
|
(E(L, Y), W(!0)); |
|
|
}; |
|
|
(L.onerror = function() { |
|
|
E(L, Y), W(!1); |
|
|
}), |
|
|
window.addEventListener("message", Y, !1), |
|
|
window.document.body.appendChild(L); |
|
|
} |
|
|
|
|
|
function E(W, L) { |
|
|
window.removeEventListener("message", L, !1), W.remove(); |
|
|
} |
|
|
return S; |
|
|
}) |
|
|
); |
|
|
|
|
|
function on() { |
|
|
try { |
|
|
return window.top.__Cypress__; |
|
|
} catch { |
|
|
return !1; |
|
|
} |
|
|
} |
|
|
}); |
|
|
var Et = pe((En, yt) => { |
|
|
var an = Ee(); |
|
|
an.define( |
|
|
"focus-visible", |
|
|
(yt.exports = function() { |
|
|
function t(h) { |
|
|
var S = !0, |
|
|
R = !1, |
|
|
m = null, |
|
|
F = { |
|
|
text: !0, |
|
|
search: !0, |
|
|
url: !0, |
|
|
tel: !0, |
|
|
email: !0, |
|
|
password: !0, |
|
|
number: !0, |
|
|
date: !0, |
|
|
month: !0, |
|
|
week: !0, |
|
|
time: !0, |
|
|
datetime: !0, |
|
|
"datetime-local": !0, |
|
|
}; |
|
|
|
|
|
function _(E) { |
|
|
return !!( |
|
|
E && |
|
|
E !== document && |
|
|
E.nodeName !== "HTML" && |
|
|
E.nodeName !== "BODY" && |
|
|
"classList" in E && |
|
|
"contains" in E.classList |
|
|
); |
|
|
} |
|
|
|
|
|
function H(E) { |
|
|
var W = E.type, |
|
|
L = E.tagName; |
|
|
return !!( |
|
|
(L === "INPUT" && F[W] && !E.readOnly) || |
|
|
(L === "TEXTAREA" && !E.readOnly) || |
|
|
E.isContentEditable |
|
|
); |
|
|
} |
|
|
|
|
|
function X(E) { |
|
|
E.getAttribute("data-wf-focus-visible") || |
|
|
E.setAttribute("data-wf-focus-visible", "true"); |
|
|
} |
|
|
|
|
|
function te(E) { |
|
|
E.getAttribute("data-wf-focus-visible") && |
|
|
E.removeAttribute("data-wf-focus-visible"); |
|
|
} |
|
|
|
|
|
function z(E) { |
|
|
E.metaKey || |
|
|
E.altKey || |
|
|
E.ctrlKey || |
|
|
(_(h.activeElement) && X(h.activeElement), (S = !0)); |
|
|
} |
|
|
|
|
|
function Q() { |
|
|
S = !1; |
|
|
} |
|
|
|
|
|
function A(E) { |
|
|
_(E.target) && (S || H(E.target)) && X(E.target); |
|
|
} |
|
|
|
|
|
function D(E) { |
|
|
_(E.target) && |
|
|
E.target.hasAttribute("data-wf-focus-visible") && |
|
|
((R = !0), |
|
|
window.clearTimeout(m), |
|
|
(m = window.setTimeout(function() { |
|
|
R = !1; |
|
|
}, 100)), |
|
|
te(E.target)); |
|
|
} |
|
|
|
|
|
function j() { |
|
|
document.visibilityState === "hidden" && (R && (S = !0), Z()); |
|
|
} |
|
|
|
|
|
function Z() { |
|
|
document.addEventListener("mousemove", M), |
|
|
document.addEventListener("mousedown", M), |
|
|
document.addEventListener("mouseup", M), |
|
|
document.addEventListener("pointermove", M), |
|
|
document.addEventListener("pointerdown", M), |
|
|
document.addEventListener("pointerup", M), |
|
|
document.addEventListener("touchmove", M), |
|
|
document.addEventListener("touchstart", M), |
|
|
document.addEventListener("touchend", M); |
|
|
} |
|
|
|
|
|
function B() { |
|
|
document.removeEventListener("mousemove", M), |
|
|
document.removeEventListener("mousedown", M), |
|
|
document.removeEventListener("mouseup", M), |
|
|
document.removeEventListener("pointermove", M), |
|
|
document.removeEventListener("pointerdown", M), |
|
|
document.removeEventListener("pointerup", M), |
|
|
document.removeEventListener("touchmove", M), |
|
|
document.removeEventListener("touchstart", M), |
|
|
document.removeEventListener("touchend", M); |
|
|
} |
|
|
|
|
|
function M(E) { |
|
|
(E.target.nodeName && |
|
|
E.target.nodeName.toLowerCase() === "html") || |
|
|
((S = !1), B()); |
|
|
} |
|
|
document.addEventListener("keydown", z, !0), |
|
|
document.addEventListener("mousedown", Q, !0), |
|
|
document.addEventListener("pointerdown", Q, !0), |
|
|
document.addEventListener("touchstart", Q, !0), |
|
|
document.addEventListener("visibilitychange", j, !0), |
|
|
Z(), |
|
|
h.addEventListener("focus", A, !0), |
|
|
h.addEventListener("blur", D, !0); |
|
|
} |
|
|
|
|
|
function f() { |
|
|
if (typeof document < "u") |
|
|
try { |
|
|
document.querySelector(":focus-visible"); |
|
|
} catch { |
|
|
t(document); |
|
|
} |
|
|
} |
|
|
return { ready: f }; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var kt = pe((xn, xt) => { |
|
|
var qe = Ee(); |
|
|
qe.define( |
|
|
"links", |
|
|
(xt.exports = function(t, f) { |
|
|
var h = {}, |
|
|
S = t(window), |
|
|
R, |
|
|
m = qe.env(), |
|
|
F = window.location, |
|
|
_ = document.createElement("a"), |
|
|
H = "w--current", |
|
|
X = /index\.(html|php)$/, |
|
|
te = /\/$/, |
|
|
z, |
|
|
Q; |
|
|
h.ready = h.design = h.preview = A; |
|
|
|
|
|
function A() { |
|
|
(R = m && qe.env("design")), |
|
|
(Q = qe.env("slug") || F.pathname || ""), |
|
|
qe.scroll.off(j), |
|
|
(z = []); |
|
|
for (var B = document.links, M = 0; M < B.length; ++M) D(B[M]); |
|
|
z.length && (qe.scroll.on(j), j()); |
|
|
} |
|
|
|
|
|
function D(B) { |
|
|
var M = |
|
|
(R && B.getAttribute("href-disabled")) || B.getAttribute("href"); |
|
|
if (((_.href = M), !(M.indexOf(":") >= 0))) { |
|
|
var E = t(B); |
|
|
if ( |
|
|
_.hash.length > 1 && |
|
|
_.host + _.pathname === F.host + F.pathname |
|
|
) { |
|
|
if (!/^#[a-zA-Z0-9\-\_]+$/.test(_.hash)) return; |
|
|
var W = t(_.hash); |
|
|
W.length && z.push({ link: E, sec: W, active: !1 }); |
|
|
return; |
|
|
} |
|
|
if (!(M === "#" || M === "")) { |
|
|
var L = |
|
|
_.href === F.href || M === Q || (X.test(M) && te.test(Q)); |
|
|
Z(E, H, L); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function j() { |
|
|
var B = S.scrollTop(), |
|
|
M = S.height(); |
|
|
f.each(z, function(E) { |
|
|
var W = E.link, |
|
|
L = E.sec, |
|
|
Y = L.offset().top, |
|
|
ue = L.outerHeight(), |
|
|
le = M * 0.5, |
|
|
de = L.is(":visible") && Y + ue - le >= B && Y + le <= B + M; |
|
|
E.active !== de && ((E.active = de), Z(W, H, de)); |
|
|
}); |
|
|
} |
|
|
|
|
|
function Z(B, M, E) { |
|
|
var W = B.hasClass(M); |
|
|
(E && W) || (!E && !W) || (E ? B.addClass(M) : B.removeClass(M)); |
|
|
} |
|
|
return h; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var Ot = pe((kn, At) => { |
|
|
var _t = Ee(); |
|
|
_t.define( |
|
|
"focus", |
|
|
(At.exports = function() { |
|
|
var t = [], |
|
|
f = !1; |
|
|
|
|
|
function h(F) { |
|
|
f && |
|
|
(F.preventDefault(), |
|
|
F.stopPropagation(), |
|
|
F.stopImmediatePropagation(), |
|
|
t.unshift(F)); |
|
|
} |
|
|
|
|
|
function S(F) { |
|
|
var _ = F.target, |
|
|
H = _.tagName; |
|
|
return ( |
|
|
(/^a$/i.test(H) && _.href != null) || |
|
|
(/^(button|textarea)$/i.test(H) && _.disabled !== !0) || |
|
|
(/^input$/i.test(H) && |
|
|
/^(button|reset|submit|radio|checkbox)$/i.test(_.type) && |
|
|
!_.disabled) || |
|
|
(!/^(button|input|textarea|select|a)$/i.test(H) && |
|
|
!Number.isNaN(Number.parseFloat(_.tabIndex))) || |
|
|
/^audio$/i.test(H) || |
|
|
(/^video$/i.test(H) && _.controls === !0) |
|
|
); |
|
|
} |
|
|
|
|
|
function R(F) { |
|
|
S(F) && |
|
|
((f = !0), |
|
|
setTimeout(() => { |
|
|
for (f = !1, F.target.focus(); t.length > 0;) { |
|
|
var _ = t.pop(); |
|
|
_.target.dispatchEvent(new MouseEvent(_.type, _)); |
|
|
} |
|
|
}, 0)); |
|
|
} |
|
|
|
|
|
function m() { |
|
|
typeof document < "u" && |
|
|
document.body.hasAttribute("data-wf-focus-within") && |
|
|
_t.env.safari && |
|
|
(document.addEventListener("mousedown", R, !0), |
|
|
document.addEventListener("mouseup", h, !0), |
|
|
document.addEventListener("click", h, !0)); |
|
|
} |
|
|
return { ready: m }; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var St = pe((_n, Lt) => { |
|
|
var sn = Ee(); |
|
|
sn.define( |
|
|
"focus-within", |
|
|
(Lt.exports = function() { |
|
|
function t(m) { |
|
|
for ( |
|
|
var F = [m], _ = null; |
|
|
(_ = m.parentNode || m.host || m.defaultView); |
|
|
|
|
|
) |
|
|
F.push(_), (m = _); |
|
|
return F; |
|
|
} |
|
|
|
|
|
function f(m) { |
|
|
typeof m.getAttribute != "function" || |
|
|
m.getAttribute("data-wf-focus-within") || |
|
|
m.setAttribute("data-wf-focus-within", "true"); |
|
|
} |
|
|
|
|
|
function h(m) { |
|
|
typeof m.getAttribute != "function" || |
|
|
!m.getAttribute("data-wf-focus-within") || |
|
|
m.removeAttribute("data-wf-focus-within"); |
|
|
} |
|
|
|
|
|
function S() { |
|
|
var m = function(F) { |
|
|
var _; |
|
|
|
|
|
function H() { |
|
|
(_ = !1), |
|
|
F.type === "blur" && |
|
|
Array.prototype.slice.call(t(F.target)).forEach(h), |
|
|
F.type === "focus" && |
|
|
Array.prototype.slice.call(t(F.target)).forEach(f); |
|
|
} |
|
|
_ || (window.requestAnimationFrame(H), (_ = !0)); |
|
|
}; |
|
|
return ( |
|
|
document.addEventListener("focus", m, !0), |
|
|
document.addEventListener("blur", m, !0), |
|
|
f(document.body), !0 |
|
|
); |
|
|
} |
|
|
|
|
|
function R() { |
|
|
if ( |
|
|
typeof document < "u" && |
|
|
document.body.hasAttribute("data-wf-focus-within") |
|
|
) |
|
|
try { |
|
|
document.querySelector(":focus-within"); |
|
|
} catch { |
|
|
S(); |
|
|
} |
|
|
} |
|
|
return { ready: R }; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var It = pe((An, Ct) => { |
|
|
var Tt = Ee(); |
|
|
Tt.define( |
|
|
"brand", |
|
|
(Ct.exports = function(t) { |
|
|
var f = {}, |
|
|
h = document, |
|
|
S = t("html"), |
|
|
R = t("body"), |
|
|
m = ".w-webflow-badge", |
|
|
F = window.location, |
|
|
_ = /PhantomJS/i.test(navigator.userAgent), |
|
|
H = |
|
|
"fullscreenchange webkitfullscreenchange mozfullscreenchange msfullscreenchange", |
|
|
X; |
|
|
f.ready = function() { |
|
|
var A = S.attr("data-wf-status"), |
|
|
D = S.attr("data-wf-domain") || ""; |
|
|
/\.webflow\.io$/i.test(D) && F.hostname !== D && (A = !0), |
|
|
A && |
|
|
!_ && |
|
|
((X = X || z()), |
|
|
Q(), |
|
|
setTimeout(Q, 500), |
|
|
t(h).off(H, te).on(H, te)); |
|
|
}; |
|
|
|
|
|
function te() { |
|
|
var A = |
|
|
h.fullScreen || |
|
|
h.mozFullScreen || |
|
|
h.webkitIsFullScreen || |
|
|
h.msFullscreenElement || |
|
|
!!h.webkitFullscreenElement; |
|
|
t(X).attr("style", A ? "display: none !important;" : ""); |
|
|
} |
|
|
|
|
|
function Q() { |
|
|
var A = R.children(m), |
|
|
D = A.length && A.get(0) === X, |
|
|
j = Tt.env("editor"); |
|
|
if (D) { |
|
|
j && A.remove(); |
|
|
return; |
|
|
} |
|
|
A.length && A.remove(), j || R.append(X); |
|
|
} |
|
|
return f; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var Wt = pe((On, Mt) => { |
|
|
"use strict"; |
|
|
var et = window.jQuery, |
|
|
Se = {}, |
|
|
$e = [], |
|
|
Ft = ".w-ix", |
|
|
Xe = { |
|
|
reset: function(t, f) { |
|
|
f.__wf_intro = null; |
|
|
}, |
|
|
intro: function(t, f) { |
|
|
f.__wf_intro || |
|
|
((f.__wf_intro = !0), et(f).triggerHandler(Se.types.INTRO)); |
|
|
}, |
|
|
outro: function(t, f) { |
|
|
f.__wf_intro && |
|
|
((f.__wf_intro = null), et(f).triggerHandler(Se.types.OUTRO)); |
|
|
}, |
|
|
}; |
|
|
Se.triggers = {}; |
|
|
Se.types = { INTRO: "w-ix-intro" + Ft, OUTRO: "w-ix-outro" + Ft }; |
|
|
Se.init = function() { |
|
|
for (var t = $e.length, f = 0; f < t; f++) { |
|
|
var h = $e[f]; |
|
|
h[0](0, h[1]); |
|
|
} |
|
|
($e = []), et.extend(Se.triggers, Xe); |
|
|
}; |
|
|
Se.async = function() { |
|
|
for (var t in Xe) { |
|
|
var f = Xe[t]; |
|
|
Xe.hasOwnProperty(t) && |
|
|
(Se.triggers[t] = function(h, S) { |
|
|
$e.push([f, S]); |
|
|
}); |
|
|
} |
|
|
}; |
|
|
Se.async(); |
|
|
Mt.exports = Se; |
|
|
}); |
|
|
var nt = pe((Ln, Pt) => { |
|
|
"use strict"; |
|
|
var tt = Wt(); |
|
|
|
|
|
function Rt(t, f) { |
|
|
var h = document.createEvent("CustomEvent"); |
|
|
h.initCustomEvent(f, !0, !0, null), t.dispatchEvent(h); |
|
|
} |
|
|
var un = window.jQuery, |
|
|
Ke = {}, |
|
|
Dt = ".w-ix", |
|
|
cn = { |
|
|
reset: function(t, f) { |
|
|
tt.triggers.reset(t, f); |
|
|
}, |
|
|
intro: function(t, f) { |
|
|
tt.triggers.intro(t, f), Rt(f, "COMPONENT_ACTIVE"); |
|
|
}, |
|
|
outro: function(t, f) { |
|
|
tt.triggers.outro(t, f), Rt(f, "COMPONENT_INACTIVE"); |
|
|
}, |
|
|
}; |
|
|
Ke.triggers = {}; |
|
|
Ke.types = { INTRO: "w-ix-intro" + Dt, OUTRO: "w-ix-outro" + Dt }; |
|
|
un.extend(Ke.triggers, cn); |
|
|
Pt.exports = Ke; |
|
|
}); |
|
|
var Nt = pe((Sn, qt) => { |
|
|
var Fe = Ee(), |
|
|
fn = nt(); |
|
|
Fe.define( |
|
|
"tabs", |
|
|
(qt.exports = function(t) { |
|
|
var f = {}, |
|
|
h = t.tram, |
|
|
S = t(document), |
|
|
R, |
|
|
m, |
|
|
F = Fe.env, |
|
|
_ = F.safari, |
|
|
H = F(), |
|
|
X = "data-w-tab", |
|
|
te = "data-w-pane", |
|
|
z = ".w-tabs", |
|
|
Q = "w--current", |
|
|
A = "w--tab-active", |
|
|
D = fn.triggers, |
|
|
j = !1; |
|
|
(f.ready = f.design = f.preview = Z), |
|
|
(f.redraw = function() { |
|
|
(j = !0), Z(), (j = !1); |
|
|
}), |
|
|
(f.destroy = function() { |
|
|
(R = S.find(z)), R.length && (R.each(E), B()); |
|
|
}); |
|
|
|
|
|
function Z() { |
|
|
(m = H && Fe.env("design")), |
|
|
(R = S.find(z)), |
|
|
R.length && |
|
|
(R.each(W), Fe.env("preview") && !j && R.each(E), B(), M()); |
|
|
} |
|
|
|
|
|
function B() { |
|
|
Fe.redraw.off(f.redraw); |
|
|
} |
|
|
|
|
|
function M() { |
|
|
Fe.redraw.on(f.redraw); |
|
|
} |
|
|
|
|
|
function E($, v) { |
|
|
var o = t.data(v, z); |
|
|
o && |
|
|
(o.links && o.links.each(D.reset), |
|
|
o.panes && o.panes.each(D.reset)); |
|
|
} |
|
|
|
|
|
function W($, v) { |
|
|
var o = z.substr(1) + "-" + $, |
|
|
c = t(v), |
|
|
d = t.data(v, z); |
|
|
if ( |
|
|
(d || (d = t.data(v, z, { el: c, config: {} })), |
|
|
(d.current = null), |
|
|
(d.tabIdentifier = o + "-" + X), |
|
|
(d.paneIdentifier = o + "-" + te), |
|
|
(d.menu = c.children(".w-tab-menu")), |
|
|
(d.links = d.menu.children(".w-tab-link")), |
|
|
(d.content = c.children(".w-tab-content")), |
|
|
(d.panes = d.content.children(".w-tab-pane")), |
|
|
d.el.off(z), |
|
|
d.links.off(z), |
|
|
d.menu.attr("role", "tablist"), |
|
|
d.links.attr("tabindex", "-1"), |
|
|
L(d), !m) |
|
|
) { |
|
|
d.links.on("click" + z, ue(d)), d.links.on("keydown" + z, le(d)); |
|
|
var w = d.links.filter("." + Q), |
|
|
P = w.attr(X); |
|
|
P && de(d, { tab: P, immediate: !0 }); |
|
|
} |
|
|
} |
|
|
|
|
|
function L($) { |
|
|
var v = {}; |
|
|
v.easing = $.el.attr("data-easing") || "ease"; |
|
|
var o = parseInt($.el.attr("data-duration-in"), 10); |
|
|
o = v.intro = o === o ? o : 0; |
|
|
var c = parseInt($.el.attr("data-duration-out"), 10); |
|
|
(c = v.outro = c === c ? c : 0), |
|
|
(v.immediate = !o && !c), |
|
|
($.config = v); |
|
|
} |
|
|
|
|
|
function Y($) { |
|
|
var v = $.current; |
|
|
return Array.prototype.findIndex.call( |
|
|
$.links, |
|
|
(o) => o.getAttribute(X) === v, |
|
|
null |
|
|
); |
|
|
} |
|
|
|
|
|
function ue($) { |
|
|
return function(v) { |
|
|
v.preventDefault(); |
|
|
var o = v.currentTarget.getAttribute(X); |
|
|
o && de($, { tab: o }); |
|
|
}; |
|
|
} |
|
|
|
|
|
function le($) { |
|
|
return function(v) { |
|
|
var o = Y($), |
|
|
c = v.key, |
|
|
d = { |
|
|
ArrowLeft: o - 1, |
|
|
ArrowUp: o - 1, |
|
|
ArrowRight: o + 1, |
|
|
ArrowDown: o + 1, |
|
|
End: $.links.length - 1, |
|
|
Home: 0, |
|
|
}; |
|
|
if (c in d) { |
|
|
v.preventDefault(); |
|
|
var w = d[c]; |
|
|
w === -1 && (w = $.links.length - 1), |
|
|
w === $.links.length && (w = 0); |
|
|
var P = $.links[w], |
|
|
q = P.getAttribute(X); |
|
|
q && de($, { tab: q }); |
|
|
} |
|
|
}; |
|
|
} |
|
|
|
|
|
function de($, v) { |
|
|
v = v || {}; |
|
|
var o = $.config, |
|
|
c = o.easing, |
|
|
d = v.tab; |
|
|
if (d !== $.current) { |
|
|
$.current = d; |
|
|
var w; |
|
|
$.links.each(function(p, O) { |
|
|
var G = t(O); |
|
|
if (v.immediate || o.immediate) { |
|
|
var V = $.panes[p]; |
|
|
O.id || (O.id = $.tabIdentifier + "-" + p), |
|
|
V.id || (V.id = $.paneIdentifier + "-" + p), |
|
|
(O.href = "#" + V.id), |
|
|
O.setAttribute("role", "tab"), |
|
|
O.setAttribute("aria-controls", V.id), |
|
|
O.setAttribute("aria-selected", "false"), |
|
|
V.setAttribute("role", "tabpanel"), |
|
|
V.setAttribute("aria-labelledby", O.id); |
|
|
} |
|
|
O.getAttribute(X) === d ? |
|
|
((w = O), |
|
|
G.addClass(Q) |
|
|
.removeAttr("tabindex") |
|
|
.attr({ "aria-selected": "true" }) |
|
|
.each(D.intro)) : |
|
|
G.hasClass(Q) && |
|
|
G.removeClass(Q) |
|
|
.attr({ tabindex: "-1", "aria-selected": "false" }) |
|
|
.each(D.outro); |
|
|
}); |
|
|
var P = [], |
|
|
q = []; |
|
|
$.panes.each(function(p, O) { |
|
|
var G = t(O); |
|
|
O.getAttribute(X) === d ? |
|
|
P.push(O) : |
|
|
G.hasClass(A) && q.push(O); |
|
|
}); |
|
|
var l = t(P), |
|
|
x = t(q); |
|
|
if (v.immediate || o.immediate) { |
|
|
l.addClass(A).each(D.intro), |
|
|
x.removeClass(A), |
|
|
j || Fe.redraw.up(); |
|
|
return; |
|
|
} else { |
|
|
var T = window.scrollX, |
|
|
g = window.scrollY; |
|
|
w.focus(), window.scrollTo(T, g); |
|
|
} |
|
|
x.length && o.outro ? |
|
|
(x.each(D.outro), |
|
|
h(x) |
|
|
.add("opacity " + o.outro + "ms " + c, { fallback: _ }) |
|
|
.start({ opacity: 0 }) |
|
|
.then(() => ye(o, x, l))) : |
|
|
ye(o, x, l); |
|
|
} |
|
|
} |
|
|
|
|
|
function ye($, v, o) { |
|
|
if ( |
|
|
(v |
|
|
.removeClass(A) |
|
|
.css({ |
|
|
opacity: "", |
|
|
transition: "", |
|
|
transform: "", |
|
|
width: "", |
|
|
height: "", |
|
|
}), |
|
|
o.addClass(A).each(D.intro), |
|
|
Fe.redraw.up(), !$.intro) |
|
|
) |
|
|
return h(o).set({ opacity: 1 }); |
|
|
h(o) |
|
|
.set({ opacity: 0 }) |
|
|
.redraw() |
|
|
.add("opacity " + $.intro + "ms " + $.easing, { fallback: _ }) |
|
|
.start({ opacity: 1 }); |
|
|
} |
|
|
return f; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var Ht = pe((Tn, zt) => { |
|
|
var Me = Ee(), |
|
|
ln = nt(), |
|
|
me = { |
|
|
ARROW_LEFT: 37, |
|
|
ARROW_UP: 38, |
|
|
ARROW_RIGHT: 39, |
|
|
ARROW_DOWN: 40, |
|
|
ESCAPE: 27, |
|
|
SPACE: 32, |
|
|
ENTER: 13, |
|
|
HOME: 36, |
|
|
END: 35, |
|
|
}; |
|
|
Me.define( |
|
|
"navbar", |
|
|
(zt.exports = function(t, f) { |
|
|
var h = {}, |
|
|
S = t.tram, |
|
|
R = t(window), |
|
|
m = t(document), |
|
|
F = f.debounce, |
|
|
_, |
|
|
H, |
|
|
X, |
|
|
te, |
|
|
z = Me.env(), |
|
|
Q = '<div class="w-nav-overlay" data-wf-ignore />', |
|
|
A = ".w-nav", |
|
|
D = "w--open", |
|
|
j = "w--nav-dropdown-open", |
|
|
Z = "w--nav-dropdown-toggle-open", |
|
|
B = "w--nav-dropdown-list-open", |
|
|
M = "w--nav-link-open", |
|
|
E = ln.triggers, |
|
|
W = t(); |
|
|
(h.ready = h.design = h.preview = L), |
|
|
(h.destroy = function() { |
|
|
(W = t()), Y(), H && H.length && H.each(ye); |
|
|
}); |
|
|
|
|
|
function L() { |
|
|
(X = z && Me.env("design")), |
|
|
(te = Me.env("editor")), |
|
|
(_ = t(document.body)), |
|
|
(H = m.find(A)), |
|
|
H.length && (H.each(de), Y(), ue()); |
|
|
} |
|
|
|
|
|
function Y() { |
|
|
Me.resize.off(le); |
|
|
} |
|
|
|
|
|
function ue() { |
|
|
Me.resize.on(le); |
|
|
} |
|
|
|
|
|
function le() { |
|
|
H.each(p); |
|
|
} |
|
|
|
|
|
function de(n, b) { |
|
|
var C = t(b), |
|
|
k = t.data(b, A); |
|
|
k || |
|
|
(k = t.data(b, A, { |
|
|
open: !1, |
|
|
el: C, |
|
|
config: {}, |
|
|
selectedIdx: -1, |
|
|
})), |
|
|
(k.menu = C.find(".w-nav-menu")), |
|
|
(k.links = k.menu.find(".w-nav-link")), |
|
|
(k.dropdowns = k.menu.find(".w-dropdown")), |
|
|
(k.dropdownToggle = k.menu.find(".w-dropdown-toggle")), |
|
|
(k.dropdownList = k.menu.find(".w-dropdown-list")), |
|
|
(k.button = C.find(".w-nav-button")), |
|
|
(k.container = C.find(".w-container")), |
|
|
(k.overlayContainerId = "w-nav-overlay-" + n), |
|
|
(k.outside = T(k)); |
|
|
var ce = C.find(".w-nav-brand"); |
|
|
ce && |
|
|
ce.attr("href") === "/" && |
|
|
ce.attr("aria-label") == null && |
|
|
ce.attr("aria-label", "home"), |
|
|
k.button.attr("style", "-webkit-user-select: text;"), |
|
|
k.button.attr("aria-label") == null && |
|
|
k.button.attr("aria-label", "menu"), |
|
|
k.button.attr("role", "button"), |
|
|
k.button.attr("tabindex", "0"), |
|
|
k.button.attr("aria-controls", k.overlayContainerId), |
|
|
k.button.attr("aria-haspopup", "menu"), |
|
|
k.button.attr("aria-expanded", "false"), |
|
|
k.el.off(A), |
|
|
k.button.off(A), |
|
|
k.menu.off(A), |
|
|
o(k), |
|
|
X ? |
|
|
($(k), k.el.on("setting" + A, c(k))) : |
|
|
(v(k), |
|
|
k.button.on("click" + A, l(k)), |
|
|
k.menu.on("click" + A, "a", x(k)), |
|
|
k.button.on("keydown" + A, d(k)), |
|
|
k.el.on("keydown" + A, w(k))), |
|
|
p(n, b); |
|
|
} |
|
|
|
|
|
function ye(n, b) { |
|
|
var C = t.data(b, A); |
|
|
C && ($(C), t.removeData(b, A)); |
|
|
} |
|
|
|
|
|
function $(n) { |
|
|
n.overlay && (re(n, !0), n.overlay.remove(), (n.overlay = null)); |
|
|
} |
|
|
|
|
|
function v(n) { |
|
|
n.overlay || |
|
|
((n.overlay = t(Q).appendTo(n.el)), |
|
|
n.overlay.attr("id", n.overlayContainerId), |
|
|
(n.parent = n.menu.parent()), |
|
|
re(n, !0)); |
|
|
} |
|
|
|
|
|
function o(n) { |
|
|
var b = {}, |
|
|
C = n.config || {}, |
|
|
k = (b.animation = n.el.attr("data-animation") || "default"); |
|
|
(b.animOver = /^over/.test(k)), |
|
|
(b.animDirect = /left$/.test(k) ? -1 : 1), |
|
|
C.animation !== k && n.open && f.defer(q, n), |
|
|
(b.easing = n.el.attr("data-easing") || "ease"), |
|
|
(b.easing2 = n.el.attr("data-easing2") || "ease"); |
|
|
var ce = n.el.attr("data-duration"); |
|
|
(b.duration = ce != null ? Number(ce) : 400), |
|
|
(b.docHeight = n.el.attr("data-doc-height")), |
|
|
(n.config = b); |
|
|
} |
|
|
|
|
|
function c(n) { |
|
|
return function(b, C) { |
|
|
C = C || {}; |
|
|
var k = R.width(); |
|
|
o(n), |
|
|
C.open === !0 && ae(n, !0), |
|
|
C.open === !1 && re(n, !0), |
|
|
n.open && |
|
|
f.defer(function() { |
|
|
k !== R.width() && q(n); |
|
|
}); |
|
|
}; |
|
|
} |
|
|
|
|
|
function d(n) { |
|
|
return function(b) { |
|
|
switch (b.keyCode) { |
|
|
case me.SPACE: |
|
|
case me.ENTER: |
|
|
return l(n)(), b.preventDefault(), b.stopPropagation(); |
|
|
case me.ESCAPE: |
|
|
return re(n), b.preventDefault(), b.stopPropagation(); |
|
|
case me.ARROW_RIGHT: |
|
|
case me.ARROW_DOWN: |
|
|
case me.HOME: |
|
|
case me.END: |
|
|
return n.open ? |
|
|
(b.keyCode === me.END ? |
|
|
(n.selectedIdx = n.links.length - 1) : |
|
|
(n.selectedIdx = 0), |
|
|
P(n), |
|
|
b.preventDefault(), |
|
|
b.stopPropagation()) : |
|
|
(b.preventDefault(), b.stopPropagation()); |
|
|
} |
|
|
}; |
|
|
} |
|
|
|
|
|
function w(n) { |
|
|
return function(b) { |
|
|
if (n.open) |
|
|
switch ( |
|
|
((n.selectedIdx = n.links.index(document.activeElement)), |
|
|
b.keyCode) |
|
|
) { |
|
|
case me.HOME: |
|
|
case me.END: |
|
|
return ( |
|
|
b.keyCode === me.END ? |
|
|
(n.selectedIdx = n.links.length - 1) : |
|
|
(n.selectedIdx = 0), |
|
|
P(n), |
|
|
b.preventDefault(), |
|
|
b.stopPropagation() |
|
|
); |
|
|
case me.ESCAPE: |
|
|
return ( |
|
|
re(n), |
|
|
n.button.focus(), |
|
|
b.preventDefault(), |
|
|
b.stopPropagation() |
|
|
); |
|
|
case me.ARROW_LEFT: |
|
|
case me.ARROW_UP: |
|
|
return ( |
|
|
(n.selectedIdx = Math.max(-1, n.selectedIdx - 1)), |
|
|
P(n), |
|
|
b.preventDefault(), |
|
|
b.stopPropagation() |
|
|
); |
|
|
case me.ARROW_RIGHT: |
|
|
case me.ARROW_DOWN: |
|
|
return ( |
|
|
(n.selectedIdx = Math.min( |
|
|
n.links.length - 1, |
|
|
n.selectedIdx + 1 |
|
|
)), |
|
|
P(n), |
|
|
b.preventDefault(), |
|
|
b.stopPropagation() |
|
|
); |
|
|
} |
|
|
}; |
|
|
} |
|
|
|
|
|
function P(n) { |
|
|
if (n.links[n.selectedIdx]) { |
|
|
var b = n.links[n.selectedIdx]; |
|
|
b.focus(), x(b); |
|
|
} |
|
|
} |
|
|
|
|
|
function q(n) { |
|
|
n.open && (re(n, !0), ae(n, !0)); |
|
|
} |
|
|
|
|
|
function l(n) { |
|
|
return F(function() { |
|
|
n.open ? re(n) : ae(n); |
|
|
}); |
|
|
} |
|
|
|
|
|
function x(n) { |
|
|
return function(b) { |
|
|
var C = t(this), |
|
|
k = C.attr("href"); |
|
|
if (!Me.validClick(b.currentTarget)) { |
|
|
b.preventDefault(); |
|
|
return; |
|
|
} |
|
|
k && k.indexOf("#") === 0 && n.open && re(n); |
|
|
}; |
|
|
} |
|
|
|
|
|
function T(n) { |
|
|
return ( |
|
|
n.outside && m.off("click" + A, n.outside), |
|
|
function(b) { |
|
|
var C = t(b.target); |
|
|
(te && C.closest(".w-editor-bem-EditorOverlay").length) || |
|
|
g(n, C); |
|
|
} |
|
|
); |
|
|
} |
|
|
var g = F(function(n, b) { |
|
|
if (n.open) { |
|
|
var C = b.closest(".w-nav-menu"); |
|
|
n.menu.is(C) || re(n); |
|
|
} |
|
|
}); |
|
|
|
|
|
function p(n, b) { |
|
|
var C = t.data(b, A), |
|
|
k = (C.collapsed = C.button.css("display") !== "none"); |
|
|
if ((C.open && !k && !X && re(C, !0), C.container.length)) { |
|
|
var ce = G(C); |
|
|
C.links.each(ce), C.dropdowns.each(ce); |
|
|
} |
|
|
C.open && Te(C); |
|
|
} |
|
|
var O = "max-width"; |
|
|
|
|
|
function G(n) { |
|
|
var b = n.container.css(O); |
|
|
return ( |
|
|
b === "none" && (b = ""), |
|
|
function(C, k) { |
|
|
(k = t(k)), k.css(O, ""), k.css(O) === "none" && k.css(O, b); |
|
|
} |
|
|
); |
|
|
} |
|
|
|
|
|
function V(n, b) { |
|
|
b.setAttribute("data-nav-menu-open", ""); |
|
|
} |
|
|
|
|
|
function U(n, b) { |
|
|
b.removeAttribute("data-nav-menu-open"); |
|
|
} |
|
|
|
|
|
function ae(n, b) { |
|
|
if (n.open) return; |
|
|
(n.open = !0), |
|
|
n.menu.each(V), |
|
|
n.links.addClass(M), |
|
|
n.dropdowns.addClass(j), |
|
|
n.dropdownToggle.addClass(Z), |
|
|
n.dropdownList.addClass(B), |
|
|
n.button.addClass(D); |
|
|
var C = n.config, |
|
|
k = C.animation; |
|
|
(k === "none" || !S.support.transform || C.duration <= 0) && |
|
|
(b = !0); |
|
|
var ce = Te(n), |
|
|
We = n.menu.outerHeight(!0), |
|
|
Ce = n.menu.outerWidth(!0), |
|
|
e = n.el.height(), |
|
|
r = n.el[0]; |
|
|
if ( |
|
|
(p(0, r), |
|
|
E.intro(0, r), |
|
|
Me.redraw.up(), |
|
|
X || m.on("click" + A, n.outside), |
|
|
b) |
|
|
) { |
|
|
i(); |
|
|
return; |
|
|
} |
|
|
var a = "transform " + C.duration + "ms " + C.easing; |
|
|
if ( |
|
|
(n.overlay && |
|
|
((W = n.menu.prev()), n.overlay.show().append(n.menu)), |
|
|
C.animOver) |
|
|
) { |
|
|
S(n.menu) |
|
|
.add(a) |
|
|
.set({ x: C.animDirect * Ce, height: ce }) |
|
|
.start({ x: 0 }) |
|
|
.then(i), |
|
|
n.overlay && n.overlay.width(Ce); |
|
|
return; |
|
|
} |
|
|
var s = e + We; |
|
|
S(n.menu).add(a).set({ y: -s }).start({ y: 0 }).then(i); |
|
|
|
|
|
function i() { |
|
|
n.button.attr("aria-expanded", "true"); |
|
|
} |
|
|
} |
|
|
|
|
|
function Te(n) { |
|
|
var b = n.config, |
|
|
C = b.docHeight ? m.height() : _.height(); |
|
|
return ( |
|
|
b.animOver ? |
|
|
n.menu.height(C) : |
|
|
n.el.css("position") !== "fixed" && |
|
|
(C -= n.el.outerHeight(!0)), |
|
|
n.overlay && n.overlay.height(C), |
|
|
C |
|
|
); |
|
|
} |
|
|
|
|
|
function re(n, b) { |
|
|
if (!n.open) return; |
|
|
(n.open = !1), n.button.removeClass(D); |
|
|
var C = n.config; |
|
|
if ( |
|
|
((C.animation === "none" || |
|
|
!S.support.transform || |
|
|
C.duration <= 0) && |
|
|
(b = !0), |
|
|
E.outro(0, n.el[0]), |
|
|
m.off("click" + A, n.outside), |
|
|
b) |
|
|
) { |
|
|
S(n.menu).stop(), r(); |
|
|
return; |
|
|
} |
|
|
var k = "transform " + C.duration + "ms " + C.easing2, |
|
|
ce = n.menu.outerHeight(!0), |
|
|
We = n.menu.outerWidth(!0), |
|
|
Ce = n.el.height(); |
|
|
if (C.animOver) { |
|
|
S(n.menu) |
|
|
.add(k) |
|
|
.start({ x: We * C.animDirect }) |
|
|
.then(r); |
|
|
return; |
|
|
} |
|
|
var e = Ce + ce; |
|
|
S(n.menu).add(k).start({ y: -e }).then(r); |
|
|
|
|
|
function r() { |
|
|
n.menu.height(""), |
|
|
S(n.menu).set({ x: 0, y: 0 }), |
|
|
n.menu.each(U), |
|
|
n.links.removeClass(M), |
|
|
n.dropdowns.removeClass(j), |
|
|
n.dropdownToggle.removeClass(Z), |
|
|
n.dropdownList.removeClass(B), |
|
|
n.overlay && |
|
|
n.overlay.children().length && |
|
|
(W.length ? |
|
|
n.menu.insertAfter(W) : |
|
|
n.menu.prependTo(n.parent), |
|
|
n.overlay.attr("style", "").hide()), |
|
|
n.el.triggerHandler("w-close"), |
|
|
n.button.attr("aria-expanded", "false"); |
|
|
} |
|
|
} |
|
|
return h; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
var Ut = pe((rt) => { |
|
|
"use strict"; |
|
|
Object.defineProperty(rt, "__esModule", { value: !0 }); |
|
|
rt.default = dn; |
|
|
|
|
|
function dn(t, f, h, S, R, m, F, _, H, X, te, z, Q) { |
|
|
return function(A) { |
|
|
t(A); |
|
|
var D = A.form, |
|
|
j = { |
|
|
name: D.attr("data-name") || D.attr("name") || "Untitled Form", |
|
|
source: f.href, |
|
|
test: h.env(), |
|
|
fields: {}, |
|
|
fileUploads: {}, |
|
|
dolphin: /pass[\s-_]?(word|code)|secret|login|credentials/i.test( |
|
|
D.html() |
|
|
), |
|
|
trackingCookies: S(), |
|
|
}; |
|
|
let Z = D.attr("data-wf-flow"); |
|
|
Z && (j.wfFlow = Z), R(A); |
|
|
var B = m(D, j.fields); |
|
|
if (B) return F(B); |
|
|
if (((j.fileUploads = _(D)), H(A), !X)) { |
|
|
te(A); |
|
|
return; |
|
|
} |
|
|
z.ajax({ |
|
|
url: Q, |
|
|
type: "POST", |
|
|
data: j, |
|
|
dataType: "json", |
|
|
crossDomain: !0, |
|
|
}) |
|
|
.done(function(M) { |
|
|
M && M.code === 200 && (A.success = !0), te(A); |
|
|
}) |
|
|
.fail(function() { |
|
|
te(A); |
|
|
}); |
|
|
}; |
|
|
} |
|
|
}); |
|
|
var $t = pe((In, Bt) => { |
|
|
var Ve = Ee(); |
|
|
Ve.define( |
|
|
"forms", |
|
|
(Bt.exports = function(t, f) { |
|
|
var h = {}, |
|
|
S = t(document), |
|
|
R, |
|
|
m = window.location, |
|
|
F = window.XDomainRequest && !window.atob, |
|
|
_ = ".w-form", |
|
|
H, |
|
|
X = /e(-)?mail/i, |
|
|
te = /^\S+@\S+$/, |
|
|
z = window.alert, |
|
|
Q = Ve.env(), |
|
|
A, |
|
|
D, |
|
|
j, |
|
|
Z = /list-manage[1-9]?.com/i, |
|
|
B = f.debounce(function() { |
|
|
z( |
|
|
"Oops! This page has improperly configured forms. Please contact your website administrator to fix this issue." |
|
|
); |
|
|
}, 100); |
|
|
h.ready = |
|
|
h.design = |
|
|
h.preview = |
|
|
function() { |
|
|
M(), !Q && !A && W(); |
|
|
}; |
|
|
|
|
|
function M() { |
|
|
(H = t("html").attr("data-wf-site")), |
|
|
(D = "https://webflow.com/api/v1/form/" + H), |
|
|
F && |
|
|
D.indexOf("https://webflow.com") >= 0 && |
|
|
(D = D.replace( |
|
|
"https://webflow.com", |
|
|
"https://formdata.webflow.com" |
|
|
)), |
|
|
(j = `${D}/signFile`), |
|
|
(R = t(_ + " form")), |
|
|
R.length && R.each(E); |
|
|
} |
|
|
|
|
|
function E(l, x) { |
|
|
var T = t(x), |
|
|
g = t.data(x, _); |
|
|
g || (g = t.data(x, _, { form: T })), L(g); |
|
|
var p = T.closest("div.w-form"); |
|
|
(g.done = p.find("> .w-form-done")), |
|
|
(g.fail = p.find("> .w-form-fail")), |
|
|
(g.fileUploads = p.find(".w-file-upload")), |
|
|
g.fileUploads.each(function(V) { |
|
|
w(V, g); |
|
|
}); |
|
|
var O = |
|
|
g.form.attr("aria-label") || g.form.attr("data-name") || "Form"; |
|
|
g.done.attr("aria-label") || g.form.attr("aria-label", O), |
|
|
g.done.attr("tabindex", "-1"), |
|
|
g.done.attr("role", "region"), |
|
|
g.done.attr("aria-label") || |
|
|
g.done.attr("aria-label", O + " success"), |
|
|
g.fail.attr("tabindex", "-1"), |
|
|
g.fail.attr("role", "region"), |
|
|
g.fail.attr("aria-label") || |
|
|
g.fail.attr("aria-label", O + " failure"); |
|
|
var G = (g.action = T.attr("action")); |
|
|
if ( |
|
|
((g.handler = null), |
|
|
(g.redirect = T.attr("data-redirect")), |
|
|
Z.test(G)) |
|
|
) { |
|
|
g.handler = o; |
|
|
return; |
|
|
} |
|
|
if (!G) { |
|
|
if (H) { |
|
|
g.handler = (() => { |
|
|
let V = Ut().default; |
|
|
return V(L, m, Ve, ye, d, ue, z, le, Y, H, c, t, D); |
|
|
})(); |
|
|
return; |
|
|
} |
|
|
B(); |
|
|
} |
|
|
} |
|
|
|
|
|
function W() { |
|
|
(A = !0), |
|
|
S.on("submit", _ + " form", function(V) { |
|
|
var U = t.data(this, _); |
|
|
U.handler && ((U.evt = V), U.handler(U)); |
|
|
}); |
|
|
let l = ".w-checkbox-input", |
|
|
x = ".w-radio-input", |
|
|
T = "w--redirected-checked", |
|
|
g = "w--redirected-focus", |
|
|
p = "w--redirected-focus-visible", |
|
|
O = ":focus-visible, [data-wf-focus-visible]", |
|
|
G = [ |
|
|
["checkbox", l], |
|
|
["radio", x], |
|
|
]; |
|
|
S.on( |
|
|
"change", |
|
|
_ + ' form input[type="checkbox"]:not(' + l + ")", |
|
|
(V) => { |
|
|
t(V.target).siblings(l).toggleClass(T); |
|
|
} |
|
|
), |
|
|
S.on("change", _ + ' form input[type="radio"]', (V) => { |
|
|
t(`input[name="${V.target.name}"]:not(${l})`).map((ae, Te) => |
|
|
t(Te).siblings(x).removeClass(T) |
|
|
); |
|
|
let U = t(V.target); |
|
|
U.hasClass("w-radio-input") || U.siblings(x).addClass(T); |
|
|
}), |
|
|
G.forEach(([V, U]) => { |
|
|
S.on( |
|
|
"focus", |
|
|
_ + ` form input[type="${V}"]:not(` + U + ")", |
|
|
(ae) => { |
|
|
t(ae.target).siblings(U).addClass(g), |
|
|
t(ae.target).filter(O).siblings(U).addClass(p); |
|
|
} |
|
|
), |
|
|
S.on( |
|
|
"blur", |
|
|
_ + ` form input[type="${V}"]:not(` + U + ")", |
|
|
(ae) => { |
|
|
t(ae.target).siblings(U).removeClass(`${g} ${p}`); |
|
|
} |
|
|
); |
|
|
}); |
|
|
} |
|
|
|
|
|
function L(l) { |
|
|
var x = (l.btn = l.form.find(':input[type="submit"]')); |
|
|
(l.wait = l.btn.attr("data-wait") || null), |
|
|
(l.success = !1), |
|
|
x.prop("disabled", !1), |
|
|
l.label && x.val(l.label); |
|
|
} |
|
|
|
|
|
function Y(l) { |
|
|
var x = l.btn, |
|
|
T = l.wait; |
|
|
x.prop("disabled", !0), T && ((l.label = x.val()), x.val(T)); |
|
|
} |
|
|
|
|
|
function ue(l, x) { |
|
|
var T = null; |
|
|
return ( |
|
|
(x = x || {}), |
|
|
l |
|
|
.find(':input:not([type="submit"]):not([type="file"])') |
|
|
.each(function(g, p) { |
|
|
var O = t(p), |
|
|
G = O.attr("type"), |
|
|
V = |
|
|
O.attr("data-name") || |
|
|
O.attr("name") || |
|
|
"Field " + (g + 1), |
|
|
U = O.val(); |
|
|
if (G === "checkbox") U = O.is(":checked"); |
|
|
else if (G === "radio") { |
|
|
if (x[V] === null || typeof x[V] == "string") return; |
|
|
U = |
|
|
l |
|
|
.find('input[name="' + O.attr("name") + '"]:checked') |
|
|
.val() || null; |
|
|
} |
|
|
typeof U == "string" && (U = t.trim(U)), |
|
|
(x[V] = U), |
|
|
(T = T || $(O, G, V, U)); |
|
|
}), |
|
|
T |
|
|
); |
|
|
} |
|
|
|
|
|
function le(l) { |
|
|
var x = {}; |
|
|
return ( |
|
|
l.find(':input[type="file"]').each(function(T, g) { |
|
|
var p = t(g), |
|
|
O = |
|
|
p.attr("data-name") || p.attr("name") || "File " + (T + 1), |
|
|
G = p.attr("data-value"); |
|
|
typeof G == "string" && (G = t.trim(G)), (x[O] = G); |
|
|
}), |
|
|
x |
|
|
); |
|
|
} |
|
|
let de = { _mkto_trk: "marketo" }; |
|
|
|
|
|
function ye() { |
|
|
return document.cookie.split("; ").reduce(function(x, T) { |
|
|
let g = T.split("="), |
|
|
p = g[0]; |
|
|
if (p in de) { |
|
|
let O = de[p], |
|
|
G = g.slice(1).join("="); |
|
|
x[O] = G; |
|
|
} |
|
|
return x; |
|
|
}, {}); |
|
|
} |
|
|
|
|
|
function $(l, x, T, g) { |
|
|
var p = null; |
|
|
return ( |
|
|
x === "password" ? |
|
|
(p = "Passwords cannot be submitted.") : |
|
|
l.attr("required") ? |
|
|
g ? |
|
|
X.test(l.attr("type")) && |
|
|
(te.test(g) || |
|
|
(p = "Please enter a valid email address for: " + T)) : |
|
|
(p = "Please fill out the required field: " + T) : |
|
|
T === "g-recaptcha-response" && |
|
|
!g && |
|
|
(p = "Please confirm you\u2019re not a robot."), |
|
|
p |
|
|
); |
|
|
} |
|
|
|
|
|
function v(l) { |
|
|
d(l), c(l); |
|
|
} |
|
|
|
|
|
function o(l) { |
|
|
L(l); |
|
|
var x = l.form, |
|
|
T = {}; |
|
|
if (/^https/.test(m.href) && !/^https/.test(l.action)) { |
|
|
x.attr("method", "post"); |
|
|
return; |
|
|
} |
|
|
d(l); |
|
|
var g = ue(x, T); |
|
|
if (g) return z(g); |
|
|
Y(l); |
|
|
var p; |
|
|
f.each(T, function(U, ae) { |
|
|
X.test(ae) && (T.EMAIL = U), |
|
|
/^((full[ _-]?)?name)$/i.test(ae) && (p = U), |
|
|
/^(first[ _-]?name)$/i.test(ae) && (T.FNAME = U), |
|
|
/^(last[ _-]?name)$/i.test(ae) && (T.LNAME = U); |
|
|
}), |
|
|
p && |
|
|
!T.FNAME && |
|
|
((p = p.split(" ")), |
|
|
(T.FNAME = p[0]), |
|
|
(T.LNAME = T.LNAME || p[1])); |
|
|
var O = l.action.replace("/post?", "/post-json?") + "&c=?", |
|
|
G = O.indexOf("u=") + 2; |
|
|
G = O.substring(G, O.indexOf("&", G)); |
|
|
var V = O.indexOf("id=") + 3; |
|
|
(V = O.substring(V, O.indexOf("&", V))), |
|
|
(T["b_" + G + "_" + V] = ""), |
|
|
t |
|
|
.ajax({ url: O, data: T, dataType: "jsonp" }) |
|
|
.done(function(U) { |
|
|
(l.success = U.result === "success" || /already/.test(U.msg)), |
|
|
l.success || console.info("MailChimp error: " + U.msg), |
|
|
c(l); |
|
|
}) |
|
|
.fail(function() { |
|
|
c(l); |
|
|
}); |
|
|
} |
|
|
|
|
|
function c(l) { |
|
|
var x = l.form, |
|
|
T = l.redirect, |
|
|
g = l.success; |
|
|
if (g && T) { |
|
|
Ve.location(T); |
|
|
return; |
|
|
} |
|
|
l.done.toggle(g), |
|
|
l.fail.toggle(!g), |
|
|
g ? l.done.focus() : l.fail.focus(), |
|
|
x.toggle(!g), |
|
|
L(l); |
|
|
} |
|
|
|
|
|
function d(l) { |
|
|
l.evt && l.evt.preventDefault(), (l.evt = null); |
|
|
} |
|
|
|
|
|
function w(l, x) { |
|
|
if (!x.fileUploads || !x.fileUploads[l]) return; |
|
|
var T, |
|
|
g = t(x.fileUploads[l]), |
|
|
p = g.find("> .w-file-upload-default"), |
|
|
O = g.find("> .w-file-upload-uploading"), |
|
|
G = g.find("> .w-file-upload-success"), |
|
|
V = g.find("> .w-file-upload-error"), |
|
|
U = p.find(".w-file-upload-input"), |
|
|
ae = p.find(".w-file-upload-label"), |
|
|
Te = ae.children(), |
|
|
re = V.find(".w-file-upload-error-msg"), |
|
|
n = G.find(".w-file-upload-file"), |
|
|
b = G.find(".w-file-remove-link"), |
|
|
C = n.find(".w-file-upload-file-name"), |
|
|
k = re.attr("data-w-size-error"), |
|
|
ce = re.attr("data-w-type-error"), |
|
|
We = re.attr("data-w-generic-error"); |
|
|
if ( |
|
|
(Q || |
|
|
ae.on("click keydown", function(i) { |
|
|
(i.type === "keydown" && i.which !== 13 && i.which !== 32) || |
|
|
(i.preventDefault(), U.click()); |
|
|
}), |
|
|
ae.find(".w-icon-file-upload-icon").attr("aria-hidden", "true"), |
|
|
b.find(".w-icon-file-upload-remove").attr("aria-hidden", "true"), |
|
|
Q) |
|
|
) |
|
|
U.on("click", function(i) { |
|
|
i.preventDefault(); |
|
|
}), |
|
|
ae.on("click", function(i) { |
|
|
i.preventDefault(); |
|
|
}), |
|
|
Te.on("click", function(i) { |
|
|
i.preventDefault(); |
|
|
}); |
|
|
else { |
|
|
b.on("click keydown", function(i) { |
|
|
if (i.type === "keydown") { |
|
|
if (i.which !== 13 && i.which !== 32) return; |
|
|
i.preventDefault(); |
|
|
} |
|
|
U.removeAttr("data-value"), |
|
|
U.val(""), |
|
|
C.html(""), |
|
|
p.toggle(!0), |
|
|
G.toggle(!1), |
|
|
ae.focus(); |
|
|
}), |
|
|
U.on("change", function(i) { |
|
|
(T = i.target && i.target.files && i.target.files[0]), |
|
|
T && |
|
|
(p.toggle(!1), |
|
|
V.toggle(!1), |
|
|
O.toggle(!0), |
|
|
O.focus(), |
|
|
C.text(T.name), |
|
|
s() || Y(x), |
|
|
(x.fileUploads[l].uploading = !0), |
|
|
P(T, r)); |
|
|
}); |
|
|
var Ce = ae.outerHeight(); |
|
|
U.height(Ce), U.width(1); |
|
|
} |
|
|
|
|
|
function e(i) { |
|
|
var u = i.responseJSON && i.responseJSON.msg, |
|
|
I = We; |
|
|
typeof u == "string" && u.indexOf("InvalidFileTypeError") === 0 ? |
|
|
(I = ce) : |
|
|
typeof u == "string" && |
|
|
u.indexOf("MaxFileSizeError") === 0 && |
|
|
(I = k), |
|
|
re.text(I), |
|
|
U.removeAttr("data-value"), |
|
|
U.val(""), |
|
|
O.toggle(!1), |
|
|
p.toggle(!0), |
|
|
V.toggle(!0), |
|
|
V.focus(), |
|
|
(x.fileUploads[l].uploading = !1), |
|
|
s() || L(x); |
|
|
} |
|
|
|
|
|
function r(i, u) { |
|
|
if (i) return e(i); |
|
|
var I = u.fileName, |
|
|
K = u.postData, |
|
|
se = u.fileId, |
|
|
y = u.s3Url; |
|
|
U.attr("data-value", se), q(y, K, T, I, a); |
|
|
} |
|
|
|
|
|
function a(i) { |
|
|
if (i) return e(i); |
|
|
O.toggle(!1), |
|
|
G.css("display", "inline-block"), |
|
|
G.focus(), |
|
|
(x.fileUploads[l].uploading = !1), |
|
|
s() || L(x); |
|
|
} |
|
|
|
|
|
function s() { |
|
|
var i = (x.fileUploads && x.fileUploads.toArray()) || []; |
|
|
return i.some(function(u) { |
|
|
return u.uploading; |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
function P(l, x) { |
|
|
var T = new URLSearchParams({ name: l.name, size: l.size }); |
|
|
t.ajax({ type: "GET", url: `${j}?${T}`, crossDomain: !0 }) |
|
|
.done(function(g) { |
|
|
x(null, g); |
|
|
}) |
|
|
.fail(function(g) { |
|
|
x(g); |
|
|
}); |
|
|
} |
|
|
|
|
|
function q(l, x, T, g, p) { |
|
|
var O = new FormData(); |
|
|
for (var G in x) O.append(G, x[G]); |
|
|
O.append("file", T, g), |
|
|
t |
|
|
.ajax({ |
|
|
type: "POST", |
|
|
url: l, |
|
|
data: O, |
|
|
processData: !1, |
|
|
contentType: !1, |
|
|
}) |
|
|
.done(function() { |
|
|
p(null); |
|
|
}) |
|
|
.fail(function(V) { |
|
|
p(V); |
|
|
}); |
|
|
} |
|
|
return h; |
|
|
}) |
|
|
); |
|
|
}); |
|
|
pt(); |
|
|
gt(); |
|
|
bt(); |
|
|
Et(); |
|
|
kt(); |
|
|
Ot(); |
|
|
St(); |
|
|
It(); |
|
|
Nt(); |
|
|
Ht(); |
|
|
$t(); |
|
|
})(); |
|
|
|
|
|
function init() { |
|
|
return; |
|
|
siteId = $('html').attr('data-wf-site'); |
|
|
|
|
|
$forms = $(namespace + ' form'); |
|
|
if (!$forms.length) return; |
|
|
$forms.each(build); |
|
|
} |