511 lines
12 KiB
JavaScript
511 lines
12 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 2cd465e94e439d21.d295534e06.js
|
|
* Module id: 368185
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t = "comm",
|
|
r = "rule",
|
|
o = "decl",
|
|
n = "@import",
|
|
i = "@namespace",
|
|
a = "@keyframes",
|
|
s = "@layer";
|
|
e.s(
|
|
[
|
|
"COMMENT",
|
|
() => t,
|
|
"DECLARATION",
|
|
() => o,
|
|
"IMPORT",
|
|
() => n,
|
|
"KEYFRAMES",
|
|
() => a,
|
|
"LAYER",
|
|
() => s,
|
|
"MOZ",
|
|
() => "-moz-",
|
|
"MS",
|
|
() => "-ms-",
|
|
"NAMESPACE",
|
|
() => i,
|
|
"RULESET",
|
|
() => r,
|
|
"WEBKIT",
|
|
() => "-webkit-",
|
|
],
|
|
830476,
|
|
);
|
|
var l = Math.abs,
|
|
c = String.fromCharCode,
|
|
u = Object.assign;
|
|
function d(e, t) {
|
|
return 45 ^ h(e, 0)
|
|
? (((((((t << 2) ^ h(e, 0)) << 2) ^ h(e, 1)) << 2) ^ h(e, 2)) << 2) ^
|
|
h(e, 3)
|
|
: 0;
|
|
}
|
|
function f(e) {
|
|
return e.trim();
|
|
}
|
|
function p(e, t) {
|
|
return (e = t.exec(e)) ? e[0] : e;
|
|
}
|
|
function g(e, t, r) {
|
|
return e.replace(t, r);
|
|
}
|
|
function m(e, t, r) {
|
|
return e.indexOf(t, r);
|
|
}
|
|
function h(e, t) {
|
|
return 0 | e.charCodeAt(t);
|
|
}
|
|
function b(e, t, r) {
|
|
return e.slice(t, r);
|
|
}
|
|
function y(e) {
|
|
return e.length;
|
|
}
|
|
function x(e) {
|
|
return e.length;
|
|
}
|
|
function v(e, t) {
|
|
return t.push(e), e;
|
|
}
|
|
function S(e, t) {
|
|
return e.map(t).join("");
|
|
}
|
|
function k(e, t) {
|
|
return e.filter(function (e) {
|
|
return !p(e, t);
|
|
});
|
|
}
|
|
e.s(
|
|
[
|
|
"abs",
|
|
() => l,
|
|
"append",
|
|
() => v,
|
|
"assign",
|
|
() => u,
|
|
"charat",
|
|
() => h,
|
|
"combine",
|
|
() => S,
|
|
"filter",
|
|
() => k,
|
|
"from",
|
|
() => c,
|
|
"hash",
|
|
() => d,
|
|
"indexof",
|
|
() => m,
|
|
"match",
|
|
() => p,
|
|
"replace",
|
|
() => g,
|
|
"sizeof",
|
|
() => x,
|
|
"strlen",
|
|
() => y,
|
|
"substr",
|
|
() => b,
|
|
"trim",
|
|
() => f,
|
|
],
|
|
731042,
|
|
);
|
|
var w = 1,
|
|
C = 1,
|
|
j = 0,
|
|
E = 0,
|
|
M = 0,
|
|
$ = "";
|
|
function T(e, t, r, o, n, i, a, s) {
|
|
return {
|
|
value: e,
|
|
root: t,
|
|
parent: r,
|
|
type: o,
|
|
props: n,
|
|
children: i,
|
|
line: w,
|
|
column: C,
|
|
length: a,
|
|
return: "",
|
|
siblings: s,
|
|
};
|
|
}
|
|
function _(e, t) {
|
|
return u(
|
|
T("", null, null, "", null, null, 0, e.siblings),
|
|
e,
|
|
{ length: -e.length },
|
|
t,
|
|
);
|
|
}
|
|
function R(e) {
|
|
for (; e.root; ) e = _(e.root, { children: [e] });
|
|
v(e, e.siblings);
|
|
}
|
|
function L() {
|
|
return M;
|
|
}
|
|
function A() {
|
|
return (M = E > 0 ? h($, --E) : 0), C--, 10 === M && ((C = 1), w--), M;
|
|
}
|
|
function I() {
|
|
return (M = E < j ? h($, E++) : 0), C++, 10 === M && ((C = 1), w++), M;
|
|
}
|
|
function P() {
|
|
return h($, E);
|
|
}
|
|
function z() {
|
|
return E;
|
|
}
|
|
function N(e) {
|
|
switch (e) {
|
|
case 0:
|
|
case 9:
|
|
case 10:
|
|
case 13:
|
|
case 32:
|
|
return 5;
|
|
case 33:
|
|
case 43:
|
|
case 44:
|
|
case 47:
|
|
case 62:
|
|
case 64:
|
|
case 126:
|
|
case 59:
|
|
case 123:
|
|
case 125:
|
|
return 4;
|
|
case 58:
|
|
return 3;
|
|
case 34:
|
|
case 39:
|
|
case 40:
|
|
case 91:
|
|
return 2;
|
|
case 41:
|
|
case 93:
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function O(e) {
|
|
return (w = C = 1), (j = y(($ = e))), (E = 0), [];
|
|
}
|
|
function D(e) {
|
|
return ($ = ""), e;
|
|
}
|
|
function W(e) {
|
|
var t, r;
|
|
return f(
|
|
((t = E - 1),
|
|
(r = (function e(t) {
|
|
for (; I(); )
|
|
switch (M) {
|
|
case t:
|
|
return E;
|
|
case 34:
|
|
case 39:
|
|
34 !== t && 39 !== t && e(M);
|
|
break;
|
|
case 40:
|
|
41 === t && e(t);
|
|
break;
|
|
case 92:
|
|
I();
|
|
}
|
|
return E;
|
|
})(91 === e ? e + 2 : 40 === e ? e + 1 : e)),
|
|
b($, t, r)),
|
|
);
|
|
}
|
|
function B(e) {
|
|
for (; (M = P()); )
|
|
if (M < 33) I();
|
|
else break;
|
|
return N(e) > 2 || N(M) > 3 ? "" : " ";
|
|
}
|
|
function F(e, t) {
|
|
for (
|
|
var r;
|
|
--t &&
|
|
I() &&
|
|
!(M < 48) &&
|
|
!(M > 102) &&
|
|
(!(M > 57) || !(M < 65)) &&
|
|
(!(M > 70) || !(M < 97));
|
|
|
|
);
|
|
return (r = E + (t < 6 && 32 == P() && 32 == I())), b($, e, r);
|
|
}
|
|
function U(e, t) {
|
|
for (; I(); )
|
|
if (e + M === 57) break;
|
|
else if (e + M === 84 && 47 === P()) break;
|
|
return "/*" + b($, t, E - 1) + "*" + c(47 === e ? e : I());
|
|
}
|
|
function H(e) {
|
|
for (; !N(P()); ) I();
|
|
return b($, e, E);
|
|
}
|
|
function V(e) {
|
|
return D(
|
|
(function e(r, o, n, i, a, s, u, d, f) {
|
|
for (
|
|
var p,
|
|
x,
|
|
S,
|
|
k,
|
|
w = 0,
|
|
C = 0,
|
|
j = u,
|
|
$ = 0,
|
|
_ = 0,
|
|
R = 0,
|
|
L = 1,
|
|
z = 1,
|
|
O = 1,
|
|
D = 0,
|
|
V = "",
|
|
Y = a,
|
|
J = s,
|
|
X = i,
|
|
Z = V;
|
|
z;
|
|
|
|
)
|
|
switch (((R = D), (D = I()))) {
|
|
case 40:
|
|
if (108 != R && 58 == h(Z, j - 1)) {
|
|
-1 !=
|
|
m((Z += g(W(D), "&", "&\f")), "&\f", l(w ? d[w - 1] : 0)) &&
|
|
(O = -1);
|
|
break;
|
|
}
|
|
case 34:
|
|
case 39:
|
|
case 91:
|
|
Z += W(D);
|
|
break;
|
|
case 9:
|
|
case 10:
|
|
case 13:
|
|
case 32:
|
|
Z += B(R);
|
|
break;
|
|
case 92:
|
|
Z += F(E - 1, 7);
|
|
continue;
|
|
case 47:
|
|
switch (P()) {
|
|
case 42:
|
|
case 47:
|
|
v(
|
|
((p = U(I(), E)),
|
|
(x = o),
|
|
(S = n),
|
|
(k = f),
|
|
T(p, x, S, t, c(M), b(p, 2, -2), 0, k)),
|
|
f,
|
|
),
|
|
(5 == N(R || 1) || 5 == N(P() || 1)) &&
|
|
y(Z) &&
|
|
" " !== b(Z, -1, void 0) &&
|
|
(Z += " ");
|
|
break;
|
|
default:
|
|
Z += "/";
|
|
}
|
|
break;
|
|
case 123 * L:
|
|
d[w++] = y(Z) * O;
|
|
case 125 * L:
|
|
case 59:
|
|
case 0:
|
|
switch (D) {
|
|
case 0:
|
|
case 125:
|
|
z = 0;
|
|
case 59 + C:
|
|
-1 == O && (Z = g(Z, /\f/g, "")),
|
|
_ > 0 &&
|
|
(y(Z) - j || (0 === L && 47 === R)) &&
|
|
v(
|
|
_ > 32
|
|
? K(Z + ";", i, n, j - 1, f)
|
|
: K(g(Z, " ", "") + ";", i, n, j - 2, f),
|
|
f,
|
|
);
|
|
break;
|
|
case 59:
|
|
Z += ";";
|
|
default:
|
|
if (
|
|
(v(
|
|
(X = G(
|
|
Z,
|
|
o,
|
|
n,
|
|
w,
|
|
C,
|
|
a,
|
|
d,
|
|
V,
|
|
(Y = []),
|
|
(J = []),
|
|
j,
|
|
s,
|
|
)),
|
|
s,
|
|
),
|
|
123 === D)
|
|
)
|
|
if (0 === C) e(Z, o, X, X, Y, s, j, d, J);
|
|
else {
|
|
switch ($) {
|
|
case 99:
|
|
if (110 === h(Z, 3)) break;
|
|
case 108:
|
|
if (97 === h(Z, 2)) break;
|
|
default:
|
|
C = 0;
|
|
case 100:
|
|
case 109:
|
|
case 115:
|
|
}
|
|
C
|
|
? e(
|
|
r,
|
|
X,
|
|
X,
|
|
i &&
|
|
v(
|
|
G(r, X, X, 0, 0, a, d, V, a, (Y = []), j, J),
|
|
J,
|
|
),
|
|
a,
|
|
J,
|
|
j,
|
|
d,
|
|
i ? Y : J,
|
|
)
|
|
: e(Z, X, X, X, [""], J, 0, d, J);
|
|
}
|
|
}
|
|
(w = C = _ = 0), (L = O = 1), (V = Z = ""), (j = u);
|
|
break;
|
|
case 58:
|
|
(j = 1 + y(Z)), (_ = R);
|
|
default:
|
|
if (L < 1) {
|
|
if (123 == D) --L;
|
|
else if (125 == D && 0 == L++ && 125 == A()) continue;
|
|
}
|
|
switch (((Z += c(D)), D * L)) {
|
|
case 38:
|
|
O = C > 0 ? 1 : ((Z += "\f"), -1);
|
|
break;
|
|
case 44:
|
|
(d[w++] = (y(Z) - 1) * O), (O = 1);
|
|
break;
|
|
case 64:
|
|
45 === P() && (Z += W(I())),
|
|
($ = P()),
|
|
(C = j = y((V = Z += H(E)))),
|
|
D++;
|
|
break;
|
|
case 45:
|
|
45 === R && 2 == y(Z) && (L = 0);
|
|
}
|
|
}
|
|
return s;
|
|
})("", null, null, null, [""], (e = O(e)), 0, [0], e),
|
|
);
|
|
}
|
|
function G(e, t, o, n, i, a, s, c, u, d, p, m) {
|
|
for (
|
|
var h = i - 1, y = 0 === i ? a : [""], v = x(y), S = 0, k = 0, w = 0;
|
|
S < n;
|
|
++S
|
|
)
|
|
for (var C = 0, j = b(e, h + 1, (h = l((k = s[S])))), E = e; C < v; ++C)
|
|
(E = f(k > 0 ? y[C] + " " + j : g(j, /&\f/g, y[C]))) && (u[w++] = E);
|
|
return T(e, t, o, 0 === i ? r : c, u, d, p, m);
|
|
}
|
|
function K(e, t, r, n, i) {
|
|
return T(e, t, r, o, b(e, 0, n), b(e, n + 1, -1), n, i);
|
|
}
|
|
function Y(e, t) {
|
|
for (var r = "", o = 0; o < e.length; o++) r += t(e[o], o, e, t) || "";
|
|
return r;
|
|
}
|
|
function J(e, l, c, u) {
|
|
switch (e.type) {
|
|
case s:
|
|
if (e.children.length) break;
|
|
case n:
|
|
case i:
|
|
case o:
|
|
return (e.return = e.return || e.value);
|
|
case t:
|
|
return "";
|
|
case a:
|
|
return (e.return = e.value + "{" + Y(e.children, u) + "}");
|
|
case r:
|
|
if (!y((e.value = e.props.join(",")))) return "";
|
|
}
|
|
return y((c = Y(e.children, u)))
|
|
? (e.return = e.value + "{" + c + "}")
|
|
: "";
|
|
}
|
|
e.s(
|
|
[
|
|
"alloc",
|
|
() => O,
|
|
"caret",
|
|
() => z,
|
|
"char",
|
|
() => L,
|
|
"commenter",
|
|
() => U,
|
|
"copy",
|
|
() => _,
|
|
"dealloc",
|
|
() => D,
|
|
"delimit",
|
|
() => W,
|
|
"escaping",
|
|
() => F,
|
|
"identifier",
|
|
() => H,
|
|
"lift",
|
|
() => R,
|
|
"next",
|
|
() => I,
|
|
"node",
|
|
() => T,
|
|
"peek",
|
|
() => P,
|
|
"prev",
|
|
() => A,
|
|
"token",
|
|
() => N,
|
|
"whitespace",
|
|
() => B,
|
|
],
|
|
921976,
|
|
),
|
|
e.s(["compile", () => V], 357957),
|
|
e.s(["serialize", () => Y, "stringify", () => J], 368185);
|
|
};
|
|
|
|
export default moduleFactory;
|