21625 lines
631 KiB
JavaScript
21625 lines
631 KiB
JavaScript
(() => {
|
|
var xb = Object.create;
|
|
var li = Object.defineProperty;
|
|
var kb = Object.getOwnPropertyDescriptor;
|
|
var Sb = Object.getOwnPropertyNames;
|
|
var Cb = Object.getPrototypeOf,
|
|
Ab = Object.prototype.hasOwnProperty;
|
|
var uu = (i) => li(i, "__esModule", { value: !0 });
|
|
var fu = (i) => {
|
|
if (typeof require != "undefined") return require(i);
|
|
throw new Error('Dynamic require of "' + i + '" is not supported');
|
|
};
|
|
var C = (i, e) => () => (i && (e = i((i = 0))), e);
|
|
var v = (i, e) => () => (e || i((e = { exports: {} }).exports, e), e.exports),
|
|
Ae = (i, e) => {
|
|
uu(i);
|
|
for (var t in e) li(i, t, { get: e[t], enumerable: !0 });
|
|
},
|
|
_b = (i, e, t) => {
|
|
if ((e && typeof e == "object") || typeof e == "function")
|
|
for (let r of Sb(e))
|
|
!Ab.call(i, r) &&
|
|
r !== "default" &&
|
|
li(i, r, {
|
|
get: () => e[r],
|
|
enumerable: !(t = kb(e, r)) || t.enumerable,
|
|
});
|
|
return i;
|
|
},
|
|
K = (i) =>
|
|
_b(
|
|
uu(
|
|
li(
|
|
i != null ? xb(Cb(i)) : {},
|
|
"default",
|
|
i && i.__esModule && "default" in i
|
|
? { get: () => i.default, enumerable: !0 }
|
|
: { value: i, enumerable: !0 },
|
|
),
|
|
),
|
|
i,
|
|
);
|
|
var h,
|
|
l = C(() => {
|
|
h = { platform: "", env: {}, versions: { node: "14.17.6" } };
|
|
});
|
|
var Ob,
|
|
re,
|
|
je = C(() => {
|
|
l();
|
|
(Ob = 0),
|
|
(re = {
|
|
readFileSync: (i) => self[i] || "",
|
|
statSync: () => ({ mtimeMs: Ob++ }),
|
|
promises: { readFile: (i) => Promise.resolve(self[i] || "") },
|
|
});
|
|
});
|
|
var Qn = v((XO, pu) => {
|
|
l();
|
|
("use strict");
|
|
var cu = class {
|
|
constructor(e = {}) {
|
|
if (!(e.maxSize && e.maxSize > 0))
|
|
throw new TypeError("`maxSize` must be a number greater than 0");
|
|
if (typeof e.maxAge == "number" && e.maxAge === 0)
|
|
throw new TypeError("`maxAge` must be a number greater than 0");
|
|
(this.maxSize = e.maxSize),
|
|
(this.maxAge = e.maxAge || 1 / 0),
|
|
(this.onEviction = e.onEviction),
|
|
(this.cache = new Map()),
|
|
(this.oldCache = new Map()),
|
|
(this._size = 0);
|
|
}
|
|
_emitEvictions(e) {
|
|
if (typeof this.onEviction == "function")
|
|
for (let [t, r] of e) this.onEviction(t, r.value);
|
|
}
|
|
_deleteIfExpired(e, t) {
|
|
return typeof t.expiry == "number" && t.expiry <= Date.now()
|
|
? (typeof this.onEviction == "function" &&
|
|
this.onEviction(e, t.value),
|
|
this.delete(e))
|
|
: !1;
|
|
}
|
|
_getOrDeleteIfExpired(e, t) {
|
|
if (this._deleteIfExpired(e, t) === !1) return t.value;
|
|
}
|
|
_getItemValue(e, t) {
|
|
return t.expiry ? this._getOrDeleteIfExpired(e, t) : t.value;
|
|
}
|
|
_peek(e, t) {
|
|
let r = t.get(e);
|
|
return this._getItemValue(e, r);
|
|
}
|
|
_set(e, t) {
|
|
this.cache.set(e, t),
|
|
this._size++,
|
|
this._size >= this.maxSize &&
|
|
((this._size = 0),
|
|
this._emitEvictions(this.oldCache),
|
|
(this.oldCache = this.cache),
|
|
(this.cache = new Map()));
|
|
}
|
|
_moveToRecent(e, t) {
|
|
this.oldCache.delete(e), this._set(e, t);
|
|
}
|
|
*_entriesAscending() {
|
|
for (let e of this.oldCache) {
|
|
let [t, r] = e;
|
|
this.cache.has(t) ||
|
|
(this._deleteIfExpired(t, r) === !1 && (yield e));
|
|
}
|
|
for (let e of this.cache) {
|
|
let [t, r] = e;
|
|
this._deleteIfExpired(t, r) === !1 && (yield e);
|
|
}
|
|
}
|
|
get(e) {
|
|
if (this.cache.has(e)) {
|
|
let t = this.cache.get(e);
|
|
return this._getItemValue(e, t);
|
|
}
|
|
if (this.oldCache.has(e)) {
|
|
let t = this.oldCache.get(e);
|
|
if (this._deleteIfExpired(e, t) === !1)
|
|
return this._moveToRecent(e, t), t.value;
|
|
}
|
|
}
|
|
set(
|
|
e,
|
|
t,
|
|
{
|
|
maxAge: r = this.maxAge === 1 / 0 ? void 0 : Date.now() + this.maxAge,
|
|
} = {},
|
|
) {
|
|
this.cache.has(e)
|
|
? this.cache.set(e, { value: t, maxAge: r })
|
|
: this._set(e, { value: t, expiry: r });
|
|
}
|
|
has(e) {
|
|
return this.cache.has(e)
|
|
? !this._deleteIfExpired(e, this.cache.get(e))
|
|
: this.oldCache.has(e)
|
|
? !this._deleteIfExpired(e, this.oldCache.get(e))
|
|
: !1;
|
|
}
|
|
peek(e) {
|
|
if (this.cache.has(e)) return this._peek(e, this.cache);
|
|
if (this.oldCache.has(e)) return this._peek(e, this.oldCache);
|
|
}
|
|
delete(e) {
|
|
let t = this.cache.delete(e);
|
|
return t && this._size--, this.oldCache.delete(e) || t;
|
|
}
|
|
clear() {
|
|
this.cache.clear(), this.oldCache.clear(), (this._size = 0);
|
|
}
|
|
resize(e) {
|
|
if (!(e && e > 0))
|
|
throw new TypeError("`maxSize` must be a number greater than 0");
|
|
let t = [...this._entriesAscending()],
|
|
r = t.length - e;
|
|
r < 0
|
|
? ((this.cache = new Map(t)),
|
|
(this.oldCache = new Map()),
|
|
(this._size = t.length))
|
|
: (r > 0 && this._emitEvictions(t.slice(0, r)),
|
|
(this.oldCache = new Map(t.slice(r))),
|
|
(this.cache = new Map()),
|
|
(this._size = 0)),
|
|
(this.maxSize = e);
|
|
}
|
|
*keys() {
|
|
for (let [e] of this) yield e;
|
|
}
|
|
*values() {
|
|
for (let [, e] of this) yield e;
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (let e of this.cache) {
|
|
let [t, r] = e;
|
|
this._deleteIfExpired(t, r) === !1 && (yield [t, r.value]);
|
|
}
|
|
for (let e of this.oldCache) {
|
|
let [t, r] = e;
|
|
this.cache.has(t) ||
|
|
(this._deleteIfExpired(t, r) === !1 && (yield [t, r.value]));
|
|
}
|
|
}
|
|
*entriesDescending() {
|
|
let e = [...this.cache];
|
|
for (let t = e.length - 1; t >= 0; --t) {
|
|
let r = e[t],
|
|
[n, a] = r;
|
|
this._deleteIfExpired(n, a) === !1 && (yield [n, a.value]);
|
|
}
|
|
e = [...this.oldCache];
|
|
for (let t = e.length - 1; t >= 0; --t) {
|
|
let r = e[t],
|
|
[n, a] = r;
|
|
this.cache.has(n) ||
|
|
(this._deleteIfExpired(n, a) === !1 && (yield [n, a.value]));
|
|
}
|
|
}
|
|
*entriesAscending() {
|
|
for (let [e, t] of this._entriesAscending()) yield [e, t.value];
|
|
}
|
|
get size() {
|
|
if (!this._size) return this.oldCache.size;
|
|
let e = 0;
|
|
for (let t of this.oldCache.keys()) this.cache.has(t) || e++;
|
|
return Math.min(this._size + e, this.maxSize);
|
|
}
|
|
};
|
|
pu.exports = cu;
|
|
});
|
|
var du,
|
|
hu = C(() => {
|
|
l();
|
|
du = (i) => i && i._hash;
|
|
});
|
|
function ui(i) {
|
|
return du(i, { ignoreUnknown: !0 });
|
|
}
|
|
var mu = C(() => {
|
|
l();
|
|
hu();
|
|
});
|
|
function Xe(i) {
|
|
if (((i = `${i}`), i === "0")) return "0";
|
|
if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(i))
|
|
return i.replace(/^[+-]?/, (t) => (t === "-" ? "" : "-"));
|
|
let e = ["var", "calc", "min", "max", "clamp"];
|
|
for (let t of e) if (i.includes(`${t}(`)) return `calc(${i} * -1)`;
|
|
}
|
|
var fi = C(() => {
|
|
l();
|
|
});
|
|
var gu,
|
|
yu = C(() => {
|
|
l();
|
|
gu = [
|
|
"preflight",
|
|
"container",
|
|
"accessibility",
|
|
"pointerEvents",
|
|
"visibility",
|
|
"position",
|
|
"inset",
|
|
"isolation",
|
|
"zIndex",
|
|
"order",
|
|
"gridColumn",
|
|
"gridColumnStart",
|
|
"gridColumnEnd",
|
|
"gridRow",
|
|
"gridRowStart",
|
|
"gridRowEnd",
|
|
"float",
|
|
"clear",
|
|
"margin",
|
|
"boxSizing",
|
|
"lineClamp",
|
|
"display",
|
|
"aspectRatio",
|
|
"size",
|
|
"height",
|
|
"maxHeight",
|
|
"minHeight",
|
|
"width",
|
|
"minWidth",
|
|
"maxWidth",
|
|
"flex",
|
|
"flexShrink",
|
|
"flexGrow",
|
|
"flexBasis",
|
|
"tableLayout",
|
|
"captionSide",
|
|
"borderCollapse",
|
|
"borderSpacing",
|
|
"transformOrigin",
|
|
"translate",
|
|
"rotate",
|
|
"skew",
|
|
"scale",
|
|
"transform",
|
|
"animation",
|
|
"cursor",
|
|
"touchAction",
|
|
"userSelect",
|
|
"resize",
|
|
"scrollSnapType",
|
|
"scrollSnapAlign",
|
|
"scrollSnapStop",
|
|
"scrollMargin",
|
|
"scrollPadding",
|
|
"listStylePosition",
|
|
"listStyleType",
|
|
"listStyleImage",
|
|
"appearance",
|
|
"columns",
|
|
"breakBefore",
|
|
"breakInside",
|
|
"breakAfter",
|
|
"gridAutoColumns",
|
|
"gridAutoFlow",
|
|
"gridAutoRows",
|
|
"gridTemplateColumns",
|
|
"gridTemplateRows",
|
|
"flexDirection",
|
|
"flexWrap",
|
|
"placeContent",
|
|
"placeItems",
|
|
"alignContent",
|
|
"alignItems",
|
|
"justifyContent",
|
|
"justifyItems",
|
|
"gap",
|
|
"space",
|
|
"divideWidth",
|
|
"divideStyle",
|
|
"divideColor",
|
|
"divideOpacity",
|
|
"placeSelf",
|
|
"alignSelf",
|
|
"justifySelf",
|
|
"overflow",
|
|
"overscrollBehavior",
|
|
"scrollBehavior",
|
|
"textOverflow",
|
|
"hyphens",
|
|
"whitespace",
|
|
"textWrap",
|
|
"wordBreak",
|
|
"borderRadius",
|
|
"borderWidth",
|
|
"borderStyle",
|
|
"borderColor",
|
|
"borderOpacity",
|
|
"backgroundColor",
|
|
"backgroundOpacity",
|
|
"backgroundImage",
|
|
"gradientColorStops",
|
|
"boxDecorationBreak",
|
|
"backgroundSize",
|
|
"backgroundAttachment",
|
|
"backgroundClip",
|
|
"backgroundPosition",
|
|
"backgroundRepeat",
|
|
"backgroundOrigin",
|
|
"fill",
|
|
"stroke",
|
|
"strokeWidth",
|
|
"objectFit",
|
|
"objectPosition",
|
|
"padding",
|
|
"textAlign",
|
|
"textIndent",
|
|
"verticalAlign",
|
|
"fontFamily",
|
|
"fontSize",
|
|
"fontWeight",
|
|
"textTransform",
|
|
"fontStyle",
|
|
"fontVariantNumeric",
|
|
"lineHeight",
|
|
"letterSpacing",
|
|
"textColor",
|
|
"textOpacity",
|
|
"textDecoration",
|
|
"textDecorationColor",
|
|
"textDecorationStyle",
|
|
"textDecorationThickness",
|
|
"textUnderlineOffset",
|
|
"fontSmoothing",
|
|
"placeholderColor",
|
|
"placeholderOpacity",
|
|
"caretColor",
|
|
"accentColor",
|
|
"opacity",
|
|
"backgroundBlendMode",
|
|
"mixBlendMode",
|
|
"boxShadow",
|
|
"boxShadowColor",
|
|
"outlineStyle",
|
|
"outlineWidth",
|
|
"outlineOffset",
|
|
"outlineColor",
|
|
"ringWidth",
|
|
"ringColor",
|
|
"ringOpacity",
|
|
"ringOffsetWidth",
|
|
"ringOffsetColor",
|
|
"blur",
|
|
"brightness",
|
|
"contrast",
|
|
"dropShadow",
|
|
"grayscale",
|
|
"hueRotate",
|
|
"invert",
|
|
"saturate",
|
|
"sepia",
|
|
"filter",
|
|
"backdropBlur",
|
|
"backdropBrightness",
|
|
"backdropContrast",
|
|
"backdropGrayscale",
|
|
"backdropHueRotate",
|
|
"backdropInvert",
|
|
"backdropOpacity",
|
|
"backdropSaturate",
|
|
"backdropSepia",
|
|
"backdropFilter",
|
|
"transitionProperty",
|
|
"transitionDelay",
|
|
"transitionDuration",
|
|
"transitionTimingFunction",
|
|
"willChange",
|
|
"content",
|
|
"forcedColorAdjust",
|
|
];
|
|
});
|
|
function wu(i, e) {
|
|
return i === void 0
|
|
? e
|
|
: Array.isArray(i)
|
|
? i
|
|
: [
|
|
...new Set(
|
|
e
|
|
.filter((r) => i !== !1 && i[r] !== !1)
|
|
.concat(Object.keys(i).filter((r) => i[r] !== !1)),
|
|
),
|
|
];
|
|
}
|
|
var bu = C(() => {
|
|
l();
|
|
});
|
|
var vu = {};
|
|
Ae(vu, { default: () => _e });
|
|
var _e,
|
|
ci = C(() => {
|
|
l();
|
|
_e = new Proxy({}, { get: () => String });
|
|
});
|
|
function Jn(i, e, t) {
|
|
(typeof h != "undefined" && h.env.JEST_WORKER_ID) ||
|
|
(t && xu.has(t)) ||
|
|
(t && xu.add(t),
|
|
console.warn(""),
|
|
e.forEach((r) => console.warn(i, "-", r)));
|
|
}
|
|
function Xn(i) {
|
|
return _e.dim(i);
|
|
}
|
|
var xu,
|
|
F,
|
|
Oe = C(() => {
|
|
l();
|
|
ci();
|
|
xu = new Set();
|
|
F = {
|
|
info(i, e) {
|
|
Jn(_e.bold(_e.cyan("info")), ...(Array.isArray(i) ? [i] : [e, i]));
|
|
},
|
|
warn(i, e) {
|
|
["content-problems"].includes(i) ||
|
|
Jn(
|
|
_e.bold(_e.yellow("warn")),
|
|
...(Array.isArray(i) ? [i] : [e, i]),
|
|
);
|
|
},
|
|
risk(i, e) {
|
|
Jn(_e.bold(_e.magenta("risk")), ...(Array.isArray(i) ? [i] : [e, i]));
|
|
},
|
|
};
|
|
});
|
|
var ku = {};
|
|
Ae(ku, { default: () => Kn });
|
|
function sr({ version: i, from: e, to: t }) {
|
|
F.warn(`${e}-color-renamed`, [
|
|
`As of Tailwind CSS ${i}, \`${e}\` has been renamed to \`${t}\`.`,
|
|
"Update your configuration file to silence this warning.",
|
|
]);
|
|
}
|
|
var Kn,
|
|
Zn = C(() => {
|
|
l();
|
|
Oe();
|
|
Kn = {
|
|
inherit: "inherit",
|
|
current: "currentColor",
|
|
transparent: "transparent",
|
|
black: "#000",
|
|
white: "#fff",
|
|
slate: {
|
|
50: "#f8fafc",
|
|
100: "#f1f5f9",
|
|
200: "#e2e8f0",
|
|
300: "#cbd5e1",
|
|
400: "#94a3b8",
|
|
500: "#64748b",
|
|
600: "#475569",
|
|
700: "#334155",
|
|
800: "#1e293b",
|
|
900: "#0f172a",
|
|
950: "#020617",
|
|
},
|
|
gray: {
|
|
50: "#f9fafb",
|
|
100: "#f3f4f6",
|
|
200: "#e5e7eb",
|
|
300: "#d1d5db",
|
|
400: "#9ca3af",
|
|
500: "#6b7280",
|
|
600: "#4b5563",
|
|
700: "#374151",
|
|
800: "#1f2937",
|
|
900: "#111827",
|
|
950: "#030712",
|
|
},
|
|
zinc: {
|
|
50: "#fafafa",
|
|
100: "#f4f4f5",
|
|
200: "#e4e4e7",
|
|
300: "#d4d4d8",
|
|
400: "#a1a1aa",
|
|
500: "#71717a",
|
|
600: "#52525b",
|
|
700: "#3f3f46",
|
|
800: "#27272a",
|
|
900: "#18181b",
|
|
950: "#09090b",
|
|
},
|
|
neutral: {
|
|
50: "#fafafa",
|
|
100: "#f5f5f5",
|
|
200: "#e5e5e5",
|
|
300: "#d4d4d4",
|
|
400: "#a3a3a3",
|
|
500: "#737373",
|
|
600: "#525252",
|
|
700: "#404040",
|
|
800: "#262626",
|
|
900: "#171717",
|
|
950: "#0a0a0a",
|
|
},
|
|
stone: {
|
|
50: "#fafaf9",
|
|
100: "#f5f5f4",
|
|
200: "#e7e5e4",
|
|
300: "#d6d3d1",
|
|
400: "#a8a29e",
|
|
500: "#78716c",
|
|
600: "#57534e",
|
|
700: "#44403c",
|
|
800: "#292524",
|
|
900: "#1c1917",
|
|
950: "#0c0a09",
|
|
},
|
|
red: {
|
|
50: "#fef2f2",
|
|
100: "#fee2e2",
|
|
200: "#fecaca",
|
|
300: "#fca5a5",
|
|
400: "#f87171",
|
|
500: "#ef4444",
|
|
600: "#dc2626",
|
|
700: "#b91c1c",
|
|
800: "#991b1b",
|
|
900: "#7f1d1d",
|
|
950: "#450a0a",
|
|
},
|
|
orange: {
|
|
50: "#fff7ed",
|
|
100: "#ffedd5",
|
|
200: "#fed7aa",
|
|
300: "#fdba74",
|
|
400: "#fb923c",
|
|
500: "#f97316",
|
|
600: "#ea580c",
|
|
700: "#c2410c",
|
|
800: "#9a3412",
|
|
900: "#7c2d12",
|
|
950: "#431407",
|
|
},
|
|
amber: {
|
|
50: "#fffbeb",
|
|
100: "#fef3c7",
|
|
200: "#fde68a",
|
|
300: "#fcd34d",
|
|
400: "#fbbf24",
|
|
500: "#f59e0b",
|
|
600: "#d97706",
|
|
700: "#b45309",
|
|
800: "#92400e",
|
|
900: "#78350f",
|
|
950: "#451a03",
|
|
},
|
|
yellow: {
|
|
50: "#fefce8",
|
|
100: "#fef9c3",
|
|
200: "#fef08a",
|
|
300: "#fde047",
|
|
400: "#facc15",
|
|
500: "#eab308",
|
|
600: "#ca8a04",
|
|
700: "#a16207",
|
|
800: "#854d0e",
|
|
900: "#713f12",
|
|
950: "#422006",
|
|
},
|
|
lime: {
|
|
50: "#f7fee7",
|
|
100: "#ecfccb",
|
|
200: "#d9f99d",
|
|
300: "#bef264",
|
|
400: "#a3e635",
|
|
500: "#84cc16",
|
|
600: "#65a30d",
|
|
700: "#4d7c0f",
|
|
800: "#3f6212",
|
|
900: "#365314",
|
|
950: "#1a2e05",
|
|
},
|
|
green: {
|
|
50: "#f0fdf4",
|
|
100: "#dcfce7",
|
|
200: "#bbf7d0",
|
|
300: "#86efac",
|
|
400: "#4ade80",
|
|
500: "#22c55e",
|
|
600: "#16a34a",
|
|
700: "#15803d",
|
|
800: "#166534",
|
|
900: "#14532d",
|
|
950: "#052e16",
|
|
},
|
|
emerald: {
|
|
50: "#ecfdf5",
|
|
100: "#d1fae5",
|
|
200: "#a7f3d0",
|
|
300: "#6ee7b7",
|
|
400: "#34d399",
|
|
500: "#10b981",
|
|
600: "#059669",
|
|
700: "#047857",
|
|
800: "#065f46",
|
|
900: "#064e3b",
|
|
950: "#022c22",
|
|
},
|
|
teal: {
|
|
50: "#f0fdfa",
|
|
100: "#ccfbf1",
|
|
200: "#99f6e4",
|
|
300: "#5eead4",
|
|
400: "#2dd4bf",
|
|
500: "#14b8a6",
|
|
600: "#0d9488",
|
|
700: "#0f766e",
|
|
800: "#115e59",
|
|
900: "#134e4a",
|
|
950: "#042f2e",
|
|
},
|
|
cyan: {
|
|
50: "#ecfeff",
|
|
100: "#cffafe",
|
|
200: "#a5f3fc",
|
|
300: "#67e8f9",
|
|
400: "#22d3ee",
|
|
500: "#06b6d4",
|
|
600: "#0891b2",
|
|
700: "#0e7490",
|
|
800: "#155e75",
|
|
900: "#164e63",
|
|
950: "#083344",
|
|
},
|
|
sky: {
|
|
50: "#f0f9ff",
|
|
100: "#e0f2fe",
|
|
200: "#bae6fd",
|
|
300: "#7dd3fc",
|
|
400: "#38bdf8",
|
|
500: "#0ea5e9",
|
|
600: "#0284c7",
|
|
700: "#0369a1",
|
|
800: "#075985",
|
|
900: "#0c4a6e",
|
|
950: "#082f49",
|
|
},
|
|
blue: {
|
|
50: "#eff6ff",
|
|
100: "#dbeafe",
|
|
200: "#bfdbfe",
|
|
300: "#93c5fd",
|
|
400: "#60a5fa",
|
|
500: "#3b82f6",
|
|
600: "#2563eb",
|
|
700: "#1d4ed8",
|
|
800: "#1e40af",
|
|
900: "#1e3a8a",
|
|
950: "#172554",
|
|
},
|
|
indigo: {
|
|
50: "#eef2ff",
|
|
100: "#e0e7ff",
|
|
200: "#c7d2fe",
|
|
300: "#a5b4fc",
|
|
400: "#818cf8",
|
|
500: "#6366f1",
|
|
600: "#4f46e5",
|
|
700: "#4338ca",
|
|
800: "#3730a3",
|
|
900: "#312e81",
|
|
950: "#1e1b4b",
|
|
},
|
|
violet: {
|
|
50: "#f5f3ff",
|
|
100: "#ede9fe",
|
|
200: "#ddd6fe",
|
|
300: "#c4b5fd",
|
|
400: "#a78bfa",
|
|
500: "#8b5cf6",
|
|
600: "#7c3aed",
|
|
700: "#6d28d9",
|
|
800: "#5b21b6",
|
|
900: "#4c1d95",
|
|
950: "#2e1065",
|
|
},
|
|
purple: {
|
|
50: "#faf5ff",
|
|
100: "#f3e8ff",
|
|
200: "#e9d5ff",
|
|
300: "#d8b4fe",
|
|
400: "#c084fc",
|
|
500: "#a855f7",
|
|
600: "#9333ea",
|
|
700: "#7e22ce",
|
|
800: "#6b21a8",
|
|
900: "#581c87",
|
|
950: "#3b0764",
|
|
},
|
|
fuchsia: {
|
|
50: "#fdf4ff",
|
|
100: "#fae8ff",
|
|
200: "#f5d0fe",
|
|
300: "#f0abfc",
|
|
400: "#e879f9",
|
|
500: "#d946ef",
|
|
600: "#c026d3",
|
|
700: "#a21caf",
|
|
800: "#86198f",
|
|
900: "#701a75",
|
|
950: "#4a044e",
|
|
},
|
|
pink: {
|
|
50: "#fdf2f8",
|
|
100: "#fce7f3",
|
|
200: "#fbcfe8",
|
|
300: "#f9a8d4",
|
|
400: "#f472b6",
|
|
500: "#ec4899",
|
|
600: "#db2777",
|
|
700: "#be185d",
|
|
800: "#9d174d",
|
|
900: "#831843",
|
|
950: "#500724",
|
|
},
|
|
rose: {
|
|
50: "#fff1f2",
|
|
100: "#ffe4e6",
|
|
200: "#fecdd3",
|
|
300: "#fda4af",
|
|
400: "#fb7185",
|
|
500: "#f43f5e",
|
|
600: "#e11d48",
|
|
700: "#be123c",
|
|
800: "#9f1239",
|
|
900: "#881337",
|
|
950: "#4c0519",
|
|
},
|
|
get lightBlue() {
|
|
return (
|
|
sr({ version: "v2.2", from: "lightBlue", to: "sky" }), this.sky
|
|
);
|
|
},
|
|
get warmGray() {
|
|
return (
|
|
sr({ version: "v3.0", from: "warmGray", to: "stone" }), this.stone
|
|
);
|
|
},
|
|
get trueGray() {
|
|
return (
|
|
sr({ version: "v3.0", from: "trueGray", to: "neutral" }),
|
|
this.neutral
|
|
);
|
|
},
|
|
get coolGray() {
|
|
return (
|
|
sr({ version: "v3.0", from: "coolGray", to: "gray" }), this.gray
|
|
);
|
|
},
|
|
get blueGray() {
|
|
return (
|
|
sr({ version: "v3.0", from: "blueGray", to: "slate" }), this.slate
|
|
);
|
|
},
|
|
};
|
|
});
|
|
function es(i, ...e) {
|
|
for (let t of e) {
|
|
for (let r in t) i?.hasOwnProperty?.(r) || (i[r] = t[r]);
|
|
for (let r of Object.getOwnPropertySymbols(t))
|
|
i?.hasOwnProperty?.(r) || (i[r] = t[r]);
|
|
}
|
|
return i;
|
|
}
|
|
var Su = C(() => {
|
|
l();
|
|
});
|
|
function Ke(i) {
|
|
if (Array.isArray(i)) return i;
|
|
let e = i.split("[").length - 1,
|
|
t = i.split("]").length - 1;
|
|
if (e !== t)
|
|
throw new Error(`Path is invalid. Has unbalanced brackets: ${i}`);
|
|
return i.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean);
|
|
}
|
|
var pi = C(() => {
|
|
l();
|
|
});
|
|
function Z(i, e) {
|
|
return di.future.includes(e)
|
|
? i.future === "all" || (i?.future?.[e] ?? Cu[e] ?? !1)
|
|
: di.experimental.includes(e)
|
|
? i.experimental === "all" || (i?.experimental?.[e] ?? Cu[e] ?? !1)
|
|
: !1;
|
|
}
|
|
function Au(i) {
|
|
return i.experimental === "all"
|
|
? di.experimental
|
|
: Object.keys(i?.experimental ?? {}).filter(
|
|
(e) => di.experimental.includes(e) && i.experimental[e],
|
|
);
|
|
}
|
|
function _u(i) {
|
|
if (h.env.JEST_WORKER_ID === void 0 && Au(i).length > 0) {
|
|
let e = Au(i)
|
|
.map((t) => _e.yellow(t))
|
|
.join(", ");
|
|
F.warn("experimental-flags-enabled", [
|
|
`You have enabled experimental features: ${e}`,
|
|
"Experimental features in Tailwind CSS are not covered by semver, may introduce breaking changes, and can change at any time.",
|
|
]);
|
|
}
|
|
}
|
|
var Cu,
|
|
di,
|
|
ze = C(() => {
|
|
l();
|
|
ci();
|
|
Oe();
|
|
(Cu = {
|
|
optimizeUniversalDefaults: !1,
|
|
generalizedModifiers: !0,
|
|
get disableColorOpacityUtilitiesByDefault() {
|
|
return !1;
|
|
},
|
|
get relativeContentPathsByDefault() {
|
|
return !1;
|
|
},
|
|
}),
|
|
(di = {
|
|
future: [
|
|
"hoverOnlyWhenSupported",
|
|
"respectDefaultRingColorOpacity",
|
|
"disableColorOpacityUtilitiesByDefault",
|
|
"relativeContentPathsByDefault",
|
|
],
|
|
experimental: ["optimizeUniversalDefaults", "generalizedModifiers"],
|
|
});
|
|
});
|
|
function Ou(i) {
|
|
(() => {
|
|
if (
|
|
i.purge ||
|
|
!i.content ||
|
|
(!Array.isArray(i.content) &&
|
|
!(typeof i.content == "object" && i.content !== null))
|
|
)
|
|
return !1;
|
|
if (Array.isArray(i.content))
|
|
return i.content.every((t) =>
|
|
typeof t == "string"
|
|
? !0
|
|
: !(
|
|
typeof t?.raw != "string" ||
|
|
(t?.extension && typeof t?.extension != "string")
|
|
),
|
|
);
|
|
if (typeof i.content == "object" && i.content !== null) {
|
|
if (
|
|
Object.keys(i.content).some(
|
|
(t) => !["files", "relative", "extract", "transform"].includes(t),
|
|
)
|
|
)
|
|
return !1;
|
|
if (Array.isArray(i.content.files)) {
|
|
if (
|
|
!i.content.files.every((t) =>
|
|
typeof t == "string"
|
|
? !0
|
|
: !(
|
|
typeof t?.raw != "string" ||
|
|
(t?.extension && typeof t?.extension != "string")
|
|
),
|
|
)
|
|
)
|
|
return !1;
|
|
if (typeof i.content.extract == "object") {
|
|
for (let t of Object.values(i.content.extract))
|
|
if (typeof t != "function") return !1;
|
|
} else if (
|
|
!(
|
|
i.content.extract === void 0 ||
|
|
typeof i.content.extract == "function"
|
|
)
|
|
)
|
|
return !1;
|
|
if (typeof i.content.transform == "object") {
|
|
for (let t of Object.values(i.content.transform))
|
|
if (typeof t != "function") return !1;
|
|
} else if (
|
|
!(
|
|
i.content.transform === void 0 ||
|
|
typeof i.content.transform == "function"
|
|
)
|
|
)
|
|
return !1;
|
|
if (
|
|
typeof i.content.relative != "boolean" &&
|
|
typeof i.content.relative != "undefined"
|
|
)
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
return !1;
|
|
})() ||
|
|
F.warn("purge-deprecation", [
|
|
"The `purge`/`content` options have changed in Tailwind CSS v3.0.",
|
|
"Update your configuration file to eliminate this warning.",
|
|
"https://tailwindcss.com/docs/upgrade-guide#configure-content-sources",
|
|
]),
|
|
(i.safelist = (() => {
|
|
let { content: t, purge: r, safelist: n } = i;
|
|
return Array.isArray(n)
|
|
? n
|
|
: Array.isArray(t?.safelist)
|
|
? t.safelist
|
|
: Array.isArray(r?.safelist)
|
|
? r.safelist
|
|
: Array.isArray(r?.options?.safelist)
|
|
? r.options.safelist
|
|
: [];
|
|
})()),
|
|
(i.blocklist = (() => {
|
|
let { blocklist: t } = i;
|
|
if (Array.isArray(t)) {
|
|
if (t.every((r) => typeof r == "string")) return t;
|
|
F.warn("blocklist-invalid", [
|
|
"The `blocklist` option must be an array of strings.",
|
|
"https://tailwindcss.com/docs/content-configuration#discarding-classes",
|
|
]);
|
|
}
|
|
return [];
|
|
})()),
|
|
typeof i.prefix == "function"
|
|
? (F.warn("prefix-function", [
|
|
"As of Tailwind CSS v3.0, `prefix` cannot be a function.",
|
|
"Update `prefix` in your configuration to be a string to eliminate this warning.",
|
|
"https://tailwindcss.com/docs/upgrade-guide#prefix-cannot-be-a-function",
|
|
]),
|
|
(i.prefix = ""))
|
|
: (i.prefix = i.prefix ?? ""),
|
|
(i.content = {
|
|
relative: (() => {
|
|
let { content: t } = i;
|
|
return t?.relative
|
|
? t.relative
|
|
: Z(i, "relativeContentPathsByDefault");
|
|
})(),
|
|
files: (() => {
|
|
let { content: t, purge: r } = i;
|
|
return Array.isArray(r)
|
|
? r
|
|
: Array.isArray(r?.content)
|
|
? r.content
|
|
: Array.isArray(t)
|
|
? t
|
|
: Array.isArray(t?.content)
|
|
? t.content
|
|
: Array.isArray(t?.files)
|
|
? t.files
|
|
: [];
|
|
})(),
|
|
extract: (() => {
|
|
let t = (() =>
|
|
i.purge?.extract
|
|
? i.purge.extract
|
|
: i.content?.extract
|
|
? i.content.extract
|
|
: i.purge?.extract?.DEFAULT
|
|
? i.purge.extract.DEFAULT
|
|
: i.content?.extract?.DEFAULT
|
|
? i.content.extract.DEFAULT
|
|
: i.purge?.options?.extractors
|
|
? i.purge.options.extractors
|
|
: i.content?.options?.extractors
|
|
? i.content.options.extractors
|
|
: {})(),
|
|
r = {},
|
|
n = (() => {
|
|
if (i.purge?.options?.defaultExtractor)
|
|
return i.purge.options.defaultExtractor;
|
|
if (i.content?.options?.defaultExtractor)
|
|
return i.content.options.defaultExtractor;
|
|
})();
|
|
if ((n !== void 0 && (r.DEFAULT = n), typeof t == "function"))
|
|
r.DEFAULT = t;
|
|
else if (Array.isArray(t))
|
|
for (let { extensions: a, extractor: s } of t ?? [])
|
|
for (let o of a) r[o] = s;
|
|
else typeof t == "object" && t !== null && Object.assign(r, t);
|
|
return r;
|
|
})(),
|
|
transform: (() => {
|
|
let t = (() =>
|
|
i.purge?.transform
|
|
? i.purge.transform
|
|
: i.content?.transform
|
|
? i.content.transform
|
|
: i.purge?.transform?.DEFAULT
|
|
? i.purge.transform.DEFAULT
|
|
: i.content?.transform?.DEFAULT
|
|
? i.content.transform.DEFAULT
|
|
: {})(),
|
|
r = {};
|
|
return (
|
|
typeof t == "function" && (r.DEFAULT = t),
|
|
typeof t == "object" && t !== null && Object.assign(r, t),
|
|
r
|
|
);
|
|
})(),
|
|
});
|
|
for (let t of i.content.files)
|
|
if (typeof t == "string" && /{([^,]*?)}/g.test(t)) {
|
|
F.warn("invalid-glob-braces", [
|
|
`The glob pattern ${Xn(t)} in your Tailwind CSS configuration is invalid.`,
|
|
`Update it to ${Xn(t.replace(/{([^,]*?)}/g, "$1"))} to silence this warning.`,
|
|
]);
|
|
break;
|
|
}
|
|
return i;
|
|
}
|
|
var Eu = C(() => {
|
|
l();
|
|
ze();
|
|
Oe();
|
|
});
|
|
function ne(i) {
|
|
if (Object.prototype.toString.call(i) !== "[object Object]") return !1;
|
|
let e = Object.getPrototypeOf(i);
|
|
return e === null || Object.getPrototypeOf(e) === null;
|
|
}
|
|
var kt = C(() => {
|
|
l();
|
|
});
|
|
function Ze(i) {
|
|
return Array.isArray(i)
|
|
? i.map((e) => Ze(e))
|
|
: typeof i == "object" && i !== null
|
|
? Object.fromEntries(Object.entries(i).map(([e, t]) => [e, Ze(t)]))
|
|
: i;
|
|
}
|
|
var hi = C(() => {
|
|
l();
|
|
});
|
|
function mt(i) {
|
|
return i.replace(/\\,/g, "\\2c ");
|
|
}
|
|
var mi = C(() => {
|
|
l();
|
|
});
|
|
var ts,
|
|
Tu = C(() => {
|
|
l();
|
|
ts = {
|
|
aliceblue: [240, 248, 255],
|
|
antiquewhite: [250, 235, 215],
|
|
aqua: [0, 255, 255],
|
|
aquamarine: [127, 255, 212],
|
|
azure: [240, 255, 255],
|
|
beige: [245, 245, 220],
|
|
bisque: [255, 228, 196],
|
|
black: [0, 0, 0],
|
|
blanchedalmond: [255, 235, 205],
|
|
blue: [0, 0, 255],
|
|
blueviolet: [138, 43, 226],
|
|
brown: [165, 42, 42],
|
|
burlywood: [222, 184, 135],
|
|
cadetblue: [95, 158, 160],
|
|
chartreuse: [127, 255, 0],
|
|
chocolate: [210, 105, 30],
|
|
coral: [255, 127, 80],
|
|
cornflowerblue: [100, 149, 237],
|
|
cornsilk: [255, 248, 220],
|
|
crimson: [220, 20, 60],
|
|
cyan: [0, 255, 255],
|
|
darkblue: [0, 0, 139],
|
|
darkcyan: [0, 139, 139],
|
|
darkgoldenrod: [184, 134, 11],
|
|
darkgray: [169, 169, 169],
|
|
darkgreen: [0, 100, 0],
|
|
darkgrey: [169, 169, 169],
|
|
darkkhaki: [189, 183, 107],
|
|
darkmagenta: [139, 0, 139],
|
|
darkolivegreen: [85, 107, 47],
|
|
darkorange: [255, 140, 0],
|
|
darkorchid: [153, 50, 204],
|
|
darkred: [139, 0, 0],
|
|
darksalmon: [233, 150, 122],
|
|
darkseagreen: [143, 188, 143],
|
|
darkslateblue: [72, 61, 139],
|
|
darkslategray: [47, 79, 79],
|
|
darkslategrey: [47, 79, 79],
|
|
darkturquoise: [0, 206, 209],
|
|
darkviolet: [148, 0, 211],
|
|
deeppink: [255, 20, 147],
|
|
deepskyblue: [0, 191, 255],
|
|
dimgray: [105, 105, 105],
|
|
dimgrey: [105, 105, 105],
|
|
dodgerblue: [30, 144, 255],
|
|
firebrick: [178, 34, 34],
|
|
floralwhite: [255, 250, 240],
|
|
forestgreen: [34, 139, 34],
|
|
fuchsia: [255, 0, 255],
|
|
gainsboro: [220, 220, 220],
|
|
ghostwhite: [248, 248, 255],
|
|
gold: [255, 215, 0],
|
|
goldenrod: [218, 165, 32],
|
|
gray: [128, 128, 128],
|
|
green: [0, 128, 0],
|
|
greenyellow: [173, 255, 47],
|
|
grey: [128, 128, 128],
|
|
honeydew: [240, 255, 240],
|
|
hotpink: [255, 105, 180],
|
|
indianred: [205, 92, 92],
|
|
indigo: [75, 0, 130],
|
|
ivory: [255, 255, 240],
|
|
khaki: [240, 230, 140],
|
|
lavender: [230, 230, 250],
|
|
lavenderblush: [255, 240, 245],
|
|
lawngreen: [124, 252, 0],
|
|
lemonchiffon: [255, 250, 205],
|
|
lightblue: [173, 216, 230],
|
|
lightcoral: [240, 128, 128],
|
|
lightcyan: [224, 255, 255],
|
|
lightgoldenrodyellow: [250, 250, 210],
|
|
lightgray: [211, 211, 211],
|
|
lightgreen: [144, 238, 144],
|
|
lightgrey: [211, 211, 211],
|
|
lightpink: [255, 182, 193],
|
|
lightsalmon: [255, 160, 122],
|
|
lightseagreen: [32, 178, 170],
|
|
lightskyblue: [135, 206, 250],
|
|
lightslategray: [119, 136, 153],
|
|
lightslategrey: [119, 136, 153],
|
|
lightsteelblue: [176, 196, 222],
|
|
lightyellow: [255, 255, 224],
|
|
lime: [0, 255, 0],
|
|
limegreen: [50, 205, 50],
|
|
linen: [250, 240, 230],
|
|
magenta: [255, 0, 255],
|
|
maroon: [128, 0, 0],
|
|
mediumaquamarine: [102, 205, 170],
|
|
mediumblue: [0, 0, 205],
|
|
mediumorchid: [186, 85, 211],
|
|
mediumpurple: [147, 112, 219],
|
|
mediumseagreen: [60, 179, 113],
|
|
mediumslateblue: [123, 104, 238],
|
|
mediumspringgreen: [0, 250, 154],
|
|
mediumturquoise: [72, 209, 204],
|
|
mediumvioletred: [199, 21, 133],
|
|
midnightblue: [25, 25, 112],
|
|
mintcream: [245, 255, 250],
|
|
mistyrose: [255, 228, 225],
|
|
moccasin: [255, 228, 181],
|
|
navajowhite: [255, 222, 173],
|
|
navy: [0, 0, 128],
|
|
oldlace: [253, 245, 230],
|
|
olive: [128, 128, 0],
|
|
olivedrab: [107, 142, 35],
|
|
orange: [255, 165, 0],
|
|
orangered: [255, 69, 0],
|
|
orchid: [218, 112, 214],
|
|
palegoldenrod: [238, 232, 170],
|
|
palegreen: [152, 251, 152],
|
|
paleturquoise: [175, 238, 238],
|
|
palevioletred: [219, 112, 147],
|
|
papayawhip: [255, 239, 213],
|
|
peachpuff: [255, 218, 185],
|
|
peru: [205, 133, 63],
|
|
pink: [255, 192, 203],
|
|
plum: [221, 160, 221],
|
|
powderblue: [176, 224, 230],
|
|
purple: [128, 0, 128],
|
|
rebeccapurple: [102, 51, 153],
|
|
red: [255, 0, 0],
|
|
rosybrown: [188, 143, 143],
|
|
royalblue: [65, 105, 225],
|
|
saddlebrown: [139, 69, 19],
|
|
salmon: [250, 128, 114],
|
|
sandybrown: [244, 164, 96],
|
|
seagreen: [46, 139, 87],
|
|
seashell: [255, 245, 238],
|
|
sienna: [160, 82, 45],
|
|
silver: [192, 192, 192],
|
|
skyblue: [135, 206, 235],
|
|
slateblue: [106, 90, 205],
|
|
slategray: [112, 128, 144],
|
|
slategrey: [112, 128, 144],
|
|
snow: [255, 250, 250],
|
|
springgreen: [0, 255, 127],
|
|
steelblue: [70, 130, 180],
|
|
tan: [210, 180, 140],
|
|
teal: [0, 128, 128],
|
|
thistle: [216, 191, 216],
|
|
tomato: [255, 99, 71],
|
|
turquoise: [64, 224, 208],
|
|
violet: [238, 130, 238],
|
|
wheat: [245, 222, 179],
|
|
white: [255, 255, 255],
|
|
whitesmoke: [245, 245, 245],
|
|
yellow: [255, 255, 0],
|
|
yellowgreen: [154, 205, 50],
|
|
};
|
|
});
|
|
function ar(i, { loose: e = !1 } = {}) {
|
|
if (typeof i != "string") return null;
|
|
if (((i = i.trim()), i === "transparent"))
|
|
return { mode: "rgb", color: ["0", "0", "0"], alpha: "0" };
|
|
if (i in ts) return { mode: "rgb", color: ts[i].map((a) => a.toString()) };
|
|
let t = i
|
|
.replace(Tb, (a, s, o, u, c) =>
|
|
["#", s, s, o, o, u, u, c ? c + c : ""].join(""),
|
|
)
|
|
.match(Eb);
|
|
if (t !== null)
|
|
return {
|
|
mode: "rgb",
|
|
color: [parseInt(t[1], 16), parseInt(t[2], 16), parseInt(t[3], 16)].map(
|
|
(a) => a.toString(),
|
|
),
|
|
alpha: t[4] ? (parseInt(t[4], 16) / 255).toString() : void 0,
|
|
};
|
|
let r = i.match(Pb) ?? i.match(Db);
|
|
if (r === null) return null;
|
|
let n = [r[2], r[3], r[4]].filter(Boolean).map((a) => a.toString());
|
|
return n.length === 2 && n[0].startsWith("var(")
|
|
? { mode: r[1], color: [n[0]], alpha: n[1] }
|
|
: (!e && n.length !== 3) ||
|
|
(n.length < 3 && !n.some((a) => /^var\(.*?\)$/.test(a)))
|
|
? null
|
|
: { mode: r[1], color: n, alpha: r[5]?.toString?.() };
|
|
}
|
|
function rs({ mode: i, color: e, alpha: t }) {
|
|
let r = t !== void 0;
|
|
return i === "rgba" || i === "hsla"
|
|
? `${i}(${e.join(", ")}${r ? `, ${t}` : ""})`
|
|
: `${i}(${e.join(" ")}${r ? ` / ${t}` : ""})`;
|
|
}
|
|
var Eb,
|
|
Tb,
|
|
et,
|
|
gi,
|
|
Pu,
|
|
tt,
|
|
Pb,
|
|
Db,
|
|
is = C(() => {
|
|
l();
|
|
Tu();
|
|
(Eb = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i),
|
|
(Tb = /^#([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i),
|
|
(et = /(?:\d+|\d*\.\d+)%?/),
|
|
(gi = /(?:\s*,\s*|\s+)/),
|
|
(Pu = /\s*[,/]\s*/),
|
|
(tt = /var\(--(?:[^ )]*?)(?:,(?:[^ )]*?|var\(--[^ )]*?\)))?\)/),
|
|
(Pb = new RegExp(
|
|
`^(rgba?)\\(\\s*(${et.source}|${tt.source})(?:${gi.source}(${et.source}|${tt.source}))?(?:${gi.source}(${et.source}|${tt.source}))?(?:${Pu.source}(${et.source}|${tt.source}))?\\s*\\)$`,
|
|
)),
|
|
(Db = new RegExp(
|
|
`^(hsla?)\\(\\s*((?:${et.source})(?:deg|rad|grad|turn)?|${tt.source})(?:${gi.source}(${et.source}|${tt.source}))?(?:${gi.source}(${et.source}|${tt.source}))?(?:${Pu.source}(${et.source}|${tt.source}))?\\s*\\)$`,
|
|
));
|
|
});
|
|
function De(i, e, t) {
|
|
if (typeof i == "function") return i({ opacityValue: e });
|
|
let r = ar(i, { loose: !0 });
|
|
return r === null ? t : rs({ ...r, alpha: e });
|
|
}
|
|
function ae({ color: i, property: e, variable: t }) {
|
|
let r = [].concat(e);
|
|
if (typeof i == "function")
|
|
return {
|
|
[t]: "1",
|
|
...Object.fromEntries(
|
|
r.map((a) => [
|
|
a,
|
|
i({ opacityVariable: t, opacityValue: `var(${t})` }),
|
|
]),
|
|
),
|
|
};
|
|
let n = ar(i);
|
|
return n === null
|
|
? Object.fromEntries(r.map((a) => [a, i]))
|
|
: n.alpha !== void 0
|
|
? Object.fromEntries(r.map((a) => [a, i]))
|
|
: {
|
|
[t]: "1",
|
|
...Object.fromEntries(
|
|
r.map((a) => [a, rs({ ...n, alpha: `var(${t})` })]),
|
|
),
|
|
};
|
|
}
|
|
var or = C(() => {
|
|
l();
|
|
is();
|
|
});
|
|
function oe(i, e) {
|
|
let t = [],
|
|
r = [],
|
|
n = 0,
|
|
a = !1;
|
|
for (let s = 0; s < i.length; s++) {
|
|
let o = i[s];
|
|
t.length === 0 &&
|
|
o === e[0] &&
|
|
!a &&
|
|
(e.length === 1 || i.slice(s, s + e.length) === e) &&
|
|
(r.push(i.slice(n, s)), (n = s + e.length)),
|
|
a ? (a = !1) : o === "\\" && (a = !0),
|
|
o === "(" || o === "[" || o === "{"
|
|
? t.push(o)
|
|
: ((o === ")" && t[t.length - 1] === "(") ||
|
|
(o === "]" && t[t.length - 1] === "[") ||
|
|
(o === "}" && t[t.length - 1] === "{")) &&
|
|
t.pop();
|
|
}
|
|
return r.push(i.slice(n)), r;
|
|
}
|
|
var St = C(() => {
|
|
l();
|
|
});
|
|
function yi(i) {
|
|
return oe(i, ",").map((t) => {
|
|
let r = t.trim(),
|
|
n = { raw: r },
|
|
a = r.split(qb),
|
|
s = new Set();
|
|
for (let o of a)
|
|
(Du.lastIndex = 0),
|
|
!s.has("KEYWORD") && Ib.has(o)
|
|
? ((n.keyword = o), s.add("KEYWORD"))
|
|
: Du.test(o)
|
|
? s.has("X")
|
|
? s.has("Y")
|
|
? s.has("BLUR")
|
|
? s.has("SPREAD") || ((n.spread = o), s.add("SPREAD"))
|
|
: ((n.blur = o), s.add("BLUR"))
|
|
: ((n.y = o), s.add("Y"))
|
|
: ((n.x = o), s.add("X"))
|
|
: n.color
|
|
? (n.unknown || (n.unknown = []), n.unknown.push(o))
|
|
: (n.color = o);
|
|
return (n.valid = n.x !== void 0 && n.y !== void 0), n;
|
|
});
|
|
}
|
|
function Iu(i) {
|
|
return i
|
|
.map((e) =>
|
|
e.valid
|
|
? [e.keyword, e.x, e.y, e.blur, e.spread, e.color]
|
|
.filter(Boolean)
|
|
.join(" ")
|
|
: e.raw,
|
|
)
|
|
.join(", ");
|
|
}
|
|
var Ib,
|
|
qb,
|
|
Du,
|
|
ns = C(() => {
|
|
l();
|
|
St();
|
|
(Ib = new Set(["inset", "inherit", "initial", "revert", "unset"])),
|
|
(qb = /\ +(?![^(]*\))/g),
|
|
(Du = /^-?(\d+|\.\d+)(.*?)$/g);
|
|
});
|
|
function ss(i) {
|
|
return Rb.some((e) => new RegExp(`^${e}\\(.*\\)`).test(i));
|
|
}
|
|
function N(i, e = null, t = !0) {
|
|
let r = e && Mb.has(e.property);
|
|
return i.startsWith("--") && !r
|
|
? `var(${i})`
|
|
: i.includes("url(")
|
|
? i
|
|
.split(/(url\(.*?\))/g)
|
|
.filter(Boolean)
|
|
.map((n) => (/^url\(.*?\)$/.test(n) ? n : N(n, e, !1)))
|
|
.join("")
|
|
: ((i = i
|
|
.replace(/([^\\])_+/g, (n, a) => a + " ".repeat(n.length - 1))
|
|
.replace(/^_/g, " ")
|
|
.replace(/\\_/g, "_")),
|
|
t && (i = i.trim()),
|
|
(i = Bb(i)),
|
|
i);
|
|
}
|
|
function Bb(i) {
|
|
let e = ["theme"],
|
|
t = [
|
|
"min-content",
|
|
"max-content",
|
|
"fit-content",
|
|
"safe-area-inset-top",
|
|
"safe-area-inset-right",
|
|
"safe-area-inset-bottom",
|
|
"safe-area-inset-left",
|
|
"titlebar-area-x",
|
|
"titlebar-area-y",
|
|
"titlebar-area-width",
|
|
"titlebar-area-height",
|
|
"keyboard-inset-top",
|
|
"keyboard-inset-right",
|
|
"keyboard-inset-bottom",
|
|
"keyboard-inset-left",
|
|
"keyboard-inset-width",
|
|
"keyboard-inset-height",
|
|
"radial-gradient",
|
|
"linear-gradient",
|
|
"conic-gradient",
|
|
"repeating-radial-gradient",
|
|
"repeating-linear-gradient",
|
|
"repeating-conic-gradient",
|
|
];
|
|
return i.replace(/(calc|min|max|clamp)\(.+\)/g, (r) => {
|
|
let n = "";
|
|
function a() {
|
|
let s = n.trimEnd();
|
|
return s[s.length - 1];
|
|
}
|
|
for (let s = 0; s < r.length; s++) {
|
|
let o = function (f) {
|
|
return f.split("").every((d, p) => r[s + p] === d);
|
|
},
|
|
u = function (f) {
|
|
let d = 1 / 0;
|
|
for (let m of f) {
|
|
let w = r.indexOf(m, s);
|
|
w !== -1 && w < d && (d = w);
|
|
}
|
|
let p = r.slice(s, d);
|
|
return (s += p.length - 1), p;
|
|
},
|
|
c = r[s];
|
|
if (o("var")) n += u([")", ","]);
|
|
else if (t.some((f) => o(f))) {
|
|
let f = t.find((d) => o(d));
|
|
(n += f), (s += f.length - 1);
|
|
} else
|
|
e.some((f) => o(f))
|
|
? (n += u([")"]))
|
|
: o("[")
|
|
? (n += u(["]"]))
|
|
: ["+", "-", "*", "/"].includes(c) &&
|
|
!["(", "+", "-", "*", "/", ","].includes(a())
|
|
? (n += ` ${c} `)
|
|
: (n += c);
|
|
}
|
|
return n.replace(/\s+/g, " ");
|
|
});
|
|
}
|
|
function as(i) {
|
|
return i.startsWith("url(");
|
|
}
|
|
function os(i) {
|
|
return !isNaN(Number(i)) || ss(i);
|
|
}
|
|
function lr(i) {
|
|
return (i.endsWith("%") && os(i.slice(0, -1))) || ss(i);
|
|
}
|
|
function ur(i) {
|
|
return (
|
|
i === "0" ||
|
|
new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${Nb}$`).test(i) ||
|
|
ss(i)
|
|
);
|
|
}
|
|
function qu(i) {
|
|
return Lb.has(i);
|
|
}
|
|
function Ru(i) {
|
|
let e = yi(N(i));
|
|
for (let t of e) if (!t.valid) return !1;
|
|
return !0;
|
|
}
|
|
function Mu(i) {
|
|
let e = 0;
|
|
return oe(i, "_").every(
|
|
(r) => (
|
|
(r = N(r)),
|
|
r.startsWith("var(")
|
|
? !0
|
|
: ar(r, { loose: !0 }) !== null
|
|
? (e++, !0)
|
|
: !1
|
|
),
|
|
)
|
|
? e > 0
|
|
: !1;
|
|
}
|
|
function Bu(i) {
|
|
let e = 0;
|
|
return oe(i, ",").every(
|
|
(r) => (
|
|
(r = N(r)),
|
|
r.startsWith("var(")
|
|
? !0
|
|
: as(r) ||
|
|
jb(r) ||
|
|
["element(", "image(", "cross-fade(", "image-set("].some((n) =>
|
|
r.startsWith(n),
|
|
)
|
|
? (e++, !0)
|
|
: !1
|
|
),
|
|
)
|
|
? e > 0
|
|
: !1;
|
|
}
|
|
function jb(i) {
|
|
i = N(i);
|
|
for (let e of $b) if (i.startsWith(`${e}(`)) return !0;
|
|
return !1;
|
|
}
|
|
function Fu(i) {
|
|
let e = 0;
|
|
return oe(i, "_").every(
|
|
(r) => (
|
|
(r = N(r)),
|
|
r.startsWith("var(") ? !0 : zb.has(r) || ur(r) || lr(r) ? (e++, !0) : !1
|
|
),
|
|
)
|
|
? e > 0
|
|
: !1;
|
|
}
|
|
function Nu(i) {
|
|
let e = 0;
|
|
return oe(i, ",").every(
|
|
(r) => (
|
|
(r = N(r)),
|
|
r.startsWith("var(")
|
|
? !0
|
|
: (r.includes(" ") && !/(['"])([^"']+)\1/g.test(r)) || /^\d/g.test(r)
|
|
? !1
|
|
: (e++, !0)
|
|
),
|
|
)
|
|
? e > 0
|
|
: !1;
|
|
}
|
|
function Lu(i) {
|
|
return Vb.has(i);
|
|
}
|
|
function $u(i) {
|
|
return Ub.has(i);
|
|
}
|
|
function ju(i) {
|
|
return Wb.has(i);
|
|
}
|
|
var Rb,
|
|
Mb,
|
|
Fb,
|
|
Nb,
|
|
Lb,
|
|
$b,
|
|
zb,
|
|
Vb,
|
|
Ub,
|
|
Wb,
|
|
fr = C(() => {
|
|
l();
|
|
is();
|
|
ns();
|
|
St();
|
|
Rb = ["min", "max", "clamp", "calc"];
|
|
Mb = new Set([
|
|
"scroll-timeline-name",
|
|
"timeline-scope",
|
|
"view-timeline-name",
|
|
"font-palette",
|
|
"scroll-timeline",
|
|
"animation-timeline",
|
|
"view-timeline",
|
|
]);
|
|
(Fb = [
|
|
"cm",
|
|
"mm",
|
|
"Q",
|
|
"in",
|
|
"pc",
|
|
"pt",
|
|
"px",
|
|
"em",
|
|
"ex",
|
|
"ch",
|
|
"rem",
|
|
"lh",
|
|
"rlh",
|
|
"vw",
|
|
"vh",
|
|
"vmin",
|
|
"vmax",
|
|
"vb",
|
|
"vi",
|
|
"svw",
|
|
"svh",
|
|
"lvw",
|
|
"lvh",
|
|
"dvw",
|
|
"dvh",
|
|
"cqw",
|
|
"cqh",
|
|
"cqi",
|
|
"cqb",
|
|
"cqmin",
|
|
"cqmax",
|
|
]),
|
|
(Nb = `(?:${Fb.join("|")})`);
|
|
Lb = new Set(["thin", "medium", "thick"]);
|
|
$b = new Set([
|
|
"conic-gradient",
|
|
"linear-gradient",
|
|
"radial-gradient",
|
|
"repeating-conic-gradient",
|
|
"repeating-linear-gradient",
|
|
"repeating-radial-gradient",
|
|
]);
|
|
zb = new Set(["center", "top", "right", "bottom", "left"]);
|
|
Vb = new Set([
|
|
"serif",
|
|
"sans-serif",
|
|
"monospace",
|
|
"cursive",
|
|
"fantasy",
|
|
"system-ui",
|
|
"ui-serif",
|
|
"ui-sans-serif",
|
|
"ui-monospace",
|
|
"ui-rounded",
|
|
"math",
|
|
"emoji",
|
|
"fangsong",
|
|
]);
|
|
Ub = new Set([
|
|
"xx-small",
|
|
"x-small",
|
|
"small",
|
|
"medium",
|
|
"large",
|
|
"x-large",
|
|
"x-large",
|
|
"xxx-large",
|
|
]);
|
|
Wb = new Set(["larger", "smaller"]);
|
|
});
|
|
function zu(i) {
|
|
let e = ["cover", "contain"];
|
|
return oe(i, ",").every((t) => {
|
|
let r = oe(t, "_").filter(Boolean);
|
|
return r.length === 1 && e.includes(r[0])
|
|
? !0
|
|
: r.length !== 1 && r.length !== 2
|
|
? !1
|
|
: r.every((n) => ur(n) || lr(n) || n === "auto");
|
|
});
|
|
}
|
|
var Vu = C(() => {
|
|
l();
|
|
fr();
|
|
St();
|
|
});
|
|
function Uu(i, e) {
|
|
i.walkClasses((t) => {
|
|
(t.value = e(t.value)),
|
|
t.raws && t.raws.value && (t.raws.value = mt(t.raws.value));
|
|
});
|
|
}
|
|
function Wu(i, e) {
|
|
if (!rt(i)) return;
|
|
let t = i.slice(1, -1);
|
|
if (!!e(t)) return N(t);
|
|
}
|
|
function Gb(i, e = {}, t) {
|
|
let r = e[i];
|
|
if (r !== void 0) return Xe(r);
|
|
if (rt(i)) {
|
|
let n = Wu(i, t);
|
|
return n === void 0 ? void 0 : Xe(n);
|
|
}
|
|
}
|
|
function wi(i, e = {}, { validate: t = () => !0 } = {}) {
|
|
let r = e.values?.[i];
|
|
return r !== void 0
|
|
? r
|
|
: e.supportsNegativeValues && i.startsWith("-")
|
|
? Gb(i.slice(1), e.values, t)
|
|
: Wu(i, t);
|
|
}
|
|
function rt(i) {
|
|
return i.startsWith("[") && i.endsWith("]");
|
|
}
|
|
function Gu(i) {
|
|
let e = i.lastIndexOf("/"),
|
|
t = i.lastIndexOf("[", e),
|
|
r = i.indexOf("]", e);
|
|
return (
|
|
i[e - 1] === "]" ||
|
|
i[e + 1] === "[" ||
|
|
(t !== -1 && r !== -1 && t < e && e < r && (e = i.lastIndexOf("/", t))),
|
|
e === -1 || e === i.length - 1
|
|
? [i, void 0]
|
|
: rt(i) && !i.includes("]/[")
|
|
? [i, void 0]
|
|
: [i.slice(0, e), i.slice(e + 1)]
|
|
);
|
|
}
|
|
function Ct(i) {
|
|
if (typeof i == "string" && i.includes("<alpha-value>")) {
|
|
let e = i;
|
|
return ({ opacityValue: t = 1 }) => e.replace("<alpha-value>", t);
|
|
}
|
|
return i;
|
|
}
|
|
function Hu(i) {
|
|
return N(i.slice(1, -1));
|
|
}
|
|
function Hb(i, e = {}, { tailwindConfig: t = {} } = {}) {
|
|
if (e.values?.[i] !== void 0) return Ct(e.values?.[i]);
|
|
let [r, n] = Gu(i);
|
|
if (n !== void 0) {
|
|
let a = e.values?.[r] ?? (rt(r) ? r.slice(1, -1) : void 0);
|
|
return a === void 0
|
|
? void 0
|
|
: ((a = Ct(a)),
|
|
rt(n)
|
|
? De(a, Hu(n))
|
|
: t.theme?.opacity?.[n] === void 0
|
|
? void 0
|
|
: De(a, t.theme.opacity[n]));
|
|
}
|
|
return wi(i, e, { validate: Mu });
|
|
}
|
|
function Yb(i, e = {}) {
|
|
return e.values?.[i];
|
|
}
|
|
function me(i) {
|
|
return (e, t) => wi(e, t, { validate: i });
|
|
}
|
|
function Qb(i, e) {
|
|
let t = i.indexOf(e);
|
|
return t === -1 ? [void 0, i] : [i.slice(0, t), i.slice(t + 1)];
|
|
}
|
|
function us(i, e, t, r) {
|
|
if (t.values && e in t.values)
|
|
for (let { type: a } of i ?? []) {
|
|
let s = ls[a](e, t, { tailwindConfig: r });
|
|
if (s !== void 0) return [s, a, null];
|
|
}
|
|
if (rt(e)) {
|
|
let a = e.slice(1, -1),
|
|
[s, o] = Qb(a, ":");
|
|
if (!/^[\w-_]+$/g.test(s)) o = a;
|
|
else if (s !== void 0 && !Yu.includes(s)) return [];
|
|
if (o.length > 0 && Yu.includes(s)) return [wi(`[${o}]`, t), s, null];
|
|
}
|
|
let n = fs(i, e, t, r);
|
|
for (let a of n) return a;
|
|
return [];
|
|
}
|
|
function* fs(i, e, t, r) {
|
|
let n = Z(r, "generalizedModifiers"),
|
|
[a, s] = Gu(e);
|
|
if (
|
|
((n &&
|
|
t.modifiers != null &&
|
|
(t.modifiers === "any" ||
|
|
(typeof t.modifiers == "object" &&
|
|
((s && rt(s)) || s in t.modifiers)))) ||
|
|
((a = e), (s = void 0)),
|
|
s !== void 0 && a === "" && (a = "DEFAULT"),
|
|
s !== void 0 && typeof t.modifiers == "object")
|
|
) {
|
|
let u = t.modifiers?.[s] ?? null;
|
|
u !== null ? (s = u) : rt(s) && (s = Hu(s));
|
|
}
|
|
for (let { type: u } of i ?? []) {
|
|
let c = ls[u](a, t, { tailwindConfig: r });
|
|
c !== void 0 && (yield [c, u, s ?? null]);
|
|
}
|
|
}
|
|
var ls,
|
|
Yu,
|
|
cr = C(() => {
|
|
l();
|
|
mi();
|
|
or();
|
|
fr();
|
|
fi();
|
|
Vu();
|
|
ze();
|
|
(ls = {
|
|
any: wi,
|
|
color: Hb,
|
|
url: me(as),
|
|
image: me(Bu),
|
|
length: me(ur),
|
|
percentage: me(lr),
|
|
position: me(Fu),
|
|
lookup: Yb,
|
|
"generic-name": me(Lu),
|
|
"family-name": me(Nu),
|
|
number: me(os),
|
|
"line-width": me(qu),
|
|
"absolute-size": me($u),
|
|
"relative-size": me(ju),
|
|
shadow: me(Ru),
|
|
size: me(zu),
|
|
}),
|
|
(Yu = Object.keys(ls));
|
|
});
|
|
function L(i) {
|
|
return typeof i == "function" ? i({}) : i;
|
|
}
|
|
var cs = C(() => {
|
|
l();
|
|
});
|
|
function At(i) {
|
|
return typeof i == "function";
|
|
}
|
|
function pr(i, ...e) {
|
|
let t = e.pop();
|
|
for (let r of e)
|
|
for (let n in r) {
|
|
let a = t(i[n], r[n]);
|
|
a === void 0
|
|
? ne(i[n]) && ne(r[n])
|
|
? (i[n] = pr({}, i[n], r[n], t))
|
|
: (i[n] = r[n])
|
|
: (i[n] = a);
|
|
}
|
|
return i;
|
|
}
|
|
function Jb(i, ...e) {
|
|
return At(i) ? i(...e) : i;
|
|
}
|
|
function Xb(i) {
|
|
return i.reduce(
|
|
(e, { extend: t }) =>
|
|
pr(e, t, (r, n) =>
|
|
r === void 0 ? [n] : Array.isArray(r) ? [n, ...r] : [n, r],
|
|
),
|
|
{},
|
|
);
|
|
}
|
|
function Kb(i) {
|
|
return { ...i.reduce((e, t) => es(e, t), {}), extend: Xb(i) };
|
|
}
|
|
function Qu(i, e) {
|
|
if (Array.isArray(i) && ne(i[0])) return i.concat(e);
|
|
if (Array.isArray(e) && ne(e[0]) && ne(i)) return [i, ...e];
|
|
if (Array.isArray(e)) return e;
|
|
}
|
|
function Zb({ extend: i, ...e }) {
|
|
return pr(e, i, (t, r) =>
|
|
!At(t) && !r.some(At)
|
|
? pr({}, t, ...r, Qu)
|
|
: (n, a) => pr({}, ...[t, ...r].map((s) => Jb(s, n, a)), Qu),
|
|
);
|
|
}
|
|
function* e0(i) {
|
|
let e = Ke(i);
|
|
if (e.length === 0 || (yield e, Array.isArray(i))) return;
|
|
let t = /^(.*?)\s*\/\s*([^/]+)$/,
|
|
r = i.match(t);
|
|
if (r !== null) {
|
|
let [, n, a] = r,
|
|
s = Ke(n);
|
|
(s.alpha = a), yield s;
|
|
}
|
|
}
|
|
function t0(i) {
|
|
let e = (t, r) => {
|
|
for (let n of e0(t)) {
|
|
let a = 0,
|
|
s = i;
|
|
for (; s != null && a < n.length; )
|
|
(s = s[n[a++]]),
|
|
(s =
|
|
At(s) && (n.alpha === void 0 || a <= n.length - 1)
|
|
? s(e, ps)
|
|
: s);
|
|
if (s !== void 0) {
|
|
if (n.alpha !== void 0) {
|
|
let o = Ct(s);
|
|
return De(o, n.alpha, L(o));
|
|
}
|
|
return ne(s) ? Ze(s) : s;
|
|
}
|
|
}
|
|
return r;
|
|
};
|
|
return (
|
|
Object.assign(e, { theme: e, ...ps }),
|
|
Object.keys(i).reduce(
|
|
(t, r) => ((t[r] = At(i[r]) ? i[r](e, ps) : i[r]), t),
|
|
{},
|
|
)
|
|
);
|
|
}
|
|
function Ju(i) {
|
|
let e = [];
|
|
return (
|
|
i.forEach((t) => {
|
|
e = [...e, t];
|
|
let r = t?.plugins ?? [];
|
|
r.length !== 0 &&
|
|
r.forEach((n) => {
|
|
n.__isOptionsFunction && (n = n()),
|
|
(e = [...e, ...Ju([n?.config ?? {}])]);
|
|
});
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function r0(i) {
|
|
return [...i].reduceRight(
|
|
(t, r) => (At(r) ? r({ corePlugins: t }) : wu(r, t)),
|
|
gu,
|
|
);
|
|
}
|
|
function i0(i) {
|
|
return [...i].reduceRight((t, r) => [...t, ...r], []);
|
|
}
|
|
function ds(i) {
|
|
let e = [...Ju(i), { prefix: "", important: !1, separator: ":" }];
|
|
return Ou(
|
|
es(
|
|
{
|
|
theme: t0(Zb(Kb(e.map((t) => t?.theme ?? {})))),
|
|
corePlugins: r0(e.map((t) => t.corePlugins)),
|
|
plugins: i0(i.map((t) => t?.plugins ?? [])),
|
|
},
|
|
...e,
|
|
),
|
|
);
|
|
}
|
|
var ps,
|
|
Xu = C(() => {
|
|
l();
|
|
fi();
|
|
yu();
|
|
bu();
|
|
Zn();
|
|
Su();
|
|
pi();
|
|
Eu();
|
|
kt();
|
|
hi();
|
|
cr();
|
|
or();
|
|
cs();
|
|
ps = {
|
|
colors: Kn,
|
|
negative(i) {
|
|
return Object.keys(i)
|
|
.filter((e) => i[e] !== "0")
|
|
.reduce((e, t) => {
|
|
let r = Xe(i[t]);
|
|
return r !== void 0 && (e[`-${t}`] = r), e;
|
|
}, {});
|
|
},
|
|
breakpoints(i) {
|
|
return Object.keys(i)
|
|
.filter((e) => typeof i[e] == "string")
|
|
.reduce((e, t) => ({ ...e, [`screen-${t}`]: i[t] }), {});
|
|
},
|
|
};
|
|
});
|
|
var bi = v((eT, Ku) => {
|
|
l();
|
|
Ku.exports = {
|
|
content: [],
|
|
presets: [],
|
|
darkMode: "media",
|
|
theme: {
|
|
accentColor: ({ theme: i }) => ({ ...i("colors"), auto: "auto" }),
|
|
animation: {
|
|
none: "none",
|
|
spin: "spin 1s linear infinite",
|
|
ping: "ping 1s cubic-bezier(0, 0, 0.2, 1) infinite",
|
|
pulse: "pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite",
|
|
bounce: "bounce 1s infinite",
|
|
},
|
|
aria: {
|
|
busy: 'busy="true"',
|
|
checked: 'checked="true"',
|
|
disabled: 'disabled="true"',
|
|
expanded: 'expanded="true"',
|
|
hidden: 'hidden="true"',
|
|
pressed: 'pressed="true"',
|
|
readonly: 'readonly="true"',
|
|
required: 'required="true"',
|
|
selected: 'selected="true"',
|
|
},
|
|
aspectRatio: { auto: "auto", square: "1 / 1", video: "16 / 9" },
|
|
backdropBlur: ({ theme: i }) => i("blur"),
|
|
backdropBrightness: ({ theme: i }) => i("brightness"),
|
|
backdropContrast: ({ theme: i }) => i("contrast"),
|
|
backdropGrayscale: ({ theme: i }) => i("grayscale"),
|
|
backdropHueRotate: ({ theme: i }) => i("hueRotate"),
|
|
backdropInvert: ({ theme: i }) => i("invert"),
|
|
backdropOpacity: ({ theme: i }) => i("opacity"),
|
|
backdropSaturate: ({ theme: i }) => i("saturate"),
|
|
backdropSepia: ({ theme: i }) => i("sepia"),
|
|
backgroundColor: ({ theme: i }) => i("colors"),
|
|
backgroundImage: {
|
|
none: "none",
|
|
"gradient-to-t": "linear-gradient(to top, var(--tw-gradient-stops))",
|
|
"gradient-to-tr":
|
|
"linear-gradient(to top right, var(--tw-gradient-stops))",
|
|
"gradient-to-r":
|
|
"linear-gradient(to right, var(--tw-gradient-stops))",
|
|
"gradient-to-br":
|
|
"linear-gradient(to bottom right, var(--tw-gradient-stops))",
|
|
"gradient-to-b":
|
|
"linear-gradient(to bottom, var(--tw-gradient-stops))",
|
|
"gradient-to-bl":
|
|
"linear-gradient(to bottom left, var(--tw-gradient-stops))",
|
|
"gradient-to-l": "linear-gradient(to left, var(--tw-gradient-stops))",
|
|
"gradient-to-tl":
|
|
"linear-gradient(to top left, var(--tw-gradient-stops))",
|
|
},
|
|
backgroundOpacity: ({ theme: i }) => i("opacity"),
|
|
backgroundPosition: {
|
|
bottom: "bottom",
|
|
center: "center",
|
|
left: "left",
|
|
"left-bottom": "left bottom",
|
|
"left-top": "left top",
|
|
right: "right",
|
|
"right-bottom": "right bottom",
|
|
"right-top": "right top",
|
|
top: "top",
|
|
},
|
|
backgroundSize: { auto: "auto", cover: "cover", contain: "contain" },
|
|
blur: {
|
|
0: "0",
|
|
none: "0",
|
|
sm: "4px",
|
|
DEFAULT: "8px",
|
|
md: "12px",
|
|
lg: "16px",
|
|
xl: "24px",
|
|
"2xl": "40px",
|
|
"3xl": "64px",
|
|
},
|
|
borderColor: ({ theme: i }) => ({
|
|
...i("colors"),
|
|
DEFAULT: i("colors.gray.200", "currentColor"),
|
|
}),
|
|
borderOpacity: ({ theme: i }) => i("opacity"),
|
|
borderRadius: {
|
|
none: "0px",
|
|
sm: "0.125rem",
|
|
DEFAULT: "0.25rem",
|
|
md: "0.375rem",
|
|
lg: "0.5rem",
|
|
xl: "0.75rem",
|
|
"2xl": "1rem",
|
|
"3xl": "1.5rem",
|
|
full: "9999px",
|
|
},
|
|
borderSpacing: ({ theme: i }) => ({ ...i("spacing") }),
|
|
borderWidth: { DEFAULT: "1px", 0: "0px", 2: "2px", 4: "4px", 8: "8px" },
|
|
boxShadow: {
|
|
sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
|
|
DEFAULT:
|
|
"0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
|
|
md: "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)",
|
|
lg: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
|
|
xl: "0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1)",
|
|
"2xl": "0 25px 50px -12px rgb(0 0 0 / 0.25)",
|
|
inner: "inset 0 2px 4px 0 rgb(0 0 0 / 0.05)",
|
|
none: "none",
|
|
},
|
|
boxShadowColor: ({ theme: i }) => i("colors"),
|
|
brightness: {
|
|
0: "0",
|
|
50: ".5",
|
|
75: ".75",
|
|
90: ".9",
|
|
95: ".95",
|
|
100: "1",
|
|
105: "1.05",
|
|
110: "1.1",
|
|
125: "1.25",
|
|
150: "1.5",
|
|
200: "2",
|
|
},
|
|
caretColor: ({ theme: i }) => i("colors"),
|
|
colors: ({ colors: i }) => ({
|
|
inherit: i.inherit,
|
|
current: i.current,
|
|
transparent: i.transparent,
|
|
black: i.black,
|
|
white: i.white,
|
|
slate: i.slate,
|
|
gray: i.gray,
|
|
zinc: i.zinc,
|
|
neutral: i.neutral,
|
|
stone: i.stone,
|
|
red: i.red,
|
|
orange: i.orange,
|
|
amber: i.amber,
|
|
yellow: i.yellow,
|
|
lime: i.lime,
|
|
green: i.green,
|
|
emerald: i.emerald,
|
|
teal: i.teal,
|
|
cyan: i.cyan,
|
|
sky: i.sky,
|
|
blue: i.blue,
|
|
indigo: i.indigo,
|
|
violet: i.violet,
|
|
purple: i.purple,
|
|
fuchsia: i.fuchsia,
|
|
pink: i.pink,
|
|
rose: i.rose,
|
|
}),
|
|
columns: {
|
|
auto: "auto",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
"3xs": "16rem",
|
|
"2xs": "18rem",
|
|
xs: "20rem",
|
|
sm: "24rem",
|
|
md: "28rem",
|
|
lg: "32rem",
|
|
xl: "36rem",
|
|
"2xl": "42rem",
|
|
"3xl": "48rem",
|
|
"4xl": "56rem",
|
|
"5xl": "64rem",
|
|
"6xl": "72rem",
|
|
"7xl": "80rem",
|
|
},
|
|
container: {},
|
|
content: { none: "none" },
|
|
contrast: {
|
|
0: "0",
|
|
50: ".5",
|
|
75: ".75",
|
|
100: "1",
|
|
125: "1.25",
|
|
150: "1.5",
|
|
200: "2",
|
|
},
|
|
cursor: {
|
|
auto: "auto",
|
|
default: "default",
|
|
pointer: "pointer",
|
|
wait: "wait",
|
|
text: "text",
|
|
move: "move",
|
|
help: "help",
|
|
"not-allowed": "not-allowed",
|
|
none: "none",
|
|
"context-menu": "context-menu",
|
|
progress: "progress",
|
|
cell: "cell",
|
|
crosshair: "crosshair",
|
|
"vertical-text": "vertical-text",
|
|
alias: "alias",
|
|
copy: "copy",
|
|
"no-drop": "no-drop",
|
|
grab: "grab",
|
|
grabbing: "grabbing",
|
|
"all-scroll": "all-scroll",
|
|
"col-resize": "col-resize",
|
|
"row-resize": "row-resize",
|
|
"n-resize": "n-resize",
|
|
"e-resize": "e-resize",
|
|
"s-resize": "s-resize",
|
|
"w-resize": "w-resize",
|
|
"ne-resize": "ne-resize",
|
|
"nw-resize": "nw-resize",
|
|
"se-resize": "se-resize",
|
|
"sw-resize": "sw-resize",
|
|
"ew-resize": "ew-resize",
|
|
"ns-resize": "ns-resize",
|
|
"nesw-resize": "nesw-resize",
|
|
"nwse-resize": "nwse-resize",
|
|
"zoom-in": "zoom-in",
|
|
"zoom-out": "zoom-out",
|
|
},
|
|
divideColor: ({ theme: i }) => i("borderColor"),
|
|
divideOpacity: ({ theme: i }) => i("borderOpacity"),
|
|
divideWidth: ({ theme: i }) => i("borderWidth"),
|
|
dropShadow: {
|
|
sm: "0 1px 1px rgb(0 0 0 / 0.05)",
|
|
DEFAULT: [
|
|
"0 1px 2px rgb(0 0 0 / 0.1)",
|
|
"0 1px 1px rgb(0 0 0 / 0.06)",
|
|
],
|
|
md: ["0 4px 3px rgb(0 0 0 / 0.07)", "0 2px 2px rgb(0 0 0 / 0.06)"],
|
|
lg: ["0 10px 8px rgb(0 0 0 / 0.04)", "0 4px 3px rgb(0 0 0 / 0.1)"],
|
|
xl: ["0 20px 13px rgb(0 0 0 / 0.03)", "0 8px 5px rgb(0 0 0 / 0.08)"],
|
|
"2xl": "0 25px 25px rgb(0 0 0 / 0.15)",
|
|
none: "0 0 #0000",
|
|
},
|
|
fill: ({ theme: i }) => ({ none: "none", ...i("colors") }),
|
|
flex: {
|
|
1: "1 1 0%",
|
|
auto: "1 1 auto",
|
|
initial: "0 1 auto",
|
|
none: "none",
|
|
},
|
|
flexBasis: ({ theme: i }) => ({
|
|
auto: "auto",
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
"1/5": "20%",
|
|
"2/5": "40%",
|
|
"3/5": "60%",
|
|
"4/5": "80%",
|
|
"1/6": "16.666667%",
|
|
"2/6": "33.333333%",
|
|
"3/6": "50%",
|
|
"4/6": "66.666667%",
|
|
"5/6": "83.333333%",
|
|
"1/12": "8.333333%",
|
|
"2/12": "16.666667%",
|
|
"3/12": "25%",
|
|
"4/12": "33.333333%",
|
|
"5/12": "41.666667%",
|
|
"6/12": "50%",
|
|
"7/12": "58.333333%",
|
|
"8/12": "66.666667%",
|
|
"9/12": "75%",
|
|
"10/12": "83.333333%",
|
|
"11/12": "91.666667%",
|
|
full: "100%",
|
|
}),
|
|
flexGrow: { 0: "0", DEFAULT: "1" },
|
|
flexShrink: { 0: "0", DEFAULT: "1" },
|
|
fontFamily: {
|
|
sans: [
|
|
"ui-sans-serif",
|
|
"system-ui",
|
|
"sans-serif",
|
|
'"Apple Color Emoji"',
|
|
'"Segoe UI Emoji"',
|
|
'"Segoe UI Symbol"',
|
|
'"Noto Color Emoji"',
|
|
],
|
|
serif: [
|
|
"ui-serif",
|
|
"Georgia",
|
|
"Cambria",
|
|
'"Times New Roman"',
|
|
"Times",
|
|
"serif",
|
|
],
|
|
mono: [
|
|
"ui-monospace",
|
|
"SFMono-Regular",
|
|
"Menlo",
|
|
"Monaco",
|
|
"Consolas",
|
|
'"Liberation Mono"',
|
|
'"Courier New"',
|
|
"monospace",
|
|
],
|
|
},
|
|
fontSize: {
|
|
xs: ["0.75rem", { lineHeight: "1rem" }],
|
|
sm: ["0.875rem", { lineHeight: "1.25rem" }],
|
|
base: ["1rem", { lineHeight: "1.5rem" }],
|
|
lg: ["1.125rem", { lineHeight: "1.75rem" }],
|
|
xl: ["1.25rem", { lineHeight: "1.75rem" }],
|
|
"2xl": ["1.5rem", { lineHeight: "2rem" }],
|
|
"3xl": ["1.875rem", { lineHeight: "2.25rem" }],
|
|
"4xl": ["2.25rem", { lineHeight: "2.5rem" }],
|
|
"5xl": ["3rem", { lineHeight: "1" }],
|
|
"6xl": ["3.75rem", { lineHeight: "1" }],
|
|
"7xl": ["4.5rem", { lineHeight: "1" }],
|
|
"8xl": ["6rem", { lineHeight: "1" }],
|
|
"9xl": ["8rem", { lineHeight: "1" }],
|
|
},
|
|
fontWeight: {
|
|
thin: "100",
|
|
extralight: "200",
|
|
light: "300",
|
|
normal: "400",
|
|
medium: "500",
|
|
semibold: "600",
|
|
bold: "700",
|
|
extrabold: "800",
|
|
black: "900",
|
|
},
|
|
gap: ({ theme: i }) => i("spacing"),
|
|
gradientColorStops: ({ theme: i }) => i("colors"),
|
|
gradientColorStopPositions: {
|
|
"0%": "0%",
|
|
"5%": "5%",
|
|
"10%": "10%",
|
|
"15%": "15%",
|
|
"20%": "20%",
|
|
"25%": "25%",
|
|
"30%": "30%",
|
|
"35%": "35%",
|
|
"40%": "40%",
|
|
"45%": "45%",
|
|
"50%": "50%",
|
|
"55%": "55%",
|
|
"60%": "60%",
|
|
"65%": "65%",
|
|
"70%": "70%",
|
|
"75%": "75%",
|
|
"80%": "80%",
|
|
"85%": "85%",
|
|
"90%": "90%",
|
|
"95%": "95%",
|
|
"100%": "100%",
|
|
},
|
|
grayscale: { 0: "0", DEFAULT: "100%" },
|
|
gridAutoColumns: {
|
|
auto: "auto",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fr: "minmax(0, 1fr)",
|
|
},
|
|
gridAutoRows: {
|
|
auto: "auto",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fr: "minmax(0, 1fr)",
|
|
},
|
|
gridColumn: {
|
|
auto: "auto",
|
|
"span-1": "span 1 / span 1",
|
|
"span-2": "span 2 / span 2",
|
|
"span-3": "span 3 / span 3",
|
|
"span-4": "span 4 / span 4",
|
|
"span-5": "span 5 / span 5",
|
|
"span-6": "span 6 / span 6",
|
|
"span-7": "span 7 / span 7",
|
|
"span-8": "span 8 / span 8",
|
|
"span-9": "span 9 / span 9",
|
|
"span-10": "span 10 / span 10",
|
|
"span-11": "span 11 / span 11",
|
|
"span-12": "span 12 / span 12",
|
|
"span-full": "1 / -1",
|
|
},
|
|
gridColumnEnd: {
|
|
auto: "auto",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
13: "13",
|
|
},
|
|
gridColumnStart: {
|
|
auto: "auto",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
13: "13",
|
|
},
|
|
gridRow: {
|
|
auto: "auto",
|
|
"span-1": "span 1 / span 1",
|
|
"span-2": "span 2 / span 2",
|
|
"span-3": "span 3 / span 3",
|
|
"span-4": "span 4 / span 4",
|
|
"span-5": "span 5 / span 5",
|
|
"span-6": "span 6 / span 6",
|
|
"span-7": "span 7 / span 7",
|
|
"span-8": "span 8 / span 8",
|
|
"span-9": "span 9 / span 9",
|
|
"span-10": "span 10 / span 10",
|
|
"span-11": "span 11 / span 11",
|
|
"span-12": "span 12 / span 12",
|
|
"span-full": "1 / -1",
|
|
},
|
|
gridRowEnd: {
|
|
auto: "auto",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
13: "13",
|
|
},
|
|
gridRowStart: {
|
|
auto: "auto",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
13: "13",
|
|
},
|
|
gridTemplateColumns: {
|
|
none: "none",
|
|
subgrid: "subgrid",
|
|
1: "repeat(1, minmax(0, 1fr))",
|
|
2: "repeat(2, minmax(0, 1fr))",
|
|
3: "repeat(3, minmax(0, 1fr))",
|
|
4: "repeat(4, minmax(0, 1fr))",
|
|
5: "repeat(5, minmax(0, 1fr))",
|
|
6: "repeat(6, minmax(0, 1fr))",
|
|
7: "repeat(7, minmax(0, 1fr))",
|
|
8: "repeat(8, minmax(0, 1fr))",
|
|
9: "repeat(9, minmax(0, 1fr))",
|
|
10: "repeat(10, minmax(0, 1fr))",
|
|
11: "repeat(11, minmax(0, 1fr))",
|
|
12: "repeat(12, minmax(0, 1fr))",
|
|
},
|
|
gridTemplateRows: {
|
|
none: "none",
|
|
subgrid: "subgrid",
|
|
1: "repeat(1, minmax(0, 1fr))",
|
|
2: "repeat(2, minmax(0, 1fr))",
|
|
3: "repeat(3, minmax(0, 1fr))",
|
|
4: "repeat(4, minmax(0, 1fr))",
|
|
5: "repeat(5, minmax(0, 1fr))",
|
|
6: "repeat(6, minmax(0, 1fr))",
|
|
7: "repeat(7, minmax(0, 1fr))",
|
|
8: "repeat(8, minmax(0, 1fr))",
|
|
9: "repeat(9, minmax(0, 1fr))",
|
|
10: "repeat(10, minmax(0, 1fr))",
|
|
11: "repeat(11, minmax(0, 1fr))",
|
|
12: "repeat(12, minmax(0, 1fr))",
|
|
},
|
|
height: ({ theme: i }) => ({
|
|
auto: "auto",
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
"1/5": "20%",
|
|
"2/5": "40%",
|
|
"3/5": "60%",
|
|
"4/5": "80%",
|
|
"1/6": "16.666667%",
|
|
"2/6": "33.333333%",
|
|
"3/6": "50%",
|
|
"4/6": "66.666667%",
|
|
"5/6": "83.333333%",
|
|
full: "100%",
|
|
screen: "100vh",
|
|
svh: "100svh",
|
|
lvh: "100lvh",
|
|
dvh: "100dvh",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
hueRotate: {
|
|
0: "0deg",
|
|
15: "15deg",
|
|
30: "30deg",
|
|
60: "60deg",
|
|
90: "90deg",
|
|
180: "180deg",
|
|
},
|
|
inset: ({ theme: i }) => ({
|
|
auto: "auto",
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
full: "100%",
|
|
}),
|
|
invert: { 0: "0", DEFAULT: "100%" },
|
|
keyframes: {
|
|
spin: { to: { transform: "rotate(360deg)" } },
|
|
ping: { "75%, 100%": { transform: "scale(2)", opacity: "0" } },
|
|
pulse: { "50%": { opacity: ".5" } },
|
|
bounce: {
|
|
"0%, 100%": {
|
|
transform: "translateY(-25%)",
|
|
animationTimingFunction: "cubic-bezier(0.8,0,1,1)",
|
|
},
|
|
"50%": {
|
|
transform: "none",
|
|
animationTimingFunction: "cubic-bezier(0,0,0.2,1)",
|
|
},
|
|
},
|
|
},
|
|
letterSpacing: {
|
|
tighter: "-0.05em",
|
|
tight: "-0.025em",
|
|
normal: "0em",
|
|
wide: "0.025em",
|
|
wider: "0.05em",
|
|
widest: "0.1em",
|
|
},
|
|
lineHeight: {
|
|
none: "1",
|
|
tight: "1.25",
|
|
snug: "1.375",
|
|
normal: "1.5",
|
|
relaxed: "1.625",
|
|
loose: "2",
|
|
3: ".75rem",
|
|
4: "1rem",
|
|
5: "1.25rem",
|
|
6: "1.5rem",
|
|
7: "1.75rem",
|
|
8: "2rem",
|
|
9: "2.25rem",
|
|
10: "2.5rem",
|
|
},
|
|
listStyleType: { none: "none", disc: "disc", decimal: "decimal" },
|
|
listStyleImage: { none: "none" },
|
|
margin: ({ theme: i }) => ({ auto: "auto", ...i("spacing") }),
|
|
lineClamp: { 1: "1", 2: "2", 3: "3", 4: "4", 5: "5", 6: "6" },
|
|
maxHeight: ({ theme: i }) => ({
|
|
...i("spacing"),
|
|
none: "none",
|
|
full: "100%",
|
|
screen: "100vh",
|
|
svh: "100svh",
|
|
lvh: "100lvh",
|
|
dvh: "100dvh",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
maxWidth: ({ theme: i, breakpoints: e }) => ({
|
|
...i("spacing"),
|
|
none: "none",
|
|
xs: "20rem",
|
|
sm: "24rem",
|
|
md: "28rem",
|
|
lg: "32rem",
|
|
xl: "36rem",
|
|
"2xl": "42rem",
|
|
"3xl": "48rem",
|
|
"4xl": "56rem",
|
|
"5xl": "64rem",
|
|
"6xl": "72rem",
|
|
"7xl": "80rem",
|
|
full: "100%",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
prose: "65ch",
|
|
...e(i("screens")),
|
|
}),
|
|
minHeight: ({ theme: i }) => ({
|
|
...i("spacing"),
|
|
full: "100%",
|
|
screen: "100vh",
|
|
svh: "100svh",
|
|
lvh: "100lvh",
|
|
dvh: "100dvh",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
minWidth: ({ theme: i }) => ({
|
|
...i("spacing"),
|
|
full: "100%",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
objectPosition: {
|
|
bottom: "bottom",
|
|
center: "center",
|
|
left: "left",
|
|
"left-bottom": "left bottom",
|
|
"left-top": "left top",
|
|
right: "right",
|
|
"right-bottom": "right bottom",
|
|
"right-top": "right top",
|
|
top: "top",
|
|
},
|
|
opacity: {
|
|
0: "0",
|
|
5: "0.05",
|
|
10: "0.1",
|
|
15: "0.15",
|
|
20: "0.2",
|
|
25: "0.25",
|
|
30: "0.3",
|
|
35: "0.35",
|
|
40: "0.4",
|
|
45: "0.45",
|
|
50: "0.5",
|
|
55: "0.55",
|
|
60: "0.6",
|
|
65: "0.65",
|
|
70: "0.7",
|
|
75: "0.75",
|
|
80: "0.8",
|
|
85: "0.85",
|
|
90: "0.9",
|
|
95: "0.95",
|
|
100: "1",
|
|
},
|
|
order: {
|
|
first: "-9999",
|
|
last: "9999",
|
|
none: "0",
|
|
1: "1",
|
|
2: "2",
|
|
3: "3",
|
|
4: "4",
|
|
5: "5",
|
|
6: "6",
|
|
7: "7",
|
|
8: "8",
|
|
9: "9",
|
|
10: "10",
|
|
11: "11",
|
|
12: "12",
|
|
},
|
|
outlineColor: ({ theme: i }) => i("colors"),
|
|
outlineOffset: { 0: "0px", 1: "1px", 2: "2px", 4: "4px", 8: "8px" },
|
|
outlineWidth: { 0: "0px", 1: "1px", 2: "2px", 4: "4px", 8: "8px" },
|
|
padding: ({ theme: i }) => i("spacing"),
|
|
placeholderColor: ({ theme: i }) => i("colors"),
|
|
placeholderOpacity: ({ theme: i }) => i("opacity"),
|
|
ringColor: ({ theme: i }) => ({
|
|
DEFAULT: i("colors.blue.500", "#3b82f6"),
|
|
...i("colors"),
|
|
}),
|
|
ringOffsetColor: ({ theme: i }) => i("colors"),
|
|
ringOffsetWidth: { 0: "0px", 1: "1px", 2: "2px", 4: "4px", 8: "8px" },
|
|
ringOpacity: ({ theme: i }) => ({ DEFAULT: "0.5", ...i("opacity") }),
|
|
ringWidth: {
|
|
DEFAULT: "3px",
|
|
0: "0px",
|
|
1: "1px",
|
|
2: "2px",
|
|
4: "4px",
|
|
8: "8px",
|
|
},
|
|
rotate: {
|
|
0: "0deg",
|
|
1: "1deg",
|
|
2: "2deg",
|
|
3: "3deg",
|
|
6: "6deg",
|
|
12: "12deg",
|
|
45: "45deg",
|
|
90: "90deg",
|
|
180: "180deg",
|
|
},
|
|
saturate: { 0: "0", 50: ".5", 100: "1", 150: "1.5", 200: "2" },
|
|
scale: {
|
|
0: "0",
|
|
50: ".5",
|
|
75: ".75",
|
|
90: ".9",
|
|
95: ".95",
|
|
100: "1",
|
|
105: "1.05",
|
|
110: "1.1",
|
|
125: "1.25",
|
|
150: "1.5",
|
|
},
|
|
screens: {
|
|
sm: "640px",
|
|
md: "768px",
|
|
lg: "1024px",
|
|
xl: "1280px",
|
|
"2xl": "1536px",
|
|
},
|
|
scrollMargin: ({ theme: i }) => ({ ...i("spacing") }),
|
|
scrollPadding: ({ theme: i }) => i("spacing"),
|
|
sepia: { 0: "0", DEFAULT: "100%" },
|
|
skew: {
|
|
0: "0deg",
|
|
1: "1deg",
|
|
2: "2deg",
|
|
3: "3deg",
|
|
6: "6deg",
|
|
12: "12deg",
|
|
},
|
|
space: ({ theme: i }) => ({ ...i("spacing") }),
|
|
spacing: {
|
|
px: "1px",
|
|
0: "0px",
|
|
0.5: "0.125rem",
|
|
1: "0.25rem",
|
|
1.5: "0.375rem",
|
|
2: "0.5rem",
|
|
2.5: "0.625rem",
|
|
3: "0.75rem",
|
|
3.5: "0.875rem",
|
|
4: "1rem",
|
|
5: "1.25rem",
|
|
6: "1.5rem",
|
|
7: "1.75rem",
|
|
8: "2rem",
|
|
9: "2.25rem",
|
|
10: "2.5rem",
|
|
11: "2.75rem",
|
|
12: "3rem",
|
|
14: "3.5rem",
|
|
16: "4rem",
|
|
20: "5rem",
|
|
24: "6rem",
|
|
28: "7rem",
|
|
32: "8rem",
|
|
36: "9rem",
|
|
40: "10rem",
|
|
44: "11rem",
|
|
48: "12rem",
|
|
52: "13rem",
|
|
56: "14rem",
|
|
60: "15rem",
|
|
64: "16rem",
|
|
72: "18rem",
|
|
80: "20rem",
|
|
96: "24rem",
|
|
},
|
|
stroke: ({ theme: i }) => ({ none: "none", ...i("colors") }),
|
|
strokeWidth: { 0: "0", 1: "1", 2: "2" },
|
|
supports: {},
|
|
data: {},
|
|
textColor: ({ theme: i }) => i("colors"),
|
|
textDecorationColor: ({ theme: i }) => i("colors"),
|
|
textDecorationThickness: {
|
|
auto: "auto",
|
|
"from-font": "from-font",
|
|
0: "0px",
|
|
1: "1px",
|
|
2: "2px",
|
|
4: "4px",
|
|
8: "8px",
|
|
},
|
|
textIndent: ({ theme: i }) => ({ ...i("spacing") }),
|
|
textOpacity: ({ theme: i }) => i("opacity"),
|
|
textUnderlineOffset: {
|
|
auto: "auto",
|
|
0: "0px",
|
|
1: "1px",
|
|
2: "2px",
|
|
4: "4px",
|
|
8: "8px",
|
|
},
|
|
transformOrigin: {
|
|
center: "center",
|
|
top: "top",
|
|
"top-right": "top right",
|
|
right: "right",
|
|
"bottom-right": "bottom right",
|
|
bottom: "bottom",
|
|
"bottom-left": "bottom left",
|
|
left: "left",
|
|
"top-left": "top left",
|
|
},
|
|
transitionDelay: {
|
|
0: "0s",
|
|
75: "75ms",
|
|
100: "100ms",
|
|
150: "150ms",
|
|
200: "200ms",
|
|
300: "300ms",
|
|
500: "500ms",
|
|
700: "700ms",
|
|
1e3: "1000ms",
|
|
},
|
|
transitionDuration: {
|
|
DEFAULT: "150ms",
|
|
0: "0s",
|
|
75: "75ms",
|
|
100: "100ms",
|
|
150: "150ms",
|
|
200: "200ms",
|
|
300: "300ms",
|
|
500: "500ms",
|
|
700: "700ms",
|
|
1e3: "1000ms",
|
|
},
|
|
transitionProperty: {
|
|
none: "none",
|
|
all: "all",
|
|
DEFAULT:
|
|
"color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter",
|
|
colors:
|
|
"color, background-color, border-color, text-decoration-color, fill, stroke",
|
|
opacity: "opacity",
|
|
shadow: "box-shadow",
|
|
transform: "transform",
|
|
},
|
|
transitionTimingFunction: {
|
|
DEFAULT: "cubic-bezier(0.4, 0, 0.2, 1)",
|
|
linear: "linear",
|
|
in: "cubic-bezier(0.4, 0, 1, 1)",
|
|
out: "cubic-bezier(0, 0, 0.2, 1)",
|
|
"in-out": "cubic-bezier(0.4, 0, 0.2, 1)",
|
|
},
|
|
translate: ({ theme: i }) => ({
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
full: "100%",
|
|
}),
|
|
size: ({ theme: i }) => ({
|
|
auto: "auto",
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
"1/5": "20%",
|
|
"2/5": "40%",
|
|
"3/5": "60%",
|
|
"4/5": "80%",
|
|
"1/6": "16.666667%",
|
|
"2/6": "33.333333%",
|
|
"3/6": "50%",
|
|
"4/6": "66.666667%",
|
|
"5/6": "83.333333%",
|
|
"1/12": "8.333333%",
|
|
"2/12": "16.666667%",
|
|
"3/12": "25%",
|
|
"4/12": "33.333333%",
|
|
"5/12": "41.666667%",
|
|
"6/12": "50%",
|
|
"7/12": "58.333333%",
|
|
"8/12": "66.666667%",
|
|
"9/12": "75%",
|
|
"10/12": "83.333333%",
|
|
"11/12": "91.666667%",
|
|
full: "100%",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
width: ({ theme: i }) => ({
|
|
auto: "auto",
|
|
...i("spacing"),
|
|
"1/2": "50%",
|
|
"1/3": "33.333333%",
|
|
"2/3": "66.666667%",
|
|
"1/4": "25%",
|
|
"2/4": "50%",
|
|
"3/4": "75%",
|
|
"1/5": "20%",
|
|
"2/5": "40%",
|
|
"3/5": "60%",
|
|
"4/5": "80%",
|
|
"1/6": "16.666667%",
|
|
"2/6": "33.333333%",
|
|
"3/6": "50%",
|
|
"4/6": "66.666667%",
|
|
"5/6": "83.333333%",
|
|
"1/12": "8.333333%",
|
|
"2/12": "16.666667%",
|
|
"3/12": "25%",
|
|
"4/12": "33.333333%",
|
|
"5/12": "41.666667%",
|
|
"6/12": "50%",
|
|
"7/12": "58.333333%",
|
|
"8/12": "66.666667%",
|
|
"9/12": "75%",
|
|
"10/12": "83.333333%",
|
|
"11/12": "91.666667%",
|
|
full: "100%",
|
|
screen: "100vw",
|
|
svw: "100svw",
|
|
lvw: "100lvw",
|
|
dvw: "100dvw",
|
|
min: "min-content",
|
|
max: "max-content",
|
|
fit: "fit-content",
|
|
}),
|
|
willChange: {
|
|
auto: "auto",
|
|
scroll: "scroll-position",
|
|
contents: "contents",
|
|
transform: "transform",
|
|
},
|
|
zIndex: {
|
|
auto: "auto",
|
|
0: "0",
|
|
10: "10",
|
|
20: "20",
|
|
30: "30",
|
|
40: "40",
|
|
50: "50",
|
|
},
|
|
},
|
|
plugins: [],
|
|
};
|
|
});
|
|
function vi(i) {
|
|
let e = (i?.presets ?? [Zu.default])
|
|
.slice()
|
|
.reverse()
|
|
.flatMap((n) => vi(n instanceof Function ? n() : n)),
|
|
t = {
|
|
respectDefaultRingColorOpacity: {
|
|
theme: {
|
|
ringColor: ({ theme: n }) => ({
|
|
DEFAULT: "#3b82f67f",
|
|
...n("colors"),
|
|
}),
|
|
},
|
|
},
|
|
disableColorOpacityUtilitiesByDefault: {
|
|
corePlugins: {
|
|
backgroundOpacity: !1,
|
|
borderOpacity: !1,
|
|
divideOpacity: !1,
|
|
placeholderOpacity: !1,
|
|
ringOpacity: !1,
|
|
textOpacity: !1,
|
|
},
|
|
},
|
|
},
|
|
r = Object.keys(t)
|
|
.filter((n) => Z(i, n))
|
|
.map((n) => t[n]);
|
|
return [i, ...r, ...e];
|
|
}
|
|
var Zu,
|
|
ef = C(() => {
|
|
l();
|
|
Zu = K(bi());
|
|
ze();
|
|
});
|
|
var tf = {};
|
|
Ae(tf, { default: () => dr });
|
|
function dr(...i) {
|
|
let [, ...e] = vi(i[0]);
|
|
return ds([...i, ...e]);
|
|
}
|
|
var hs = C(() => {
|
|
l();
|
|
Xu();
|
|
ef();
|
|
});
|
|
var rf = {};
|
|
Ae(rf, { default: () => ee });
|
|
var ee,
|
|
gt = C(() => {
|
|
l();
|
|
ee = { resolve: (i) => i, extname: (i) => "." + i.split(".").pop() };
|
|
});
|
|
function xi(i) {
|
|
return typeof i == "object" && i !== null;
|
|
}
|
|
function s0(i) {
|
|
return Object.keys(i).length === 0;
|
|
}
|
|
function nf(i) {
|
|
return typeof i == "string" || i instanceof String;
|
|
}
|
|
function ms(i) {
|
|
return xi(i) && i.config === void 0 && !s0(i)
|
|
? null
|
|
: xi(i) && i.config !== void 0 && nf(i.config)
|
|
? ee.resolve(i.config)
|
|
: xi(i) && i.config !== void 0 && xi(i.config)
|
|
? null
|
|
: nf(i)
|
|
? ee.resolve(i)
|
|
: a0();
|
|
}
|
|
function a0() {
|
|
for (let i of n0)
|
|
try {
|
|
let e = ee.resolve(i);
|
|
return re.accessSync(e), e;
|
|
} catch (e) {}
|
|
return null;
|
|
}
|
|
var n0,
|
|
sf = C(() => {
|
|
l();
|
|
je();
|
|
gt();
|
|
n0 = [
|
|
"./tailwind.config.js",
|
|
"./tailwind.config.cjs",
|
|
"./tailwind.config.mjs",
|
|
"./tailwind.config.ts",
|
|
];
|
|
});
|
|
var af = {};
|
|
Ae(af, { default: () => gs });
|
|
var gs,
|
|
ys = C(() => {
|
|
l();
|
|
gs = { parse: (i) => ({ href: i }) };
|
|
});
|
|
var ws = v(() => {
|
|
l();
|
|
});
|
|
var ki = v((fT, uf) => {
|
|
l();
|
|
("use strict");
|
|
var of = (ci(), vu),
|
|
lf = ws(),
|
|
_t = class extends Error {
|
|
constructor(e, t, r, n, a, s) {
|
|
super(e);
|
|
(this.name = "CssSyntaxError"),
|
|
(this.reason = e),
|
|
a && (this.file = a),
|
|
n && (this.source = n),
|
|
s && (this.plugin = s),
|
|
typeof t != "undefined" &&
|
|
typeof r != "undefined" &&
|
|
(typeof t == "number"
|
|
? ((this.line = t), (this.column = r))
|
|
: ((this.line = t.line),
|
|
(this.column = t.column),
|
|
(this.endLine = r.line),
|
|
(this.endColumn = r.column))),
|
|
this.setMessage(),
|
|
Error.captureStackTrace && Error.captureStackTrace(this, _t);
|
|
}
|
|
setMessage() {
|
|
(this.message = this.plugin ? this.plugin + ": " : ""),
|
|
(this.message += this.file ? this.file : "<css input>"),
|
|
typeof this.line != "undefined" &&
|
|
(this.message += ":" + this.line + ":" + this.column),
|
|
(this.message += ": " + this.reason);
|
|
}
|
|
showSourceCode(e) {
|
|
if (!this.source) return "";
|
|
let t = this.source;
|
|
e == null && (e = of.isColorSupported), lf && e && (t = lf(t));
|
|
let r = t.split(/\r?\n/),
|
|
n = Math.max(this.line - 3, 0),
|
|
a = Math.min(this.line + 2, r.length),
|
|
s = String(a).length,
|
|
o,
|
|
u;
|
|
if (e) {
|
|
let { bold: c, red: f, gray: d } = of.createColors(!0);
|
|
(o = (p) => c(f(p))), (u = (p) => d(p));
|
|
} else o = u = (c) => c;
|
|
return r.slice(n, a).map((c, f) => {
|
|
let d = n + 1 + f,
|
|
p = " " + (" " + d).slice(-s) + " | ";
|
|
if (d === this.line) {
|
|
let m =
|
|
u(p.replace(/\d/g, " ")) +
|
|
c.slice(0, this.column - 1).replace(/[^\t]/g, " ");
|
|
return (
|
|
o(">") +
|
|
u(p) +
|
|
c +
|
|
`
|
|
` +
|
|
m +
|
|
o("^")
|
|
);
|
|
}
|
|
return " " + u(p) + c;
|
|
}).join(`
|
|
`);
|
|
}
|
|
toString() {
|
|
let e = this.showSourceCode();
|
|
return (
|
|
e &&
|
|
(e =
|
|
`
|
|
|
|
` +
|
|
e +
|
|
`
|
|
`),
|
|
this.name + ": " + this.message + e
|
|
);
|
|
}
|
|
};
|
|
uf.exports = _t;
|
|
_t.default = _t;
|
|
});
|
|
var Si = v((cT, bs) => {
|
|
l();
|
|
("use strict");
|
|
bs.exports.isClean = Symbol("isClean");
|
|
bs.exports.my = Symbol("my");
|
|
});
|
|
var vs = v((pT, cf) => {
|
|
l();
|
|
("use strict");
|
|
var ff = {
|
|
colon: ": ",
|
|
indent: " ",
|
|
beforeDecl: `
|
|
`,
|
|
beforeRule: `
|
|
`,
|
|
beforeOpen: " ",
|
|
beforeClose: `
|
|
`,
|
|
beforeComment: `
|
|
`,
|
|
after: `
|
|
`,
|
|
emptyBody: "",
|
|
commentLeft: " ",
|
|
commentRight: " ",
|
|
semicolon: !1,
|
|
};
|
|
function o0(i) {
|
|
return i[0].toUpperCase() + i.slice(1);
|
|
}
|
|
var Ci = class {
|
|
constructor(e) {
|
|
this.builder = e;
|
|
}
|
|
stringify(e, t) {
|
|
if (!this[e.type])
|
|
throw new Error(
|
|
"Unknown AST node type " +
|
|
e.type +
|
|
". Maybe you need to change PostCSS stringifier.",
|
|
);
|
|
this[e.type](e, t);
|
|
}
|
|
document(e) {
|
|
this.body(e);
|
|
}
|
|
root(e) {
|
|
this.body(e), e.raws.after && this.builder(e.raws.after);
|
|
}
|
|
comment(e) {
|
|
let t = this.raw(e, "left", "commentLeft"),
|
|
r = this.raw(e, "right", "commentRight");
|
|
this.builder("/*" + t + e.text + r + "*/", e);
|
|
}
|
|
decl(e, t) {
|
|
let r = this.raw(e, "between", "colon"),
|
|
n = e.prop + r + this.rawValue(e, "value");
|
|
e.important && (n += e.raws.important || " !important"),
|
|
t && (n += ";"),
|
|
this.builder(n, e);
|
|
}
|
|
rule(e) {
|
|
this.block(e, this.rawValue(e, "selector")),
|
|
e.raws.ownSemicolon && this.builder(e.raws.ownSemicolon, e, "end");
|
|
}
|
|
atrule(e, t) {
|
|
let r = "@" + e.name,
|
|
n = e.params ? this.rawValue(e, "params") : "";
|
|
if (
|
|
(typeof e.raws.afterName != "undefined"
|
|
? (r += e.raws.afterName)
|
|
: n && (r += " "),
|
|
e.nodes)
|
|
)
|
|
this.block(e, r + n);
|
|
else {
|
|
let a = (e.raws.between || "") + (t ? ";" : "");
|
|
this.builder(r + n + a, e);
|
|
}
|
|
}
|
|
body(e) {
|
|
let t = e.nodes.length - 1;
|
|
for (; t > 0 && e.nodes[t].type === "comment"; ) t -= 1;
|
|
let r = this.raw(e, "semicolon");
|
|
for (let n = 0; n < e.nodes.length; n++) {
|
|
let a = e.nodes[n],
|
|
s = this.raw(a, "before");
|
|
s && this.builder(s), this.stringify(a, t !== n || r);
|
|
}
|
|
}
|
|
block(e, t) {
|
|
let r = this.raw(e, "between", "beforeOpen");
|
|
this.builder(t + r + "{", e, "start");
|
|
let n;
|
|
e.nodes && e.nodes.length
|
|
? (this.body(e), (n = this.raw(e, "after")))
|
|
: (n = this.raw(e, "after", "emptyBody")),
|
|
n && this.builder(n),
|
|
this.builder("}", e, "end");
|
|
}
|
|
raw(e, t, r) {
|
|
let n;
|
|
if ((r || (r = t), t && ((n = e.raws[t]), typeof n != "undefined")))
|
|
return n;
|
|
let a = e.parent;
|
|
if (
|
|
r === "before" &&
|
|
(!a ||
|
|
(a.type === "root" && a.first === e) ||
|
|
(a && a.type === "document"))
|
|
)
|
|
return "";
|
|
if (!a) return ff[r];
|
|
let s = e.root();
|
|
if (
|
|
(s.rawCache || (s.rawCache = {}), typeof s.rawCache[r] != "undefined")
|
|
)
|
|
return s.rawCache[r];
|
|
if (r === "before" || r === "after") return this.beforeAfter(e, r);
|
|
{
|
|
let o = "raw" + o0(r);
|
|
this[o]
|
|
? (n = this[o](s, e))
|
|
: s.walk((u) => {
|
|
if (((n = u.raws[t]), typeof n != "undefined")) return !1;
|
|
});
|
|
}
|
|
return typeof n == "undefined" && (n = ff[r]), (s.rawCache[r] = n), n;
|
|
}
|
|
rawSemicolon(e) {
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
if (
|
|
r.nodes &&
|
|
r.nodes.length &&
|
|
r.last.type === "decl" &&
|
|
((t = r.raws.semicolon), typeof t != "undefined")
|
|
)
|
|
return !1;
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
rawEmptyBody(e) {
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
if (
|
|
r.nodes &&
|
|
r.nodes.length === 0 &&
|
|
((t = r.raws.after), typeof t != "undefined")
|
|
)
|
|
return !1;
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
rawIndent(e) {
|
|
if (e.raws.indent) return e.raws.indent;
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
let n = r.parent;
|
|
if (
|
|
n &&
|
|
n !== e &&
|
|
n.parent &&
|
|
n.parent === e &&
|
|
typeof r.raws.before != "undefined"
|
|
) {
|
|
let a = r.raws.before.split(`
|
|
`);
|
|
return (t = a[a.length - 1]), (t = t.replace(/\S/g, "")), !1;
|
|
}
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
rawBeforeComment(e, t) {
|
|
let r;
|
|
return (
|
|
e.walkComments((n) => {
|
|
if (typeof n.raws.before != "undefined")
|
|
return (
|
|
(r = n.raws.before),
|
|
r.includes(`
|
|
`) && (r = r.replace(/[^\n]+$/, "")),
|
|
!1
|
|
);
|
|
}),
|
|
typeof r == "undefined"
|
|
? (r = this.raw(t, null, "beforeDecl"))
|
|
: r && (r = r.replace(/\S/g, "")),
|
|
r
|
|
);
|
|
}
|
|
rawBeforeDecl(e, t) {
|
|
let r;
|
|
return (
|
|
e.walkDecls((n) => {
|
|
if (typeof n.raws.before != "undefined")
|
|
return (
|
|
(r = n.raws.before),
|
|
r.includes(`
|
|
`) && (r = r.replace(/[^\n]+$/, "")),
|
|
!1
|
|
);
|
|
}),
|
|
typeof r == "undefined"
|
|
? (r = this.raw(t, null, "beforeRule"))
|
|
: r && (r = r.replace(/\S/g, "")),
|
|
r
|
|
);
|
|
}
|
|
rawBeforeRule(e) {
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
if (
|
|
r.nodes &&
|
|
(r.parent !== e || e.first !== r) &&
|
|
typeof r.raws.before != "undefined"
|
|
)
|
|
return (
|
|
(t = r.raws.before),
|
|
t.includes(`
|
|
`) && (t = t.replace(/[^\n]+$/, "")),
|
|
!1
|
|
);
|
|
}),
|
|
t && (t = t.replace(/\S/g, "")),
|
|
t
|
|
);
|
|
}
|
|
rawBeforeClose(e) {
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
if (
|
|
r.nodes &&
|
|
r.nodes.length > 0 &&
|
|
typeof r.raws.after != "undefined"
|
|
)
|
|
return (
|
|
(t = r.raws.after),
|
|
t.includes(`
|
|
`) && (t = t.replace(/[^\n]+$/, "")),
|
|
!1
|
|
);
|
|
}),
|
|
t && (t = t.replace(/\S/g, "")),
|
|
t
|
|
);
|
|
}
|
|
rawBeforeOpen(e) {
|
|
let t;
|
|
return (
|
|
e.walk((r) => {
|
|
if (
|
|
r.type !== "decl" &&
|
|
((t = r.raws.between), typeof t != "undefined")
|
|
)
|
|
return !1;
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
rawColon(e) {
|
|
let t;
|
|
return (
|
|
e.walkDecls((r) => {
|
|
if (typeof r.raws.between != "undefined")
|
|
return (t = r.raws.between.replace(/[^\s:]/g, "")), !1;
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
beforeAfter(e, t) {
|
|
let r;
|
|
e.type === "decl"
|
|
? (r = this.raw(e, null, "beforeDecl"))
|
|
: e.type === "comment"
|
|
? (r = this.raw(e, null, "beforeComment"))
|
|
: t === "before"
|
|
? (r = this.raw(e, null, "beforeRule"))
|
|
: (r = this.raw(e, null, "beforeClose"));
|
|
let n = e.parent,
|
|
a = 0;
|
|
for (; n && n.type !== "root"; ) (a += 1), (n = n.parent);
|
|
if (
|
|
r.includes(`
|
|
`)
|
|
) {
|
|
let s = this.raw(e, null, "indent");
|
|
if (s.length) for (let o = 0; o < a; o++) r += s;
|
|
}
|
|
return r;
|
|
}
|
|
rawValue(e, t) {
|
|
let r = e[t],
|
|
n = e.raws[t];
|
|
return n && n.value === r ? n.raw : r;
|
|
}
|
|
};
|
|
cf.exports = Ci;
|
|
Ci.default = Ci;
|
|
});
|
|
var hr = v((dT, pf) => {
|
|
l();
|
|
("use strict");
|
|
var l0 = vs();
|
|
function xs(i, e) {
|
|
new l0(e).stringify(i);
|
|
}
|
|
pf.exports = xs;
|
|
xs.default = xs;
|
|
});
|
|
var mr = v((hT, df) => {
|
|
l();
|
|
("use strict");
|
|
var { isClean: Ai, my: u0 } = Si(),
|
|
f0 = ki(),
|
|
c0 = vs(),
|
|
p0 = hr();
|
|
function ks(i, e) {
|
|
let t = new i.constructor();
|
|
for (let r in i) {
|
|
if (!Object.prototype.hasOwnProperty.call(i, r) || r === "proxyCache")
|
|
continue;
|
|
let n = i[r],
|
|
a = typeof n;
|
|
r === "parent" && a === "object"
|
|
? e && (t[r] = e)
|
|
: r === "source"
|
|
? (t[r] = n)
|
|
: Array.isArray(n)
|
|
? (t[r] = n.map((s) => ks(s, t)))
|
|
: (a === "object" && n !== null && (n = ks(n)), (t[r] = n));
|
|
}
|
|
return t;
|
|
}
|
|
var _i = class {
|
|
constructor(e = {}) {
|
|
(this.raws = {}), (this[Ai] = !1), (this[u0] = !0);
|
|
for (let t in e)
|
|
if (t === "nodes") {
|
|
this.nodes = [];
|
|
for (let r of e[t])
|
|
typeof r.clone == "function"
|
|
? this.append(r.clone())
|
|
: this.append(r);
|
|
} else this[t] = e[t];
|
|
}
|
|
error(e, t = {}) {
|
|
if (this.source) {
|
|
let { start: r, end: n } = this.rangeBy(t);
|
|
return this.source.input.error(
|
|
e,
|
|
{ line: r.line, column: r.column },
|
|
{ line: n.line, column: n.column },
|
|
t,
|
|
);
|
|
}
|
|
return new f0(e);
|
|
}
|
|
warn(e, t, r) {
|
|
let n = { node: this };
|
|
for (let a in r) n[a] = r[a];
|
|
return e.warn(t, n);
|
|
}
|
|
remove() {
|
|
return (
|
|
this.parent && this.parent.removeChild(this),
|
|
(this.parent = void 0),
|
|
this
|
|
);
|
|
}
|
|
toString(e = p0) {
|
|
e.stringify && (e = e.stringify);
|
|
let t = "";
|
|
return (
|
|
e(this, (r) => {
|
|
t += r;
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
assign(e = {}) {
|
|
for (let t in e) this[t] = e[t];
|
|
return this;
|
|
}
|
|
clone(e = {}) {
|
|
let t = ks(this);
|
|
for (let r in e) t[r] = e[r];
|
|
return t;
|
|
}
|
|
cloneBefore(e = {}) {
|
|
let t = this.clone(e);
|
|
return this.parent.insertBefore(this, t), t;
|
|
}
|
|
cloneAfter(e = {}) {
|
|
let t = this.clone(e);
|
|
return this.parent.insertAfter(this, t), t;
|
|
}
|
|
replaceWith(...e) {
|
|
if (this.parent) {
|
|
let t = this,
|
|
r = !1;
|
|
for (let n of e)
|
|
n === this
|
|
? (r = !0)
|
|
: r
|
|
? (this.parent.insertAfter(t, n), (t = n))
|
|
: this.parent.insertBefore(t, n);
|
|
r || this.remove();
|
|
}
|
|
return this;
|
|
}
|
|
next() {
|
|
if (!this.parent) return;
|
|
let e = this.parent.index(this);
|
|
return this.parent.nodes[e + 1];
|
|
}
|
|
prev() {
|
|
if (!this.parent) return;
|
|
let e = this.parent.index(this);
|
|
return this.parent.nodes[e - 1];
|
|
}
|
|
before(e) {
|
|
return this.parent.insertBefore(this, e), this;
|
|
}
|
|
after(e) {
|
|
return this.parent.insertAfter(this, e), this;
|
|
}
|
|
root() {
|
|
let e = this;
|
|
for (; e.parent && e.parent.type !== "document"; ) e = e.parent;
|
|
return e;
|
|
}
|
|
raw(e, t) {
|
|
return new c0().raw(this, e, t);
|
|
}
|
|
cleanRaws(e) {
|
|
delete this.raws.before,
|
|
delete this.raws.after,
|
|
e || delete this.raws.between;
|
|
}
|
|
toJSON(e, t) {
|
|
let r = {},
|
|
n = t == null;
|
|
t = t || new Map();
|
|
let a = 0;
|
|
for (let s in this) {
|
|
if (
|
|
!Object.prototype.hasOwnProperty.call(this, s) ||
|
|
s === "parent" ||
|
|
s === "proxyCache"
|
|
)
|
|
continue;
|
|
let o = this[s];
|
|
if (Array.isArray(o))
|
|
r[s] = o.map((u) =>
|
|
typeof u == "object" && u.toJSON ? u.toJSON(null, t) : u,
|
|
);
|
|
else if (typeof o == "object" && o.toJSON) r[s] = o.toJSON(null, t);
|
|
else if (s === "source") {
|
|
let u = t.get(o.input);
|
|
u == null && ((u = a), t.set(o.input, a), a++),
|
|
(r[s] = { inputId: u, start: o.start, end: o.end });
|
|
} else r[s] = o;
|
|
}
|
|
return n && (r.inputs = [...t.keys()].map((s) => s.toJSON())), r;
|
|
}
|
|
positionInside(e) {
|
|
let t = this.toString(),
|
|
r = this.source.start.column,
|
|
n = this.source.start.line;
|
|
for (let a = 0; a < e; a++)
|
|
t[a] ===
|
|
`
|
|
`
|
|
? ((r = 1), (n += 1))
|
|
: (r += 1);
|
|
return { line: n, column: r };
|
|
}
|
|
positionBy(e) {
|
|
let t = this.source.start;
|
|
if (e.index) t = this.positionInside(e.index);
|
|
else if (e.word) {
|
|
let r = this.toString().indexOf(e.word);
|
|
r !== -1 && (t = this.positionInside(r));
|
|
}
|
|
return t;
|
|
}
|
|
rangeBy(e) {
|
|
let t = {
|
|
line: this.source.start.line,
|
|
column: this.source.start.column,
|
|
},
|
|
r = this.source.end
|
|
? { line: this.source.end.line, column: this.source.end.column + 1 }
|
|
: { line: t.line, column: t.column + 1 };
|
|
if (e.word) {
|
|
let n = this.toString().indexOf(e.word);
|
|
n !== -1 &&
|
|
((t = this.positionInside(n)),
|
|
(r = this.positionInside(n + e.word.length)));
|
|
} else
|
|
e.start
|
|
? (t = { line: e.start.line, column: e.start.column })
|
|
: e.index && (t = this.positionInside(e.index)),
|
|
e.end
|
|
? (r = { line: e.end.line, column: e.end.column })
|
|
: e.endIndex
|
|
? (r = this.positionInside(e.endIndex))
|
|
: e.index && (r = this.positionInside(e.index + 1));
|
|
return (
|
|
(r.line < t.line || (r.line === t.line && r.column <= t.column)) &&
|
|
(r = { line: t.line, column: t.column + 1 }),
|
|
{ start: t, end: r }
|
|
);
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
set(e, t, r) {
|
|
return (
|
|
e[t] === r ||
|
|
((e[t] = r),
|
|
(t === "prop" ||
|
|
t === "value" ||
|
|
t === "name" ||
|
|
t === "params" ||
|
|
t === "important" ||
|
|
t === "text") &&
|
|
e.markDirty()),
|
|
!0
|
|
);
|
|
},
|
|
get(e, t) {
|
|
return t === "proxyOf"
|
|
? e
|
|
: t === "root"
|
|
? () => e.root().toProxy()
|
|
: e[t];
|
|
},
|
|
};
|
|
}
|
|
toProxy() {
|
|
return (
|
|
this.proxyCache ||
|
|
(this.proxyCache = new Proxy(this, this.getProxyProcessor())),
|
|
this.proxyCache
|
|
);
|
|
}
|
|
addToError(e) {
|
|
if (
|
|
((e.postcssNode = this),
|
|
e.stack && this.source && /\n\s{4}at /.test(e.stack))
|
|
) {
|
|
let t = this.source;
|
|
e.stack = e.stack.replace(
|
|
/\n\s{4}at /,
|
|
`$&${t.input.from}:${t.start.line}:${t.start.column}$&`,
|
|
);
|
|
}
|
|
return e;
|
|
}
|
|
markDirty() {
|
|
if (this[Ai]) {
|
|
this[Ai] = !1;
|
|
let e = this;
|
|
for (; (e = e.parent); ) e[Ai] = !1;
|
|
}
|
|
}
|
|
get proxyOf() {
|
|
return this;
|
|
}
|
|
};
|
|
df.exports = _i;
|
|
_i.default = _i;
|
|
});
|
|
var gr = v((mT, hf) => {
|
|
l();
|
|
("use strict");
|
|
var d0 = mr(),
|
|
Oi = class extends d0 {
|
|
constructor(e) {
|
|
e &&
|
|
typeof e.value != "undefined" &&
|
|
typeof e.value != "string" &&
|
|
(e = { ...e, value: String(e.value) });
|
|
super(e);
|
|
this.type = "decl";
|
|
}
|
|
get variable() {
|
|
return this.prop.startsWith("--") || this.prop[0] === "$";
|
|
}
|
|
};
|
|
hf.exports = Oi;
|
|
Oi.default = Oi;
|
|
});
|
|
var Ss = v((gT, mf) => {
|
|
l();
|
|
mf.exports = function (i, e) {
|
|
return {
|
|
generate: () => {
|
|
let t = "";
|
|
return (
|
|
i(e, (r) => {
|
|
t += r;
|
|
}),
|
|
[t]
|
|
);
|
|
},
|
|
};
|
|
};
|
|
});
|
|
var yr = v((yT, gf) => {
|
|
l();
|
|
("use strict");
|
|
var h0 = mr(),
|
|
Ei = class extends h0 {
|
|
constructor(e) {
|
|
super(e);
|
|
this.type = "comment";
|
|
}
|
|
};
|
|
gf.exports = Ei;
|
|
Ei.default = Ei;
|
|
});
|
|
var it = v((wT, Af) => {
|
|
l();
|
|
("use strict");
|
|
var { isClean: yf, my: wf } = Si(),
|
|
bf = gr(),
|
|
vf = yr(),
|
|
m0 = mr(),
|
|
xf,
|
|
Cs,
|
|
As,
|
|
kf;
|
|
function Sf(i) {
|
|
return i.map(
|
|
(e) => (e.nodes && (e.nodes = Sf(e.nodes)), delete e.source, e),
|
|
);
|
|
}
|
|
function Cf(i) {
|
|
if (((i[yf] = !1), i.proxyOf.nodes)) for (let e of i.proxyOf.nodes) Cf(e);
|
|
}
|
|
var we = class extends m0 {
|
|
push(e) {
|
|
return (e.parent = this), this.proxyOf.nodes.push(e), this;
|
|
}
|
|
each(e) {
|
|
if (!this.proxyOf.nodes) return;
|
|
let t = this.getIterator(),
|
|
r,
|
|
n;
|
|
for (
|
|
;
|
|
this.indexes[t] < this.proxyOf.nodes.length &&
|
|
((r = this.indexes[t]), (n = e(this.proxyOf.nodes[r], r)), n !== !1);
|
|
|
|
)
|
|
this.indexes[t] += 1;
|
|
return delete this.indexes[t], n;
|
|
}
|
|
walk(e) {
|
|
return this.each((t, r) => {
|
|
let n;
|
|
try {
|
|
n = e(t, r);
|
|
} catch (a) {
|
|
throw t.addToError(a);
|
|
}
|
|
return n !== !1 && t.walk && (n = t.walk(e)), n;
|
|
});
|
|
}
|
|
walkDecls(e, t) {
|
|
return t
|
|
? e instanceof RegExp
|
|
? this.walk((r, n) => {
|
|
if (r.type === "decl" && e.test(r.prop)) return t(r, n);
|
|
})
|
|
: this.walk((r, n) => {
|
|
if (r.type === "decl" && r.prop === e) return t(r, n);
|
|
})
|
|
: ((t = e),
|
|
this.walk((r, n) => {
|
|
if (r.type === "decl") return t(r, n);
|
|
}));
|
|
}
|
|
walkRules(e, t) {
|
|
return t
|
|
? e instanceof RegExp
|
|
? this.walk((r, n) => {
|
|
if (r.type === "rule" && e.test(r.selector)) return t(r, n);
|
|
})
|
|
: this.walk((r, n) => {
|
|
if (r.type === "rule" && r.selector === e) return t(r, n);
|
|
})
|
|
: ((t = e),
|
|
this.walk((r, n) => {
|
|
if (r.type === "rule") return t(r, n);
|
|
}));
|
|
}
|
|
walkAtRules(e, t) {
|
|
return t
|
|
? e instanceof RegExp
|
|
? this.walk((r, n) => {
|
|
if (r.type === "atrule" && e.test(r.name)) return t(r, n);
|
|
})
|
|
: this.walk((r, n) => {
|
|
if (r.type === "atrule" && r.name === e) return t(r, n);
|
|
})
|
|
: ((t = e),
|
|
this.walk((r, n) => {
|
|
if (r.type === "atrule") return t(r, n);
|
|
}));
|
|
}
|
|
walkComments(e) {
|
|
return this.walk((t, r) => {
|
|
if (t.type === "comment") return e(t, r);
|
|
});
|
|
}
|
|
append(...e) {
|
|
for (let t of e) {
|
|
let r = this.normalize(t, this.last);
|
|
for (let n of r) this.proxyOf.nodes.push(n);
|
|
}
|
|
return this.markDirty(), this;
|
|
}
|
|
prepend(...e) {
|
|
e = e.reverse();
|
|
for (let t of e) {
|
|
let r = this.normalize(t, this.first, "prepend").reverse();
|
|
for (let n of r) this.proxyOf.nodes.unshift(n);
|
|
for (let n in this.indexes)
|
|
this.indexes[n] = this.indexes[n] + r.length;
|
|
}
|
|
return this.markDirty(), this;
|
|
}
|
|
cleanRaws(e) {
|
|
if ((super.cleanRaws(e), this.nodes))
|
|
for (let t of this.nodes) t.cleanRaws(e);
|
|
}
|
|
insertBefore(e, t) {
|
|
let r = this.index(e),
|
|
n = r === 0 ? "prepend" : !1,
|
|
a = this.normalize(t, this.proxyOf.nodes[r], n).reverse();
|
|
r = this.index(e);
|
|
for (let o of a) this.proxyOf.nodes.splice(r, 0, o);
|
|
let s;
|
|
for (let o in this.indexes)
|
|
(s = this.indexes[o]), r <= s && (this.indexes[o] = s + a.length);
|
|
return this.markDirty(), this;
|
|
}
|
|
insertAfter(e, t) {
|
|
let r = this.index(e),
|
|
n = this.normalize(t, this.proxyOf.nodes[r]).reverse();
|
|
r = this.index(e);
|
|
for (let s of n) this.proxyOf.nodes.splice(r + 1, 0, s);
|
|
let a;
|
|
for (let s in this.indexes)
|
|
(a = this.indexes[s]), r < a && (this.indexes[s] = a + n.length);
|
|
return this.markDirty(), this;
|
|
}
|
|
removeChild(e) {
|
|
(e = this.index(e)),
|
|
(this.proxyOf.nodes[e].parent = void 0),
|
|
this.proxyOf.nodes.splice(e, 1);
|
|
let t;
|
|
for (let r in this.indexes)
|
|
(t = this.indexes[r]), t >= e && (this.indexes[r] = t - 1);
|
|
return this.markDirty(), this;
|
|
}
|
|
removeAll() {
|
|
for (let e of this.proxyOf.nodes) e.parent = void 0;
|
|
return (this.proxyOf.nodes = []), this.markDirty(), this;
|
|
}
|
|
replaceValues(e, t, r) {
|
|
return (
|
|
r || ((r = t), (t = {})),
|
|
this.walkDecls((n) => {
|
|
(t.props && !t.props.includes(n.prop)) ||
|
|
(t.fast && !n.value.includes(t.fast)) ||
|
|
(n.value = n.value.replace(e, r));
|
|
}),
|
|
this.markDirty(),
|
|
this
|
|
);
|
|
}
|
|
every(e) {
|
|
return this.nodes.every(e);
|
|
}
|
|
some(e) {
|
|
return this.nodes.some(e);
|
|
}
|
|
index(e) {
|
|
return typeof e == "number"
|
|
? e
|
|
: (e.proxyOf && (e = e.proxyOf), this.proxyOf.nodes.indexOf(e));
|
|
}
|
|
get first() {
|
|
if (!!this.proxyOf.nodes) return this.proxyOf.nodes[0];
|
|
}
|
|
get last() {
|
|
if (!!this.proxyOf.nodes)
|
|
return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
|
|
}
|
|
normalize(e, t) {
|
|
if (typeof e == "string") e = Sf(xf(e).nodes);
|
|
else if (Array.isArray(e)) {
|
|
e = e.slice(0);
|
|
for (let n of e) n.parent && n.parent.removeChild(n, "ignore");
|
|
} else if (e.type === "root" && this.type !== "document") {
|
|
e = e.nodes.slice(0);
|
|
for (let n of e) n.parent && n.parent.removeChild(n, "ignore");
|
|
} else if (e.type) e = [e];
|
|
else if (e.prop) {
|
|
if (typeof e.value == "undefined")
|
|
throw new Error("Value field is missed in node creation");
|
|
typeof e.value != "string" && (e.value = String(e.value)),
|
|
(e = [new bf(e)]);
|
|
} else if (e.selector) e = [new Cs(e)];
|
|
else if (e.name) e = [new As(e)];
|
|
else if (e.text) e = [new vf(e)];
|
|
else throw new Error("Unknown node type in node creation");
|
|
return e.map(
|
|
(n) => (
|
|
n[wf] || we.rebuild(n),
|
|
(n = n.proxyOf),
|
|
n.parent && n.parent.removeChild(n),
|
|
n[yf] && Cf(n),
|
|
typeof n.raws.before == "undefined" &&
|
|
t &&
|
|
typeof t.raws.before != "undefined" &&
|
|
(n.raws.before = t.raws.before.replace(/\S/g, "")),
|
|
(n.parent = this.proxyOf),
|
|
n
|
|
),
|
|
);
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
set(e, t, r) {
|
|
return (
|
|
e[t] === r ||
|
|
((e[t] = r),
|
|
(t === "name" || t === "params" || t === "selector") &&
|
|
e.markDirty()),
|
|
!0
|
|
);
|
|
},
|
|
get(e, t) {
|
|
return t === "proxyOf"
|
|
? e
|
|
: e[t]
|
|
? t === "each" || (typeof t == "string" && t.startsWith("walk"))
|
|
? (...r) =>
|
|
e[t](
|
|
...r.map((n) =>
|
|
typeof n == "function"
|
|
? (a, s) => n(a.toProxy(), s)
|
|
: n,
|
|
),
|
|
)
|
|
: t === "every" || t === "some"
|
|
? (r) => e[t]((n, ...a) => r(n.toProxy(), ...a))
|
|
: t === "root"
|
|
? () => e.root().toProxy()
|
|
: t === "nodes"
|
|
? e.nodes.map((r) => r.toProxy())
|
|
: t === "first" || t === "last"
|
|
? e[t].toProxy()
|
|
: e[t]
|
|
: e[t];
|
|
},
|
|
};
|
|
}
|
|
getIterator() {
|
|
this.lastEach || (this.lastEach = 0),
|
|
this.indexes || (this.indexes = {}),
|
|
(this.lastEach += 1);
|
|
let e = this.lastEach;
|
|
return (this.indexes[e] = 0), e;
|
|
}
|
|
};
|
|
we.registerParse = (i) => {
|
|
xf = i;
|
|
};
|
|
we.registerRule = (i) => {
|
|
Cs = i;
|
|
};
|
|
we.registerAtRule = (i) => {
|
|
As = i;
|
|
};
|
|
we.registerRoot = (i) => {
|
|
kf = i;
|
|
};
|
|
Af.exports = we;
|
|
we.default = we;
|
|
we.rebuild = (i) => {
|
|
i.type === "atrule"
|
|
? Object.setPrototypeOf(i, As.prototype)
|
|
: i.type === "rule"
|
|
? Object.setPrototypeOf(i, Cs.prototype)
|
|
: i.type === "decl"
|
|
? Object.setPrototypeOf(i, bf.prototype)
|
|
: i.type === "comment"
|
|
? Object.setPrototypeOf(i, vf.prototype)
|
|
: i.type === "root" && Object.setPrototypeOf(i, kf.prototype),
|
|
(i[wf] = !0),
|
|
i.nodes &&
|
|
i.nodes.forEach((e) => {
|
|
we.rebuild(e);
|
|
});
|
|
};
|
|
});
|
|
var Ti = v((bT, Ef) => {
|
|
l();
|
|
("use strict");
|
|
var g0 = it(),
|
|
_f,
|
|
Of,
|
|
Ot = class extends g0 {
|
|
constructor(e) {
|
|
super({ type: "document", ...e });
|
|
this.nodes || (this.nodes = []);
|
|
}
|
|
toResult(e = {}) {
|
|
return new _f(new Of(), this, e).stringify();
|
|
}
|
|
};
|
|
Ot.registerLazyResult = (i) => {
|
|
_f = i;
|
|
};
|
|
Ot.registerProcessor = (i) => {
|
|
Of = i;
|
|
};
|
|
Ef.exports = Ot;
|
|
Ot.default = Ot;
|
|
});
|
|
var _s = v((vT, Pf) => {
|
|
l();
|
|
("use strict");
|
|
var Tf = {};
|
|
Pf.exports = function (e) {
|
|
Tf[e] ||
|
|
((Tf[e] = !0),
|
|
typeof console != "undefined" && console.warn && console.warn(e));
|
|
};
|
|
});
|
|
var Os = v((xT, Df) => {
|
|
l();
|
|
("use strict");
|
|
var Pi = class {
|
|
constructor(e, t = {}) {
|
|
if (
|
|
((this.type = "warning"), (this.text = e), t.node && t.node.source)
|
|
) {
|
|
let r = t.node.rangeBy(t);
|
|
(this.line = r.start.line),
|
|
(this.column = r.start.column),
|
|
(this.endLine = r.end.line),
|
|
(this.endColumn = r.end.column);
|
|
}
|
|
for (let r in t) this[r] = t[r];
|
|
}
|
|
toString() {
|
|
return this.node
|
|
? this.node.error(this.text, {
|
|
plugin: this.plugin,
|
|
index: this.index,
|
|
word: this.word,
|
|
}).message
|
|
: this.plugin
|
|
? this.plugin + ": " + this.text
|
|
: this.text;
|
|
}
|
|
};
|
|
Df.exports = Pi;
|
|
Pi.default = Pi;
|
|
});
|
|
var Ii = v((kT, If) => {
|
|
l();
|
|
("use strict");
|
|
var y0 = Os(),
|
|
Di = class {
|
|
constructor(e, t, r) {
|
|
(this.processor = e),
|
|
(this.messages = []),
|
|
(this.root = t),
|
|
(this.opts = r),
|
|
(this.css = void 0),
|
|
(this.map = void 0);
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
warn(e, t = {}) {
|
|
t.plugin ||
|
|
(this.lastPlugin &&
|
|
this.lastPlugin.postcssPlugin &&
|
|
(t.plugin = this.lastPlugin.postcssPlugin));
|
|
let r = new y0(e, t);
|
|
return this.messages.push(r), r;
|
|
}
|
|
warnings() {
|
|
return this.messages.filter((e) => e.type === "warning");
|
|
}
|
|
get content() {
|
|
return this.css;
|
|
}
|
|
};
|
|
If.exports = Di;
|
|
Di.default = Di;
|
|
});
|
|
var Ff = v((ST, Bf) => {
|
|
l();
|
|
("use strict");
|
|
var Es = "'".charCodeAt(0),
|
|
qf = '"'.charCodeAt(0),
|
|
qi = "\\".charCodeAt(0),
|
|
Rf = "/".charCodeAt(0),
|
|
Ri = `
|
|
`.charCodeAt(0),
|
|
wr = " ".charCodeAt(0),
|
|
Mi = "\f".charCodeAt(0),
|
|
Bi = " ".charCodeAt(0),
|
|
Fi = "\r".charCodeAt(0),
|
|
w0 = "[".charCodeAt(0),
|
|
b0 = "]".charCodeAt(0),
|
|
v0 = "(".charCodeAt(0),
|
|
x0 = ")".charCodeAt(0),
|
|
k0 = "{".charCodeAt(0),
|
|
S0 = "}".charCodeAt(0),
|
|
C0 = ";".charCodeAt(0),
|
|
A0 = "*".charCodeAt(0),
|
|
_0 = ":".charCodeAt(0),
|
|
O0 = "@".charCodeAt(0),
|
|
Ni = /[\t\n\f\r "#'()/;[\\\]{}]/g,
|
|
Li = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g,
|
|
E0 = /.[\n"'(/\\]/,
|
|
Mf = /[\da-f]/i;
|
|
Bf.exports = function (e, t = {}) {
|
|
let r = e.css.valueOf(),
|
|
n = t.ignoreErrors,
|
|
a,
|
|
s,
|
|
o,
|
|
u,
|
|
c,
|
|
f,
|
|
d,
|
|
p,
|
|
m,
|
|
w,
|
|
x = r.length,
|
|
y = 0,
|
|
b = [],
|
|
k = [];
|
|
function S() {
|
|
return y;
|
|
}
|
|
function _(q) {
|
|
throw e.error("Unclosed " + q, y);
|
|
}
|
|
function O() {
|
|
return k.length === 0 && y >= x;
|
|
}
|
|
function I(q) {
|
|
if (k.length) return k.pop();
|
|
if (y >= x) return;
|
|
let X = q ? q.ignoreUnclosed : !1;
|
|
switch (((a = r.charCodeAt(y)), a)) {
|
|
case Ri:
|
|
case wr:
|
|
case Bi:
|
|
case Fi:
|
|
case Mi: {
|
|
s = y;
|
|
do (s += 1), (a = r.charCodeAt(s));
|
|
while (a === wr || a === Ri || a === Bi || a === Fi || a === Mi);
|
|
(w = ["space", r.slice(y, s)]), (y = s - 1);
|
|
break;
|
|
}
|
|
case w0:
|
|
case b0:
|
|
case k0:
|
|
case S0:
|
|
case _0:
|
|
case C0:
|
|
case x0: {
|
|
let le = String.fromCharCode(a);
|
|
w = [le, le, y];
|
|
break;
|
|
}
|
|
case v0: {
|
|
if (
|
|
((p = b.length ? b.pop()[1] : ""),
|
|
(m = r.charCodeAt(y + 1)),
|
|
p === "url" &&
|
|
m !== Es &&
|
|
m !== qf &&
|
|
m !== wr &&
|
|
m !== Ri &&
|
|
m !== Bi &&
|
|
m !== Mi &&
|
|
m !== Fi)
|
|
) {
|
|
s = y;
|
|
do {
|
|
if (((f = !1), (s = r.indexOf(")", s + 1)), s === -1))
|
|
if (n || X) {
|
|
s = y;
|
|
break;
|
|
} else _("bracket");
|
|
for (d = s; r.charCodeAt(d - 1) === qi; ) (d -= 1), (f = !f);
|
|
} while (f);
|
|
(w = ["brackets", r.slice(y, s + 1), y, s]), (y = s);
|
|
} else
|
|
(s = r.indexOf(")", y + 1)),
|
|
(u = r.slice(y, s + 1)),
|
|
s === -1 || E0.test(u)
|
|
? (w = ["(", "(", y])
|
|
: ((w = ["brackets", u, y, s]), (y = s));
|
|
break;
|
|
}
|
|
case Es:
|
|
case qf: {
|
|
(o = a === Es ? "'" : '"'), (s = y);
|
|
do {
|
|
if (((f = !1), (s = r.indexOf(o, s + 1)), s === -1))
|
|
if (n || X) {
|
|
s = y + 1;
|
|
break;
|
|
} else _("string");
|
|
for (d = s; r.charCodeAt(d - 1) === qi; ) (d -= 1), (f = !f);
|
|
} while (f);
|
|
(w = ["string", r.slice(y, s + 1), y, s]), (y = s);
|
|
break;
|
|
}
|
|
case O0: {
|
|
(Ni.lastIndex = y + 1),
|
|
Ni.test(r),
|
|
Ni.lastIndex === 0 ? (s = r.length - 1) : (s = Ni.lastIndex - 2),
|
|
(w = ["at-word", r.slice(y, s + 1), y, s]),
|
|
(y = s);
|
|
break;
|
|
}
|
|
case qi: {
|
|
for (s = y, c = !0; r.charCodeAt(s + 1) === qi; )
|
|
(s += 1), (c = !c);
|
|
if (
|
|
((a = r.charCodeAt(s + 1)),
|
|
c &&
|
|
a !== Rf &&
|
|
a !== wr &&
|
|
a !== Ri &&
|
|
a !== Bi &&
|
|
a !== Fi &&
|
|
a !== Mi &&
|
|
((s += 1), Mf.test(r.charAt(s))))
|
|
) {
|
|
for (; Mf.test(r.charAt(s + 1)); ) s += 1;
|
|
r.charCodeAt(s + 1) === wr && (s += 1);
|
|
}
|
|
(w = ["word", r.slice(y, s + 1), y, s]), (y = s);
|
|
break;
|
|
}
|
|
default: {
|
|
a === Rf && r.charCodeAt(y + 1) === A0
|
|
? ((s = r.indexOf("*/", y + 2) + 1),
|
|
s === 0 && (n || X ? (s = r.length) : _("comment")),
|
|
(w = ["comment", r.slice(y, s + 1), y, s]),
|
|
(y = s))
|
|
: ((Li.lastIndex = y + 1),
|
|
Li.test(r),
|
|
Li.lastIndex === 0
|
|
? (s = r.length - 1)
|
|
: (s = Li.lastIndex - 2),
|
|
(w = ["word", r.slice(y, s + 1), y, s]),
|
|
b.push(w),
|
|
(y = s));
|
|
break;
|
|
}
|
|
}
|
|
return y++, w;
|
|
}
|
|
function B(q) {
|
|
k.push(q);
|
|
}
|
|
return { back: B, nextToken: I, endOfFile: O, position: S };
|
|
};
|
|
});
|
|
var $i = v((CT, Lf) => {
|
|
l();
|
|
("use strict");
|
|
var Nf = it(),
|
|
br = class extends Nf {
|
|
constructor(e) {
|
|
super(e);
|
|
this.type = "atrule";
|
|
}
|
|
append(...e) {
|
|
return this.proxyOf.nodes || (this.nodes = []), super.append(...e);
|
|
}
|
|
prepend(...e) {
|
|
return this.proxyOf.nodes || (this.nodes = []), super.prepend(...e);
|
|
}
|
|
};
|
|
Lf.exports = br;
|
|
br.default = br;
|
|
Nf.registerAtRule(br);
|
|
});
|
|
var Et = v((AT, Vf) => {
|
|
l();
|
|
("use strict");
|
|
var $f = it(),
|
|
jf,
|
|
zf,
|
|
yt = class extends $f {
|
|
constructor(e) {
|
|
super(e);
|
|
(this.type = "root"), this.nodes || (this.nodes = []);
|
|
}
|
|
removeChild(e, t) {
|
|
let r = this.index(e);
|
|
return (
|
|
!t &&
|
|
r === 0 &&
|
|
this.nodes.length > 1 &&
|
|
(this.nodes[1].raws.before = this.nodes[r].raws.before),
|
|
super.removeChild(e)
|
|
);
|
|
}
|
|
normalize(e, t, r) {
|
|
let n = super.normalize(e);
|
|
if (t) {
|
|
if (r === "prepend")
|
|
this.nodes.length > 1
|
|
? (t.raws.before = this.nodes[1].raws.before)
|
|
: delete t.raws.before;
|
|
else if (this.first !== t)
|
|
for (let a of n) a.raws.before = t.raws.before;
|
|
}
|
|
return n;
|
|
}
|
|
toResult(e = {}) {
|
|
return new jf(new zf(), this, e).stringify();
|
|
}
|
|
};
|
|
yt.registerLazyResult = (i) => {
|
|
jf = i;
|
|
};
|
|
yt.registerProcessor = (i) => {
|
|
zf = i;
|
|
};
|
|
Vf.exports = yt;
|
|
yt.default = yt;
|
|
$f.registerRoot(yt);
|
|
});
|
|
var Ts = v((_T, Uf) => {
|
|
l();
|
|
("use strict");
|
|
var vr = {
|
|
split(i, e, t) {
|
|
let r = [],
|
|
n = "",
|
|
a = !1,
|
|
s = 0,
|
|
o = !1,
|
|
u = "",
|
|
c = !1;
|
|
for (let f of i)
|
|
c
|
|
? (c = !1)
|
|
: f === "\\"
|
|
? (c = !0)
|
|
: o
|
|
? f === u && (o = !1)
|
|
: f === '"' || f === "'"
|
|
? ((o = !0), (u = f))
|
|
: f === "("
|
|
? (s += 1)
|
|
: f === ")"
|
|
? s > 0 && (s -= 1)
|
|
: s === 0 && e.includes(f) && (a = !0),
|
|
a ? (n !== "" && r.push(n.trim()), (n = ""), (a = !1)) : (n += f);
|
|
return (t || n !== "") && r.push(n.trim()), r;
|
|
},
|
|
space(i) {
|
|
let e = [
|
|
" ",
|
|
`
|
|
`,
|
|
" ",
|
|
];
|
|
return vr.split(i, e);
|
|
},
|
|
comma(i) {
|
|
return vr.split(i, [","], !0);
|
|
},
|
|
};
|
|
Uf.exports = vr;
|
|
vr.default = vr;
|
|
});
|
|
var ji = v((OT, Gf) => {
|
|
l();
|
|
("use strict");
|
|
var Wf = it(),
|
|
T0 = Ts(),
|
|
xr = class extends Wf {
|
|
constructor(e) {
|
|
super(e);
|
|
(this.type = "rule"), this.nodes || (this.nodes = []);
|
|
}
|
|
get selectors() {
|
|
return T0.comma(this.selector);
|
|
}
|
|
set selectors(e) {
|
|
let t = this.selector ? this.selector.match(/,\s*/) : null,
|
|
r = t ? t[0] : "," + this.raw("between", "beforeOpen");
|
|
this.selector = e.join(r);
|
|
}
|
|
};
|
|
Gf.exports = xr;
|
|
xr.default = xr;
|
|
Wf.registerRule(xr);
|
|
});
|
|
var Xf = v((ET, Jf) => {
|
|
l();
|
|
("use strict");
|
|
var P0 = gr(),
|
|
D0 = Ff(),
|
|
I0 = yr(),
|
|
q0 = $i(),
|
|
R0 = Et(),
|
|
Hf = ji(),
|
|
Yf = { empty: !0, space: !0 };
|
|
function M0(i) {
|
|
for (let e = i.length - 1; e >= 0; e--) {
|
|
let t = i[e],
|
|
r = t[3] || t[2];
|
|
if (r) return r;
|
|
}
|
|
}
|
|
var Qf = class {
|
|
constructor(e) {
|
|
(this.input = e),
|
|
(this.root = new R0()),
|
|
(this.current = this.root),
|
|
(this.spaces = ""),
|
|
(this.semicolon = !1),
|
|
(this.customProperty = !1),
|
|
this.createTokenizer(),
|
|
(this.root.source = {
|
|
input: e,
|
|
start: { offset: 0, line: 1, column: 1 },
|
|
});
|
|
}
|
|
createTokenizer() {
|
|
this.tokenizer = D0(this.input);
|
|
}
|
|
parse() {
|
|
let e;
|
|
for (; !this.tokenizer.endOfFile(); )
|
|
switch (((e = this.tokenizer.nextToken()), e[0])) {
|
|
case "space":
|
|
this.spaces += e[1];
|
|
break;
|
|
case ";":
|
|
this.freeSemicolon(e);
|
|
break;
|
|
case "}":
|
|
this.end(e);
|
|
break;
|
|
case "comment":
|
|
this.comment(e);
|
|
break;
|
|
case "at-word":
|
|
this.atrule(e);
|
|
break;
|
|
case "{":
|
|
this.emptyRule(e);
|
|
break;
|
|
default:
|
|
this.other(e);
|
|
break;
|
|
}
|
|
this.endFile();
|
|
}
|
|
comment(e) {
|
|
let t = new I0();
|
|
this.init(t, e[2]), (t.source.end = this.getPosition(e[3] || e[2]));
|
|
let r = e[1].slice(2, -2);
|
|
if (/^\s*$/.test(r))
|
|
(t.text = ""), (t.raws.left = r), (t.raws.right = "");
|
|
else {
|
|
let n = r.match(/^(\s*)([^]*\S)(\s*)$/);
|
|
(t.text = n[2]), (t.raws.left = n[1]), (t.raws.right = n[3]);
|
|
}
|
|
}
|
|
emptyRule(e) {
|
|
let t = new Hf();
|
|
this.init(t, e[2]),
|
|
(t.selector = ""),
|
|
(t.raws.between = ""),
|
|
(this.current = t);
|
|
}
|
|
other(e) {
|
|
let t = !1,
|
|
r = null,
|
|
n = !1,
|
|
a = null,
|
|
s = [],
|
|
o = e[1].startsWith("--"),
|
|
u = [],
|
|
c = e;
|
|
for (; c; ) {
|
|
if (((r = c[0]), u.push(c), r === "(" || r === "["))
|
|
a || (a = c), s.push(r === "(" ? ")" : "]");
|
|
else if (o && n && r === "{") a || (a = c), s.push("}");
|
|
else if (s.length === 0)
|
|
if (r === ";")
|
|
if (n) {
|
|
this.decl(u, o);
|
|
return;
|
|
} else break;
|
|
else if (r === "{") {
|
|
this.rule(u);
|
|
return;
|
|
} else if (r === "}") {
|
|
this.tokenizer.back(u.pop()), (t = !0);
|
|
break;
|
|
} else r === ":" && (n = !0);
|
|
else r === s[s.length - 1] && (s.pop(), s.length === 0 && (a = null));
|
|
c = this.tokenizer.nextToken();
|
|
}
|
|
if (
|
|
(this.tokenizer.endOfFile() && (t = !0),
|
|
s.length > 0 && this.unclosedBracket(a),
|
|
t && n)
|
|
) {
|
|
if (!o)
|
|
for (
|
|
;
|
|
u.length &&
|
|
((c = u[u.length - 1][0]), !(c !== "space" && c !== "comment"));
|
|
|
|
)
|
|
this.tokenizer.back(u.pop());
|
|
this.decl(u, o);
|
|
} else this.unknownWord(u);
|
|
}
|
|
rule(e) {
|
|
e.pop();
|
|
let t = new Hf();
|
|
this.init(t, e[0][2]),
|
|
(t.raws.between = this.spacesAndCommentsFromEnd(e)),
|
|
this.raw(t, "selector", e),
|
|
(this.current = t);
|
|
}
|
|
decl(e, t) {
|
|
let r = new P0();
|
|
this.init(r, e[0][2]);
|
|
let n = e[e.length - 1];
|
|
for (
|
|
n[0] === ";" && ((this.semicolon = !0), e.pop()),
|
|
r.source.end = this.getPosition(n[3] || n[2] || M0(e));
|
|
e[0][0] !== "word";
|
|
|
|
)
|
|
e.length === 1 && this.unknownWord(e),
|
|
(r.raws.before += e.shift()[1]);
|
|
for (
|
|
r.source.start = this.getPosition(e[0][2]), r.prop = "";
|
|
e.length;
|
|
|
|
) {
|
|
let c = e[0][0];
|
|
if (c === ":" || c === "space" || c === "comment") break;
|
|
r.prop += e.shift()[1];
|
|
}
|
|
r.raws.between = "";
|
|
let a;
|
|
for (; e.length; )
|
|
if (((a = e.shift()), a[0] === ":")) {
|
|
r.raws.between += a[1];
|
|
break;
|
|
} else
|
|
a[0] === "word" && /\w/.test(a[1]) && this.unknownWord([a]),
|
|
(r.raws.between += a[1]);
|
|
(r.prop[0] === "_" || r.prop[0] === "*") &&
|
|
((r.raws.before += r.prop[0]), (r.prop = r.prop.slice(1)));
|
|
let s = [],
|
|
o;
|
|
for (
|
|
;
|
|
e.length && ((o = e[0][0]), !(o !== "space" && o !== "comment"));
|
|
|
|
)
|
|
s.push(e.shift());
|
|
this.precheckMissedSemicolon(e);
|
|
for (let c = e.length - 1; c >= 0; c--) {
|
|
if (((a = e[c]), a[1].toLowerCase() === "!important")) {
|
|
r.important = !0;
|
|
let f = this.stringFrom(e, c);
|
|
(f = this.spacesFromEnd(e) + f),
|
|
f !== " !important" && (r.raws.important = f);
|
|
break;
|
|
} else if (a[1].toLowerCase() === "important") {
|
|
let f = e.slice(0),
|
|
d = "";
|
|
for (let p = c; p > 0; p--) {
|
|
let m = f[p][0];
|
|
if (d.trim().indexOf("!") === 0 && m !== "space") break;
|
|
d = f.pop()[1] + d;
|
|
}
|
|
d.trim().indexOf("!") === 0 &&
|
|
((r.important = !0), (r.raws.important = d), (e = f));
|
|
}
|
|
if (a[0] !== "space" && a[0] !== "comment") break;
|
|
}
|
|
e.some((c) => c[0] !== "space" && c[0] !== "comment") &&
|
|
((r.raws.between += s.map((c) => c[1]).join("")), (s = [])),
|
|
this.raw(r, "value", s.concat(e), t),
|
|
r.value.includes(":") && !t && this.checkMissedSemicolon(e);
|
|
}
|
|
atrule(e) {
|
|
let t = new q0();
|
|
(t.name = e[1].slice(1)),
|
|
t.name === "" && this.unnamedAtrule(t, e),
|
|
this.init(t, e[2]);
|
|
let r,
|
|
n,
|
|
a,
|
|
s = !1,
|
|
o = !1,
|
|
u = [],
|
|
c = [];
|
|
for (; !this.tokenizer.endOfFile(); ) {
|
|
if (
|
|
((e = this.tokenizer.nextToken()),
|
|
(r = e[0]),
|
|
r === "(" || r === "["
|
|
? c.push(r === "(" ? ")" : "]")
|
|
: r === "{" && c.length > 0
|
|
? c.push("}")
|
|
: r === c[c.length - 1] && c.pop(),
|
|
c.length === 0)
|
|
)
|
|
if (r === ";") {
|
|
(t.source.end = this.getPosition(e[2])), (this.semicolon = !0);
|
|
break;
|
|
} else if (r === "{") {
|
|
o = !0;
|
|
break;
|
|
} else if (r === "}") {
|
|
if (u.length > 0) {
|
|
for (a = u.length - 1, n = u[a]; n && n[0] === "space"; )
|
|
n = u[--a];
|
|
n && (t.source.end = this.getPosition(n[3] || n[2]));
|
|
}
|
|
this.end(e);
|
|
break;
|
|
} else u.push(e);
|
|
else u.push(e);
|
|
if (this.tokenizer.endOfFile()) {
|
|
s = !0;
|
|
break;
|
|
}
|
|
}
|
|
(t.raws.between = this.spacesAndCommentsFromEnd(u)),
|
|
u.length
|
|
? ((t.raws.afterName = this.spacesAndCommentsFromStart(u)),
|
|
this.raw(t, "params", u),
|
|
s &&
|
|
((e = u[u.length - 1]),
|
|
(t.source.end = this.getPosition(e[3] || e[2])),
|
|
(this.spaces = t.raws.between),
|
|
(t.raws.between = "")))
|
|
: ((t.raws.afterName = ""), (t.params = "")),
|
|
o && ((t.nodes = []), (this.current = t));
|
|
}
|
|
end(e) {
|
|
this.current.nodes &&
|
|
this.current.nodes.length &&
|
|
(this.current.raws.semicolon = this.semicolon),
|
|
(this.semicolon = !1),
|
|
(this.current.raws.after =
|
|
(this.current.raws.after || "") + this.spaces),
|
|
(this.spaces = ""),
|
|
this.current.parent
|
|
? ((this.current.source.end = this.getPosition(e[2])),
|
|
(this.current = this.current.parent))
|
|
: this.unexpectedClose(e);
|
|
}
|
|
endFile() {
|
|
this.current.parent && this.unclosedBlock(),
|
|
this.current.nodes &&
|
|
this.current.nodes.length &&
|
|
(this.current.raws.semicolon = this.semicolon),
|
|
(this.current.raws.after =
|
|
(this.current.raws.after || "") + this.spaces);
|
|
}
|
|
freeSemicolon(e) {
|
|
if (((this.spaces += e[1]), this.current.nodes)) {
|
|
let t = this.current.nodes[this.current.nodes.length - 1];
|
|
t &&
|
|
t.type === "rule" &&
|
|
!t.raws.ownSemicolon &&
|
|
((t.raws.ownSemicolon = this.spaces), (this.spaces = ""));
|
|
}
|
|
}
|
|
getPosition(e) {
|
|
let t = this.input.fromOffset(e);
|
|
return { offset: e, line: t.line, column: t.col };
|
|
}
|
|
init(e, t) {
|
|
this.current.push(e),
|
|
(e.source = { start: this.getPosition(t), input: this.input }),
|
|
(e.raws.before = this.spaces),
|
|
(this.spaces = ""),
|
|
e.type !== "comment" && (this.semicolon = !1);
|
|
}
|
|
raw(e, t, r, n) {
|
|
let a,
|
|
s,
|
|
o = r.length,
|
|
u = "",
|
|
c = !0,
|
|
f,
|
|
d;
|
|
for (let p = 0; p < o; p += 1)
|
|
(a = r[p]),
|
|
(s = a[0]),
|
|
s === "space" && p === o - 1 && !n
|
|
? (c = !1)
|
|
: s === "comment"
|
|
? ((d = r[p - 1] ? r[p - 1][0] : "empty"),
|
|
(f = r[p + 1] ? r[p + 1][0] : "empty"),
|
|
!Yf[d] && !Yf[f]
|
|
? u.slice(-1) === ","
|
|
? (c = !1)
|
|
: (u += a[1])
|
|
: (c = !1))
|
|
: (u += a[1]);
|
|
if (!c) {
|
|
let p = r.reduce((m, w) => m + w[1], "");
|
|
e.raws[t] = { value: u, raw: p };
|
|
}
|
|
e[t] = u;
|
|
}
|
|
spacesAndCommentsFromEnd(e) {
|
|
let t,
|
|
r = "";
|
|
for (
|
|
;
|
|
e.length &&
|
|
((t = e[e.length - 1][0]), !(t !== "space" && t !== "comment"));
|
|
|
|
)
|
|
r = e.pop()[1] + r;
|
|
return r;
|
|
}
|
|
spacesAndCommentsFromStart(e) {
|
|
let t,
|
|
r = "";
|
|
for (
|
|
;
|
|
e.length && ((t = e[0][0]), !(t !== "space" && t !== "comment"));
|
|
|
|
)
|
|
r += e.shift()[1];
|
|
return r;
|
|
}
|
|
spacesFromEnd(e) {
|
|
let t,
|
|
r = "";
|
|
for (; e.length && ((t = e[e.length - 1][0]), t === "space"); )
|
|
r = e.pop()[1] + r;
|
|
return r;
|
|
}
|
|
stringFrom(e, t) {
|
|
let r = "";
|
|
for (let n = t; n < e.length; n++) r += e[n][1];
|
|
return e.splice(t, e.length - t), r;
|
|
}
|
|
colon(e) {
|
|
let t = 0,
|
|
r,
|
|
n,
|
|
a;
|
|
for (let [s, o] of e.entries()) {
|
|
if (
|
|
((r = o),
|
|
(n = r[0]),
|
|
n === "(" && (t += 1),
|
|
n === ")" && (t -= 1),
|
|
t === 0 && n === ":")
|
|
)
|
|
if (!a) this.doubleColon(r);
|
|
else {
|
|
if (a[0] === "word" && a[1] === "progid") continue;
|
|
return s;
|
|
}
|
|
a = r;
|
|
}
|
|
return !1;
|
|
}
|
|
unclosedBracket(e) {
|
|
throw this.input.error(
|
|
"Unclosed bracket",
|
|
{ offset: e[2] },
|
|
{ offset: e[2] + 1 },
|
|
);
|
|
}
|
|
unknownWord(e) {
|
|
throw this.input.error(
|
|
"Unknown word",
|
|
{ offset: e[0][2] },
|
|
{ offset: e[0][2] + e[0][1].length },
|
|
);
|
|
}
|
|
unexpectedClose(e) {
|
|
throw this.input.error(
|
|
"Unexpected }",
|
|
{ offset: e[2] },
|
|
{ offset: e[2] + 1 },
|
|
);
|
|
}
|
|
unclosedBlock() {
|
|
let e = this.current.source.start;
|
|
throw this.input.error("Unclosed block", e.line, e.column);
|
|
}
|
|
doubleColon(e) {
|
|
throw this.input.error(
|
|
"Double colon",
|
|
{ offset: e[2] },
|
|
{ offset: e[2] + e[1].length },
|
|
);
|
|
}
|
|
unnamedAtrule(e, t) {
|
|
throw this.input.error(
|
|
"At-rule without name",
|
|
{ offset: t[2] },
|
|
{ offset: t[2] + t[1].length },
|
|
);
|
|
}
|
|
precheckMissedSemicolon() {}
|
|
checkMissedSemicolon(e) {
|
|
let t = this.colon(e);
|
|
if (t === !1) return;
|
|
let r = 0,
|
|
n;
|
|
for (
|
|
let a = t - 1;
|
|
a >= 0 && ((n = e[a]), !(n[0] !== "space" && ((r += 1), r === 2)));
|
|
a--
|
|
);
|
|
throw this.input.error(
|
|
"Missed semicolon",
|
|
n[0] === "word" ? n[3] + 1 : n[2],
|
|
);
|
|
}
|
|
};
|
|
Jf.exports = Qf;
|
|
});
|
|
var Kf = v(() => {
|
|
l();
|
|
});
|
|
var ec = v((DT, Zf) => {
|
|
l();
|
|
var B0 = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict",
|
|
F0 =
|
|
(i, e = 21) =>
|
|
(t = e) => {
|
|
let r = "",
|
|
n = t;
|
|
for (; n--; ) r += i[(Math.random() * i.length) | 0];
|
|
return r;
|
|
},
|
|
N0 = (i = 21) => {
|
|
let e = "",
|
|
t = i;
|
|
for (; t--; ) e += B0[(Math.random() * 64) | 0];
|
|
return e;
|
|
};
|
|
Zf.exports = { nanoid: N0, customAlphabet: F0 };
|
|
});
|
|
var Ps = v((IT, tc) => {
|
|
l();
|
|
tc.exports = {};
|
|
});
|
|
var Vi = v((qT, sc) => {
|
|
l();
|
|
("use strict");
|
|
var { SourceMapConsumer: L0, SourceMapGenerator: $0 } = Kf(),
|
|
{ fileURLToPath: rc, pathToFileURL: zi } = (ys(), af),
|
|
{ resolve: Ds, isAbsolute: Is } = (gt(), rf),
|
|
{ nanoid: j0 } = ec(),
|
|
qs = ws(),
|
|
ic = ki(),
|
|
z0 = Ps(),
|
|
Rs = Symbol("fromOffsetCache"),
|
|
V0 = Boolean(L0 && $0),
|
|
nc = Boolean(Ds && Is),
|
|
kr = class {
|
|
constructor(e, t = {}) {
|
|
if (
|
|
e === null ||
|
|
typeof e == "undefined" ||
|
|
(typeof e == "object" && !e.toString)
|
|
)
|
|
throw new Error(`PostCSS received ${e} instead of CSS string`);
|
|
if (
|
|
((this.css = e.toString()),
|
|
this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE"
|
|
? ((this.hasBOM = !0), (this.css = this.css.slice(1)))
|
|
: (this.hasBOM = !1),
|
|
t.from &&
|
|
(!nc || /^\w+:\/\//.test(t.from) || Is(t.from)
|
|
? (this.file = t.from)
|
|
: (this.file = Ds(t.from))),
|
|
nc && V0)
|
|
) {
|
|
let r = new z0(this.css, t);
|
|
if (r.text) {
|
|
this.map = r;
|
|
let n = r.consumer().file;
|
|
!this.file && n && (this.file = this.mapResolve(n));
|
|
}
|
|
}
|
|
this.file || (this.id = "<input css " + j0(6) + ">"),
|
|
this.map && (this.map.file = this.from);
|
|
}
|
|
fromOffset(e) {
|
|
let t, r;
|
|
if (this[Rs]) r = this[Rs];
|
|
else {
|
|
let a = this.css.split(`
|
|
`);
|
|
r = new Array(a.length);
|
|
let s = 0;
|
|
for (let o = 0, u = a.length; o < u; o++)
|
|
(r[o] = s), (s += a[o].length + 1);
|
|
this[Rs] = r;
|
|
}
|
|
t = r[r.length - 1];
|
|
let n = 0;
|
|
if (e >= t) n = r.length - 1;
|
|
else {
|
|
let a = r.length - 2,
|
|
s;
|
|
for (; n < a; )
|
|
if (((s = n + ((a - n) >> 1)), e < r[s])) a = s - 1;
|
|
else if (e >= r[s + 1]) n = s + 1;
|
|
else {
|
|
n = s;
|
|
break;
|
|
}
|
|
}
|
|
return { line: n + 1, col: e - r[n] + 1 };
|
|
}
|
|
error(e, t, r, n = {}) {
|
|
let a, s, o;
|
|
if (t && typeof t == "object") {
|
|
let c = t,
|
|
f = r;
|
|
if (typeof c.offset == "number") {
|
|
let d = this.fromOffset(c.offset);
|
|
(t = d.line), (r = d.col);
|
|
} else (t = c.line), (r = c.column);
|
|
if (typeof f.offset == "number") {
|
|
let d = this.fromOffset(f.offset);
|
|
(s = d.line), (o = d.col);
|
|
} else (s = f.line), (o = f.column);
|
|
} else if (!r) {
|
|
let c = this.fromOffset(t);
|
|
(t = c.line), (r = c.col);
|
|
}
|
|
let u = this.origin(t, r, s, o);
|
|
return (
|
|
u
|
|
? (a = new ic(
|
|
e,
|
|
u.endLine === void 0
|
|
? u.line
|
|
: { line: u.line, column: u.column },
|
|
u.endLine === void 0
|
|
? u.column
|
|
: { line: u.endLine, column: u.endColumn },
|
|
u.source,
|
|
u.file,
|
|
n.plugin,
|
|
))
|
|
: (a = new ic(
|
|
e,
|
|
s === void 0 ? t : { line: t, column: r },
|
|
s === void 0 ? r : { line: s, column: o },
|
|
this.css,
|
|
this.file,
|
|
n.plugin,
|
|
)),
|
|
(a.input = {
|
|
line: t,
|
|
column: r,
|
|
endLine: s,
|
|
endColumn: o,
|
|
source: this.css,
|
|
}),
|
|
this.file &&
|
|
(zi && (a.input.url = zi(this.file).toString()),
|
|
(a.input.file = this.file)),
|
|
a
|
|
);
|
|
}
|
|
origin(e, t, r, n) {
|
|
if (!this.map) return !1;
|
|
let a = this.map.consumer(),
|
|
s = a.originalPositionFor({ line: e, column: t });
|
|
if (!s.source) return !1;
|
|
let o;
|
|
typeof r == "number" &&
|
|
(o = a.originalPositionFor({ line: r, column: n }));
|
|
let u;
|
|
Is(s.source)
|
|
? (u = zi(s.source))
|
|
: (u = new URL(
|
|
s.source,
|
|
this.map.consumer().sourceRoot || zi(this.map.mapFile),
|
|
));
|
|
let c = {
|
|
url: u.toString(),
|
|
line: s.line,
|
|
column: s.column,
|
|
endLine: o && o.line,
|
|
endColumn: o && o.column,
|
|
};
|
|
if (u.protocol === "file:")
|
|
if (rc) c.file = rc(u);
|
|
else
|
|
throw new Error(
|
|
"file: protocol is not available in this PostCSS build",
|
|
);
|
|
let f = a.sourceContentFor(s.source);
|
|
return f && (c.source = f), c;
|
|
}
|
|
mapResolve(e) {
|
|
return /^\w+:\/\//.test(e)
|
|
? e
|
|
: Ds(this.map.consumer().sourceRoot || this.map.root || ".", e);
|
|
}
|
|
get from() {
|
|
return this.file || this.id;
|
|
}
|
|
toJSON() {
|
|
let e = {};
|
|
for (let t of ["hasBOM", "css", "file", "id"])
|
|
this[t] != null && (e[t] = this[t]);
|
|
return (
|
|
this.map &&
|
|
((e.map = { ...this.map }),
|
|
e.map.consumerCache && (e.map.consumerCache = void 0)),
|
|
e
|
|
);
|
|
}
|
|
};
|
|
sc.exports = kr;
|
|
kr.default = kr;
|
|
qs && qs.registerInput && qs.registerInput(kr);
|
|
});
|
|
var Wi = v((RT, ac) => {
|
|
l();
|
|
("use strict");
|
|
var U0 = it(),
|
|
W0 = Xf(),
|
|
G0 = Vi();
|
|
function Ui(i, e) {
|
|
let t = new G0(i, e),
|
|
r = new W0(t);
|
|
try {
|
|
r.parse();
|
|
} catch (n) {
|
|
throw n;
|
|
}
|
|
return r.root;
|
|
}
|
|
ac.exports = Ui;
|
|
Ui.default = Ui;
|
|
U0.registerParse(Ui);
|
|
});
|
|
var Fs = v((BT, fc) => {
|
|
l();
|
|
("use strict");
|
|
var { isClean: Ie, my: H0 } = Si(),
|
|
Y0 = Ss(),
|
|
Q0 = hr(),
|
|
J0 = it(),
|
|
X0 = Ti(),
|
|
MT = _s(),
|
|
oc = Ii(),
|
|
K0 = Wi(),
|
|
Z0 = Et(),
|
|
ev = {
|
|
document: "Document",
|
|
root: "Root",
|
|
atrule: "AtRule",
|
|
rule: "Rule",
|
|
decl: "Declaration",
|
|
comment: "Comment",
|
|
},
|
|
tv = {
|
|
postcssPlugin: !0,
|
|
prepare: !0,
|
|
Once: !0,
|
|
Document: !0,
|
|
Root: !0,
|
|
Declaration: !0,
|
|
Rule: !0,
|
|
AtRule: !0,
|
|
Comment: !0,
|
|
DeclarationExit: !0,
|
|
RuleExit: !0,
|
|
AtRuleExit: !0,
|
|
CommentExit: !0,
|
|
RootExit: !0,
|
|
DocumentExit: !0,
|
|
OnceExit: !0,
|
|
},
|
|
rv = { postcssPlugin: !0, prepare: !0, Once: !0 },
|
|
Tt = 0;
|
|
function Sr(i) {
|
|
return typeof i == "object" && typeof i.then == "function";
|
|
}
|
|
function lc(i) {
|
|
let e = !1,
|
|
t = ev[i.type];
|
|
return (
|
|
i.type === "decl"
|
|
? (e = i.prop.toLowerCase())
|
|
: i.type === "atrule" && (e = i.name.toLowerCase()),
|
|
e && i.append
|
|
? [t, t + "-" + e, Tt, t + "Exit", t + "Exit-" + e]
|
|
: e
|
|
? [t, t + "-" + e, t + "Exit", t + "Exit-" + e]
|
|
: i.append
|
|
? [t, Tt, t + "Exit"]
|
|
: [t, t + "Exit"]
|
|
);
|
|
}
|
|
function uc(i) {
|
|
let e;
|
|
return (
|
|
i.type === "document"
|
|
? (e = ["Document", Tt, "DocumentExit"])
|
|
: i.type === "root"
|
|
? (e = ["Root", Tt, "RootExit"])
|
|
: (e = lc(i)),
|
|
{
|
|
node: i,
|
|
events: e,
|
|
eventIndex: 0,
|
|
visitors: [],
|
|
visitorIndex: 0,
|
|
iterator: 0,
|
|
}
|
|
);
|
|
}
|
|
function Ms(i) {
|
|
return (i[Ie] = !1), i.nodes && i.nodes.forEach((e) => Ms(e)), i;
|
|
}
|
|
var Bs = {},
|
|
Ve = class {
|
|
constructor(e, t, r) {
|
|
(this.stringified = !1), (this.processed = !1);
|
|
let n;
|
|
if (
|
|
typeof t == "object" &&
|
|
t !== null &&
|
|
(t.type === "root" || t.type === "document")
|
|
)
|
|
n = Ms(t);
|
|
else if (t instanceof Ve || t instanceof oc)
|
|
(n = Ms(t.root)),
|
|
t.map &&
|
|
(typeof r.map == "undefined" && (r.map = {}),
|
|
r.map.inline || (r.map.inline = !1),
|
|
(r.map.prev = t.map));
|
|
else {
|
|
let a = K0;
|
|
r.syntax && (a = r.syntax.parse),
|
|
r.parser && (a = r.parser),
|
|
a.parse && (a = a.parse);
|
|
try {
|
|
n = a(t, r);
|
|
} catch (s) {
|
|
(this.processed = !0), (this.error = s);
|
|
}
|
|
n && !n[H0] && J0.rebuild(n);
|
|
}
|
|
(this.result = new oc(e, n, r)),
|
|
(this.helpers = { ...Bs, result: this.result, postcss: Bs }),
|
|
(this.plugins = this.processor.plugins.map((a) =>
|
|
typeof a == "object" && a.prepare
|
|
? { ...a, ...a.prepare(this.result) }
|
|
: a,
|
|
));
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "LazyResult";
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get css() {
|
|
return this.stringify().css;
|
|
}
|
|
get content() {
|
|
return this.stringify().content;
|
|
}
|
|
get map() {
|
|
return this.stringify().map;
|
|
}
|
|
get root() {
|
|
return this.sync().root;
|
|
}
|
|
get messages() {
|
|
return this.sync().messages;
|
|
}
|
|
warnings() {
|
|
return this.sync().warnings();
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
then(e, t) {
|
|
return this.async().then(e, t);
|
|
}
|
|
catch(e) {
|
|
return this.async().catch(e);
|
|
}
|
|
finally(e) {
|
|
return this.async().then(e, e);
|
|
}
|
|
async() {
|
|
return this.error
|
|
? Promise.reject(this.error)
|
|
: this.processed
|
|
? Promise.resolve(this.result)
|
|
: (this.processing || (this.processing = this.runAsync()),
|
|
this.processing);
|
|
}
|
|
sync() {
|
|
if (this.error) throw this.error;
|
|
if (this.processed) return this.result;
|
|
if (((this.processed = !0), this.processing))
|
|
throw this.getAsyncError();
|
|
for (let e of this.plugins) {
|
|
let t = this.runOnRoot(e);
|
|
if (Sr(t)) throw this.getAsyncError();
|
|
}
|
|
if ((this.prepareVisitors(), this.hasListener)) {
|
|
let e = this.result.root;
|
|
for (; !e[Ie]; ) (e[Ie] = !0), this.walkSync(e);
|
|
if (this.listeners.OnceExit)
|
|
if (e.type === "document")
|
|
for (let t of e.nodes)
|
|
this.visitSync(this.listeners.OnceExit, t);
|
|
else this.visitSync(this.listeners.OnceExit, e);
|
|
}
|
|
return this.result;
|
|
}
|
|
stringify() {
|
|
if (this.error) throw this.error;
|
|
if (this.stringified) return this.result;
|
|
(this.stringified = !0), this.sync();
|
|
let e = this.result.opts,
|
|
t = Q0;
|
|
e.syntax && (t = e.syntax.stringify),
|
|
e.stringifier && (t = e.stringifier),
|
|
t.stringify && (t = t.stringify);
|
|
let n = new Y0(t, this.result.root, this.result.opts).generate();
|
|
return (
|
|
(this.result.css = n[0]), (this.result.map = n[1]), this.result
|
|
);
|
|
}
|
|
walkSync(e) {
|
|
e[Ie] = !0;
|
|
let t = lc(e);
|
|
for (let r of t)
|
|
if (r === Tt)
|
|
e.nodes &&
|
|
e.each((n) => {
|
|
n[Ie] || this.walkSync(n);
|
|
});
|
|
else {
|
|
let n = this.listeners[r];
|
|
if (n && this.visitSync(n, e.toProxy())) return;
|
|
}
|
|
}
|
|
visitSync(e, t) {
|
|
for (let [r, n] of e) {
|
|
this.result.lastPlugin = r;
|
|
let a;
|
|
try {
|
|
a = n(t, this.helpers);
|
|
} catch (s) {
|
|
throw this.handleError(s, t.proxyOf);
|
|
}
|
|
if (t.type !== "root" && t.type !== "document" && !t.parent)
|
|
return !0;
|
|
if (Sr(a)) throw this.getAsyncError();
|
|
}
|
|
}
|
|
runOnRoot(e) {
|
|
this.result.lastPlugin = e;
|
|
try {
|
|
if (typeof e == "object" && e.Once) {
|
|
if (this.result.root.type === "document") {
|
|
let t = this.result.root.nodes.map((r) =>
|
|
e.Once(r, this.helpers),
|
|
);
|
|
return Sr(t[0]) ? Promise.all(t) : t;
|
|
}
|
|
return e.Once(this.result.root, this.helpers);
|
|
} else if (typeof e == "function")
|
|
return e(this.result.root, this.result);
|
|
} catch (t) {
|
|
throw this.handleError(t);
|
|
}
|
|
}
|
|
getAsyncError() {
|
|
throw new Error(
|
|
"Use process(css).then(cb) to work with async plugins",
|
|
);
|
|
}
|
|
handleError(e, t) {
|
|
let r = this.result.lastPlugin;
|
|
try {
|
|
t && t.addToError(e),
|
|
(this.error = e),
|
|
e.name === "CssSyntaxError" && !e.plugin
|
|
? ((e.plugin = r.postcssPlugin), e.setMessage())
|
|
: r.postcssVersion;
|
|
} catch (n) {
|
|
console && console.error && console.error(n);
|
|
}
|
|
return e;
|
|
}
|
|
async runAsync() {
|
|
this.plugin = 0;
|
|
for (let e = 0; e < this.plugins.length; e++) {
|
|
let t = this.plugins[e],
|
|
r = this.runOnRoot(t);
|
|
if (Sr(r))
|
|
try {
|
|
await r;
|
|
} catch (n) {
|
|
throw this.handleError(n);
|
|
}
|
|
}
|
|
if ((this.prepareVisitors(), this.hasListener)) {
|
|
let e = this.result.root;
|
|
for (; !e[Ie]; ) {
|
|
e[Ie] = !0;
|
|
let t = [uc(e)];
|
|
for (; t.length > 0; ) {
|
|
let r = this.visitTick(t);
|
|
if (Sr(r))
|
|
try {
|
|
await r;
|
|
} catch (n) {
|
|
let a = t[t.length - 1].node;
|
|
throw this.handleError(n, a);
|
|
}
|
|
}
|
|
}
|
|
if (this.listeners.OnceExit)
|
|
for (let [t, r] of this.listeners.OnceExit) {
|
|
this.result.lastPlugin = t;
|
|
try {
|
|
if (e.type === "document") {
|
|
let n = e.nodes.map((a) => r(a, this.helpers));
|
|
await Promise.all(n);
|
|
} else await r(e, this.helpers);
|
|
} catch (n) {
|
|
throw this.handleError(n);
|
|
}
|
|
}
|
|
}
|
|
return (this.processed = !0), this.stringify();
|
|
}
|
|
prepareVisitors() {
|
|
this.listeners = {};
|
|
let e = (t, r, n) => {
|
|
this.listeners[r] || (this.listeners[r] = []),
|
|
this.listeners[r].push([t, n]);
|
|
};
|
|
for (let t of this.plugins)
|
|
if (typeof t == "object")
|
|
for (let r in t) {
|
|
if (!tv[r] && /^[A-Z]/.test(r))
|
|
throw new Error(
|
|
`Unknown event ${r} in ${t.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`,
|
|
);
|
|
if (!rv[r])
|
|
if (typeof t[r] == "object")
|
|
for (let n in t[r])
|
|
n === "*"
|
|
? e(t, r, t[r][n])
|
|
: e(t, r + "-" + n.toLowerCase(), t[r][n]);
|
|
else typeof t[r] == "function" && e(t, r, t[r]);
|
|
}
|
|
this.hasListener = Object.keys(this.listeners).length > 0;
|
|
}
|
|
visitTick(e) {
|
|
let t = e[e.length - 1],
|
|
{ node: r, visitors: n } = t;
|
|
if (r.type !== "root" && r.type !== "document" && !r.parent) {
|
|
e.pop();
|
|
return;
|
|
}
|
|
if (n.length > 0 && t.visitorIndex < n.length) {
|
|
let [s, o] = n[t.visitorIndex];
|
|
(t.visitorIndex += 1),
|
|
t.visitorIndex === n.length &&
|
|
((t.visitors = []), (t.visitorIndex = 0)),
|
|
(this.result.lastPlugin = s);
|
|
try {
|
|
return o(r.toProxy(), this.helpers);
|
|
} catch (u) {
|
|
throw this.handleError(u, r);
|
|
}
|
|
}
|
|
if (t.iterator !== 0) {
|
|
let s = t.iterator,
|
|
o;
|
|
for (; (o = r.nodes[r.indexes[s]]); )
|
|
if (((r.indexes[s] += 1), !o[Ie])) {
|
|
(o[Ie] = !0), e.push(uc(o));
|
|
return;
|
|
}
|
|
(t.iterator = 0), delete r.indexes[s];
|
|
}
|
|
let a = t.events;
|
|
for (; t.eventIndex < a.length; ) {
|
|
let s = a[t.eventIndex];
|
|
if (((t.eventIndex += 1), s === Tt)) {
|
|
r.nodes &&
|
|
r.nodes.length &&
|
|
((r[Ie] = !0), (t.iterator = r.getIterator()));
|
|
return;
|
|
} else if (this.listeners[s]) {
|
|
t.visitors = this.listeners[s];
|
|
return;
|
|
}
|
|
}
|
|
e.pop();
|
|
}
|
|
};
|
|
Ve.registerPostcss = (i) => {
|
|
Bs = i;
|
|
};
|
|
fc.exports = Ve;
|
|
Ve.default = Ve;
|
|
Z0.registerLazyResult(Ve);
|
|
X0.registerLazyResult(Ve);
|
|
});
|
|
var pc = v((NT, cc) => {
|
|
l();
|
|
("use strict");
|
|
var iv = Ss(),
|
|
nv = hr(),
|
|
FT = _s(),
|
|
sv = Wi(),
|
|
av = Ii(),
|
|
Gi = class {
|
|
constructor(e, t, r) {
|
|
(t = t.toString()),
|
|
(this.stringified = !1),
|
|
(this._processor = e),
|
|
(this._css = t),
|
|
(this._opts = r),
|
|
(this._map = void 0);
|
|
let n,
|
|
a = nv;
|
|
(this.result = new av(this._processor, n, this._opts)),
|
|
(this.result.css = t);
|
|
let s = this;
|
|
Object.defineProperty(this.result, "root", {
|
|
get() {
|
|
return s.root;
|
|
},
|
|
});
|
|
let o = new iv(a, n, this._opts, t);
|
|
if (o.isMap()) {
|
|
let [u, c] = o.generate();
|
|
u && (this.result.css = u), c && (this.result.map = c);
|
|
}
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "NoWorkResult";
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get css() {
|
|
return this.result.css;
|
|
}
|
|
get content() {
|
|
return this.result.css;
|
|
}
|
|
get map() {
|
|
return this.result.map;
|
|
}
|
|
get root() {
|
|
if (this._root) return this._root;
|
|
let e,
|
|
t = sv;
|
|
try {
|
|
e = t(this._css, this._opts);
|
|
} catch (r) {
|
|
this.error = r;
|
|
}
|
|
if (this.error) throw this.error;
|
|
return (this._root = e), e;
|
|
}
|
|
get messages() {
|
|
return [];
|
|
}
|
|
warnings() {
|
|
return [];
|
|
}
|
|
toString() {
|
|
return this._css;
|
|
}
|
|
then(e, t) {
|
|
return this.async().then(e, t);
|
|
}
|
|
catch(e) {
|
|
return this.async().catch(e);
|
|
}
|
|
finally(e) {
|
|
return this.async().then(e, e);
|
|
}
|
|
async() {
|
|
return this.error
|
|
? Promise.reject(this.error)
|
|
: Promise.resolve(this.result);
|
|
}
|
|
sync() {
|
|
if (this.error) throw this.error;
|
|
return this.result;
|
|
}
|
|
};
|
|
cc.exports = Gi;
|
|
Gi.default = Gi;
|
|
});
|
|
var hc = v((LT, dc) => {
|
|
l();
|
|
("use strict");
|
|
var ov = pc(),
|
|
lv = Fs(),
|
|
uv = Ti(),
|
|
fv = Et(),
|
|
Pt = class {
|
|
constructor(e = []) {
|
|
(this.version = "8.4.24"), (this.plugins = this.normalize(e));
|
|
}
|
|
use(e) {
|
|
return (
|
|
(this.plugins = this.plugins.concat(this.normalize([e]))), this
|
|
);
|
|
}
|
|
process(e, t = {}) {
|
|
return this.plugins.length === 0 &&
|
|
typeof t.parser == "undefined" &&
|
|
typeof t.stringifier == "undefined" &&
|
|
typeof t.syntax == "undefined"
|
|
? new ov(this, e, t)
|
|
: new lv(this, e, t);
|
|
}
|
|
normalize(e) {
|
|
let t = [];
|
|
for (let r of e)
|
|
if (
|
|
(r.postcss === !0 ? (r = r()) : r.postcss && (r = r.postcss),
|
|
typeof r == "object" && Array.isArray(r.plugins))
|
|
)
|
|
t = t.concat(r.plugins);
|
|
else if (typeof r == "object" && r.postcssPlugin) t.push(r);
|
|
else if (typeof r == "function") t.push(r);
|
|
else if (!(typeof r == "object" && (r.parse || r.stringify)))
|
|
throw new Error(r + " is not a PostCSS plugin");
|
|
return t;
|
|
}
|
|
};
|
|
dc.exports = Pt;
|
|
Pt.default = Pt;
|
|
fv.registerProcessor(Pt);
|
|
uv.registerProcessor(Pt);
|
|
});
|
|
var gc = v(($T, mc) => {
|
|
l();
|
|
("use strict");
|
|
var cv = gr(),
|
|
pv = Ps(),
|
|
dv = yr(),
|
|
hv = $i(),
|
|
mv = Vi(),
|
|
gv = Et(),
|
|
yv = ji();
|
|
function Cr(i, e) {
|
|
if (Array.isArray(i)) return i.map((n) => Cr(n));
|
|
let { inputs: t, ...r } = i;
|
|
if (t) {
|
|
e = [];
|
|
for (let n of t) {
|
|
let a = { ...n, __proto__: mv.prototype };
|
|
a.map && (a.map = { ...a.map, __proto__: pv.prototype }), e.push(a);
|
|
}
|
|
}
|
|
if ((r.nodes && (r.nodes = i.nodes.map((n) => Cr(n, e))), r.source)) {
|
|
let { inputId: n, ...a } = r.source;
|
|
(r.source = a), n != null && (r.source.input = e[n]);
|
|
}
|
|
if (r.type === "root") return new gv(r);
|
|
if (r.type === "decl") return new cv(r);
|
|
if (r.type === "rule") return new yv(r);
|
|
if (r.type === "comment") return new dv(r);
|
|
if (r.type === "atrule") return new hv(r);
|
|
throw new Error("Unknown node type: " + i.type);
|
|
}
|
|
mc.exports = Cr;
|
|
Cr.default = Cr;
|
|
});
|
|
var ge = v((jT, Sc) => {
|
|
l();
|
|
("use strict");
|
|
var wv = ki(),
|
|
yc = gr(),
|
|
bv = Fs(),
|
|
vv = it(),
|
|
Ns = hc(),
|
|
xv = hr(),
|
|
kv = gc(),
|
|
wc = Ti(),
|
|
Sv = Os(),
|
|
bc = yr(),
|
|
vc = $i(),
|
|
Cv = Ii(),
|
|
Av = Vi(),
|
|
_v = Wi(),
|
|
Ov = Ts(),
|
|
xc = ji(),
|
|
kc = Et(),
|
|
Ev = mr();
|
|
function z(...i) {
|
|
return i.length === 1 && Array.isArray(i[0]) && (i = i[0]), new Ns(i);
|
|
}
|
|
z.plugin = function (e, t) {
|
|
let r = !1;
|
|
function n(...s) {
|
|
console &&
|
|
console.warn &&
|
|
!r &&
|
|
((r = !0),
|
|
console.warn(
|
|
e +
|
|
`: postcss.plugin was deprecated. Migration guide:
|
|
https://evilmartians.com/chronicles/postcss-8-plugin-migration`,
|
|
),
|
|
h.env.LANG &&
|
|
h.env.LANG.startsWith("cn") &&
|
|
console.warn(
|
|
e +
|
|
`: \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:
|
|
https://www.w3ctech.com/topic/2226`,
|
|
));
|
|
let o = t(...s);
|
|
return (o.postcssPlugin = e), (o.postcssVersion = new Ns().version), o;
|
|
}
|
|
let a;
|
|
return (
|
|
Object.defineProperty(n, "postcss", {
|
|
get() {
|
|
return a || (a = n()), a;
|
|
},
|
|
}),
|
|
(n.process = function (s, o, u) {
|
|
return z([n(u)]).process(s, o);
|
|
}),
|
|
n
|
|
);
|
|
};
|
|
z.stringify = xv;
|
|
z.parse = _v;
|
|
z.fromJSON = kv;
|
|
z.list = Ov;
|
|
z.comment = (i) => new bc(i);
|
|
z.atRule = (i) => new vc(i);
|
|
z.decl = (i) => new yc(i);
|
|
z.rule = (i) => new xc(i);
|
|
z.root = (i) => new kc(i);
|
|
z.document = (i) => new wc(i);
|
|
z.CssSyntaxError = wv;
|
|
z.Declaration = yc;
|
|
z.Container = vv;
|
|
z.Processor = Ns;
|
|
z.Document = wc;
|
|
z.Comment = bc;
|
|
z.Warning = Sv;
|
|
z.AtRule = vc;
|
|
z.Result = Cv;
|
|
z.Input = Av;
|
|
z.Rule = xc;
|
|
z.Root = kc;
|
|
z.Node = Ev;
|
|
bv.registerPostcss(z);
|
|
Sc.exports = z;
|
|
z.default = z;
|
|
});
|
|
var W,
|
|
V,
|
|
zT,
|
|
VT,
|
|
UT,
|
|
WT,
|
|
GT,
|
|
HT,
|
|
YT,
|
|
QT,
|
|
JT,
|
|
XT,
|
|
KT,
|
|
ZT,
|
|
e3,
|
|
t3,
|
|
r3,
|
|
i3,
|
|
n3,
|
|
s3,
|
|
a3,
|
|
o3,
|
|
l3,
|
|
u3,
|
|
f3,
|
|
c3,
|
|
nt = C(() => {
|
|
l();
|
|
(W = K(ge())),
|
|
(V = W.default),
|
|
(zT = W.default.stringify),
|
|
(VT = W.default.fromJSON),
|
|
(UT = W.default.plugin),
|
|
(WT = W.default.parse),
|
|
(GT = W.default.list),
|
|
(HT = W.default.document),
|
|
(YT = W.default.comment),
|
|
(QT = W.default.atRule),
|
|
(JT = W.default.rule),
|
|
(XT = W.default.decl),
|
|
(KT = W.default.root),
|
|
(ZT = W.default.CssSyntaxError),
|
|
(e3 = W.default.Declaration),
|
|
(t3 = W.default.Container),
|
|
(r3 = W.default.Processor),
|
|
(i3 = W.default.Document),
|
|
(n3 = W.default.Comment),
|
|
(s3 = W.default.Warning),
|
|
(a3 = W.default.AtRule),
|
|
(o3 = W.default.Result),
|
|
(l3 = W.default.Input),
|
|
(u3 = W.default.Rule),
|
|
(f3 = W.default.Root),
|
|
(c3 = W.default.Node);
|
|
});
|
|
var Ls = v((d3, Cc) => {
|
|
l();
|
|
Cc.exports = function (i, e, t, r, n) {
|
|
for (e = e.split ? e.split(".") : e, r = 0; r < e.length; r++)
|
|
i = i ? i[e[r]] : n;
|
|
return i === n ? t : i;
|
|
};
|
|
});
|
|
var Yi = v((Hi, Ac) => {
|
|
l();
|
|
("use strict");
|
|
Hi.__esModule = !0;
|
|
Hi.default = Dv;
|
|
function Tv(i) {
|
|
for (
|
|
var e = i.toLowerCase(), t = "", r = !1, n = 0;
|
|
n < 6 && e[n] !== void 0;
|
|
n++
|
|
) {
|
|
var a = e.charCodeAt(n),
|
|
s = (a >= 97 && a <= 102) || (a >= 48 && a <= 57);
|
|
if (((r = a === 32), !s)) break;
|
|
t += e[n];
|
|
}
|
|
if (t.length !== 0) {
|
|
var o = parseInt(t, 16),
|
|
u = o >= 55296 && o <= 57343;
|
|
return u || o === 0 || o > 1114111
|
|
? ["\uFFFD", t.length + (r ? 1 : 0)]
|
|
: [String.fromCodePoint(o), t.length + (r ? 1 : 0)];
|
|
}
|
|
}
|
|
var Pv = /\\/;
|
|
function Dv(i) {
|
|
var e = Pv.test(i);
|
|
if (!e) return i;
|
|
for (var t = "", r = 0; r < i.length; r++) {
|
|
if (i[r] === "\\") {
|
|
var n = Tv(i.slice(r + 1, r + 7));
|
|
if (n !== void 0) {
|
|
(t += n[0]), (r += n[1]);
|
|
continue;
|
|
}
|
|
if (i[r + 1] === "\\") {
|
|
(t += "\\"), r++;
|
|
continue;
|
|
}
|
|
i.length === r + 1 && (t += i[r]);
|
|
continue;
|
|
}
|
|
t += i[r];
|
|
}
|
|
return t;
|
|
}
|
|
Ac.exports = Hi.default;
|
|
});
|
|
var Oc = v((Qi, _c) => {
|
|
l();
|
|
("use strict");
|
|
Qi.__esModule = !0;
|
|
Qi.default = Iv;
|
|
function Iv(i) {
|
|
for (
|
|
var e = arguments.length, t = new Array(e > 1 ? e - 1 : 0), r = 1;
|
|
r < e;
|
|
r++
|
|
)
|
|
t[r - 1] = arguments[r];
|
|
for (; t.length > 0; ) {
|
|
var n = t.shift();
|
|
if (!i[n]) return;
|
|
i = i[n];
|
|
}
|
|
return i;
|
|
}
|
|
_c.exports = Qi.default;
|
|
});
|
|
var Tc = v((Ji, Ec) => {
|
|
l();
|
|
("use strict");
|
|
Ji.__esModule = !0;
|
|
Ji.default = qv;
|
|
function qv(i) {
|
|
for (
|
|
var e = arguments.length, t = new Array(e > 1 ? e - 1 : 0), r = 1;
|
|
r < e;
|
|
r++
|
|
)
|
|
t[r - 1] = arguments[r];
|
|
for (; t.length > 0; ) {
|
|
var n = t.shift();
|
|
i[n] || (i[n] = {}), (i = i[n]);
|
|
}
|
|
}
|
|
Ec.exports = Ji.default;
|
|
});
|
|
var Dc = v((Xi, Pc) => {
|
|
l();
|
|
("use strict");
|
|
Xi.__esModule = !0;
|
|
Xi.default = Rv;
|
|
function Rv(i) {
|
|
for (var e = "", t = i.indexOf("/*"), r = 0; t >= 0; ) {
|
|
e = e + i.slice(r, t);
|
|
var n = i.indexOf("*/", t + 2);
|
|
if (n < 0) return e;
|
|
(r = n + 2), (t = i.indexOf("/*", r));
|
|
}
|
|
return (e = e + i.slice(r)), e;
|
|
}
|
|
Pc.exports = Xi.default;
|
|
});
|
|
var Ar = v((qe) => {
|
|
l();
|
|
("use strict");
|
|
qe.__esModule = !0;
|
|
qe.unesc = qe.stripComments = qe.getProp = qe.ensureObject = void 0;
|
|
var Mv = Ki(Yi());
|
|
qe.unesc = Mv.default;
|
|
var Bv = Ki(Oc());
|
|
qe.getProp = Bv.default;
|
|
var Fv = Ki(Tc());
|
|
qe.ensureObject = Fv.default;
|
|
var Nv = Ki(Dc());
|
|
qe.stripComments = Nv.default;
|
|
function Ki(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
});
|
|
var Ue = v((_r, Rc) => {
|
|
l();
|
|
("use strict");
|
|
_r.__esModule = !0;
|
|
_r.default = void 0;
|
|
var Ic = Ar();
|
|
function qc(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function Lv(i, e, t) {
|
|
return (
|
|
e && qc(i.prototype, e),
|
|
t && qc(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
var $v = function i(e, t) {
|
|
if (typeof e != "object" || e === null) return e;
|
|
var r = new e.constructor();
|
|
for (var n in e)
|
|
if (!!e.hasOwnProperty(n)) {
|
|
var a = e[n],
|
|
s = typeof a;
|
|
n === "parent" && s === "object"
|
|
? t && (r[n] = t)
|
|
: a instanceof Array
|
|
? (r[n] = a.map(function (o) {
|
|
return i(o, r);
|
|
}))
|
|
: (r[n] = i(a, r));
|
|
}
|
|
return r;
|
|
},
|
|
jv = (function () {
|
|
function i(t) {
|
|
t === void 0 && (t = {}),
|
|
Object.assign(this, t),
|
|
(this.spaces = this.spaces || {}),
|
|
(this.spaces.before = this.spaces.before || ""),
|
|
(this.spaces.after = this.spaces.after || "");
|
|
}
|
|
var e = i.prototype;
|
|
return (
|
|
(e.remove = function () {
|
|
return (
|
|
this.parent && this.parent.removeChild(this),
|
|
(this.parent = void 0),
|
|
this
|
|
);
|
|
}),
|
|
(e.replaceWith = function () {
|
|
if (this.parent) {
|
|
for (var r in arguments)
|
|
this.parent.insertBefore(this, arguments[r]);
|
|
this.remove();
|
|
}
|
|
return this;
|
|
}),
|
|
(e.next = function () {
|
|
return this.parent.at(this.parent.index(this) + 1);
|
|
}),
|
|
(e.prev = function () {
|
|
return this.parent.at(this.parent.index(this) - 1);
|
|
}),
|
|
(e.clone = function (r) {
|
|
r === void 0 && (r = {});
|
|
var n = $v(this);
|
|
for (var a in r) n[a] = r[a];
|
|
return n;
|
|
}),
|
|
(e.appendToPropertyAndEscape = function (r, n, a) {
|
|
this.raws || (this.raws = {});
|
|
var s = this[r],
|
|
o = this.raws[r];
|
|
(this[r] = s + n),
|
|
o || a !== n
|
|
? (this.raws[r] = (o || s) + a)
|
|
: delete this.raws[r];
|
|
}),
|
|
(e.setPropertyAndEscape = function (r, n, a) {
|
|
this.raws || (this.raws = {}), (this[r] = n), (this.raws[r] = a);
|
|
}),
|
|
(e.setPropertyWithoutEscape = function (r, n) {
|
|
(this[r] = n), this.raws && delete this.raws[r];
|
|
}),
|
|
(e.isAtPosition = function (r, n) {
|
|
if (this.source && this.source.start && this.source.end)
|
|
return !(
|
|
this.source.start.line > r ||
|
|
this.source.end.line < r ||
|
|
(this.source.start.line === r &&
|
|
this.source.start.column > n) ||
|
|
(this.source.end.line === r && this.source.end.column < n)
|
|
);
|
|
}),
|
|
(e.stringifyProperty = function (r) {
|
|
return (this.raws && this.raws[r]) || this[r];
|
|
}),
|
|
(e.valueToString = function () {
|
|
return String(this.stringifyProperty("value"));
|
|
}),
|
|
(e.toString = function () {
|
|
return [
|
|
this.rawSpaceBefore,
|
|
this.valueToString(),
|
|
this.rawSpaceAfter,
|
|
].join("");
|
|
}),
|
|
Lv(i, [
|
|
{
|
|
key: "rawSpaceBefore",
|
|
get: function () {
|
|
var r =
|
|
this.raws && this.raws.spaces && this.raws.spaces.before;
|
|
return (
|
|
r === void 0 && (r = this.spaces && this.spaces.before),
|
|
r || ""
|
|
);
|
|
},
|
|
set: function (r) {
|
|
(0, Ic.ensureObject)(this, "raws", "spaces"),
|
|
(this.raws.spaces.before = r);
|
|
},
|
|
},
|
|
{
|
|
key: "rawSpaceAfter",
|
|
get: function () {
|
|
var r = this.raws && this.raws.spaces && this.raws.spaces.after;
|
|
return r === void 0 && (r = this.spaces.after), r || "";
|
|
},
|
|
set: function (r) {
|
|
(0, Ic.ensureObject)(this, "raws", "spaces"),
|
|
(this.raws.spaces.after = r);
|
|
},
|
|
},
|
|
]),
|
|
i
|
|
);
|
|
})();
|
|
_r.default = jv;
|
|
Rc.exports = _r.default;
|
|
});
|
|
var se = v((G) => {
|
|
l();
|
|
("use strict");
|
|
G.__esModule = !0;
|
|
G.UNIVERSAL =
|
|
G.TAG =
|
|
G.STRING =
|
|
G.SELECTOR =
|
|
G.ROOT =
|
|
G.PSEUDO =
|
|
G.NESTING =
|
|
G.ID =
|
|
G.COMMENT =
|
|
G.COMBINATOR =
|
|
G.CLASS =
|
|
G.ATTRIBUTE =
|
|
void 0;
|
|
var zv = "tag";
|
|
G.TAG = zv;
|
|
var Vv = "string";
|
|
G.STRING = Vv;
|
|
var Uv = "selector";
|
|
G.SELECTOR = Uv;
|
|
var Wv = "root";
|
|
G.ROOT = Wv;
|
|
var Gv = "pseudo";
|
|
G.PSEUDO = Gv;
|
|
var Hv = "nesting";
|
|
G.NESTING = Hv;
|
|
var Yv = "id";
|
|
G.ID = Yv;
|
|
var Qv = "comment";
|
|
G.COMMENT = Qv;
|
|
var Jv = "combinator";
|
|
G.COMBINATOR = Jv;
|
|
var Xv = "class";
|
|
G.CLASS = Xv;
|
|
var Kv = "attribute";
|
|
G.ATTRIBUTE = Kv;
|
|
var Zv = "universal";
|
|
G.UNIVERSAL = Zv;
|
|
});
|
|
var Zi = v((Or, Nc) => {
|
|
l();
|
|
("use strict");
|
|
Or.__esModule = !0;
|
|
Or.default = void 0;
|
|
var ex = rx(Ue()),
|
|
We = tx(se());
|
|
function Mc(i) {
|
|
if (typeof WeakMap != "function") return null;
|
|
var e = new WeakMap(),
|
|
t = new WeakMap();
|
|
return (Mc = function (n) {
|
|
return n ? t : e;
|
|
})(i);
|
|
}
|
|
function tx(i, e) {
|
|
if (!e && i && i.__esModule) return i;
|
|
if (i === null || (typeof i != "object" && typeof i != "function"))
|
|
return { default: i };
|
|
var t = Mc(e);
|
|
if (t && t.has(i)) return t.get(i);
|
|
var r = {},
|
|
n = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var a in i)
|
|
if (a !== "default" && Object.prototype.hasOwnProperty.call(i, a)) {
|
|
var s = n ? Object.getOwnPropertyDescriptor(i, a) : null;
|
|
s && (s.get || s.set)
|
|
? Object.defineProperty(r, a, s)
|
|
: (r[a] = i[a]);
|
|
}
|
|
return (r.default = i), t && t.set(i, r), r;
|
|
}
|
|
function rx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function ix(i, e) {
|
|
var t =
|
|
(typeof Symbol != "undefined" && i[Symbol.iterator]) || i["@@iterator"];
|
|
if (t) return (t = t.call(i)).next.bind(t);
|
|
if (
|
|
Array.isArray(i) ||
|
|
(t = nx(i)) ||
|
|
(e && i && typeof i.length == "number")
|
|
) {
|
|
t && (i = t);
|
|
var r = 0;
|
|
return function () {
|
|
return r >= i.length ? { done: !0 } : { done: !1, value: i[r++] };
|
|
};
|
|
}
|
|
throw new TypeError(`Invalid attempt to iterate non-iterable instance.
|
|
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
|
|
}
|
|
function nx(i, e) {
|
|
if (!!i) {
|
|
if (typeof i == "string") return Bc(i, e);
|
|
var t = Object.prototype.toString.call(i).slice(8, -1);
|
|
if (
|
|
(t === "Object" && i.constructor && (t = i.constructor.name),
|
|
t === "Map" || t === "Set")
|
|
)
|
|
return Array.from(i);
|
|
if (
|
|
t === "Arguments" ||
|
|
/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
|
|
)
|
|
return Bc(i, e);
|
|
}
|
|
}
|
|
function Bc(i, e) {
|
|
(e == null || e > i.length) && (e = i.length);
|
|
for (var t = 0, r = new Array(e); t < e; t++) r[t] = i[t];
|
|
return r;
|
|
}
|
|
function Fc(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function sx(i, e, t) {
|
|
return (
|
|
e && Fc(i.prototype, e),
|
|
t && Fc(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
function ax(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
$s(i, e);
|
|
}
|
|
function $s(i, e) {
|
|
return (
|
|
($s = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
$s(i, e)
|
|
);
|
|
}
|
|
var ox = (function (i) {
|
|
ax(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (n = i.call(this, r) || this), n.nodes || (n.nodes = []), n;
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.append = function (n) {
|
|
return (n.parent = this), this.nodes.push(n), this;
|
|
}),
|
|
(t.prepend = function (n) {
|
|
return (n.parent = this), this.nodes.unshift(n), this;
|
|
}),
|
|
(t.at = function (n) {
|
|
return this.nodes[n];
|
|
}),
|
|
(t.index = function (n) {
|
|
return typeof n == "number" ? n : this.nodes.indexOf(n);
|
|
}),
|
|
(t.removeChild = function (n) {
|
|
(n = this.index(n)),
|
|
(this.at(n).parent = void 0),
|
|
this.nodes.splice(n, 1);
|
|
var a;
|
|
for (var s in this.indexes)
|
|
(a = this.indexes[s]), a >= n && (this.indexes[s] = a - 1);
|
|
return this;
|
|
}),
|
|
(t.removeAll = function () {
|
|
for (var n = ix(this.nodes), a; !(a = n()).done; ) {
|
|
var s = a.value;
|
|
s.parent = void 0;
|
|
}
|
|
return (this.nodes = []), this;
|
|
}),
|
|
(t.empty = function () {
|
|
return this.removeAll();
|
|
}),
|
|
(t.insertAfter = function (n, a) {
|
|
a.parent = this;
|
|
var s = this.index(n);
|
|
this.nodes.splice(s + 1, 0, a), (a.parent = this);
|
|
var o;
|
|
for (var u in this.indexes)
|
|
(o = this.indexes[u]), s <= o && (this.indexes[u] = o + 1);
|
|
return this;
|
|
}),
|
|
(t.insertBefore = function (n, a) {
|
|
a.parent = this;
|
|
var s = this.index(n);
|
|
this.nodes.splice(s, 0, a), (a.parent = this);
|
|
var o;
|
|
for (var u in this.indexes)
|
|
(o = this.indexes[u]), o <= s && (this.indexes[u] = o + 1);
|
|
return this;
|
|
}),
|
|
(t._findChildAtPosition = function (n, a) {
|
|
var s = void 0;
|
|
return (
|
|
this.each(function (o) {
|
|
if (o.atPosition) {
|
|
var u = o.atPosition(n, a);
|
|
if (u) return (s = u), !1;
|
|
} else if (o.isAtPosition(n, a)) return (s = o), !1;
|
|
}),
|
|
s
|
|
);
|
|
}),
|
|
(t.atPosition = function (n, a) {
|
|
if (this.isAtPosition(n, a))
|
|
return this._findChildAtPosition(n, a) || this;
|
|
}),
|
|
(t._inferEndPosition = function () {
|
|
this.last &&
|
|
this.last.source &&
|
|
this.last.source.end &&
|
|
((this.source = this.source || {}),
|
|
(this.source.end = this.source.end || {}),
|
|
Object.assign(this.source.end, this.last.source.end));
|
|
}),
|
|
(t.each = function (n) {
|
|
this.lastEach || (this.lastEach = 0),
|
|
this.indexes || (this.indexes = {}),
|
|
this.lastEach++;
|
|
var a = this.lastEach;
|
|
if (((this.indexes[a] = 0), !!this.length)) {
|
|
for (
|
|
var s, o;
|
|
this.indexes[a] < this.length &&
|
|
((s = this.indexes[a]), (o = n(this.at(s), s)), o !== !1);
|
|
|
|
)
|
|
this.indexes[a] += 1;
|
|
if ((delete this.indexes[a], o === !1)) return !1;
|
|
}
|
|
}),
|
|
(t.walk = function (n) {
|
|
return this.each(function (a, s) {
|
|
var o = n(a, s);
|
|
if ((o !== !1 && a.length && (o = a.walk(n)), o === !1)) return !1;
|
|
});
|
|
}),
|
|
(t.walkAttributes = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.ATTRIBUTE) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkClasses = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.CLASS) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkCombinators = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.COMBINATOR) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkComments = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.COMMENT) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkIds = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.ID) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkNesting = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.NESTING) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkPseudos = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.PSEUDO) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkTags = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.TAG) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.walkUniversals = function (n) {
|
|
var a = this;
|
|
return this.walk(function (s) {
|
|
if (s.type === We.UNIVERSAL) return n.call(a, s);
|
|
});
|
|
}),
|
|
(t.split = function (n) {
|
|
var a = this,
|
|
s = [];
|
|
return this.reduce(function (o, u, c) {
|
|
var f = n.call(a, u);
|
|
return (
|
|
s.push(u),
|
|
f ? (o.push(s), (s = [])) : c === a.length - 1 && o.push(s),
|
|
o
|
|
);
|
|
}, []);
|
|
}),
|
|
(t.map = function (n) {
|
|
return this.nodes.map(n);
|
|
}),
|
|
(t.reduce = function (n, a) {
|
|
return this.nodes.reduce(n, a);
|
|
}),
|
|
(t.every = function (n) {
|
|
return this.nodes.every(n);
|
|
}),
|
|
(t.some = function (n) {
|
|
return this.nodes.some(n);
|
|
}),
|
|
(t.filter = function (n) {
|
|
return this.nodes.filter(n);
|
|
}),
|
|
(t.sort = function (n) {
|
|
return this.nodes.sort(n);
|
|
}),
|
|
(t.toString = function () {
|
|
return this.map(String).join("");
|
|
}),
|
|
sx(e, [
|
|
{
|
|
key: "first",
|
|
get: function () {
|
|
return this.at(0);
|
|
},
|
|
},
|
|
{
|
|
key: "last",
|
|
get: function () {
|
|
return this.at(this.length - 1);
|
|
},
|
|
},
|
|
{
|
|
key: "length",
|
|
get: function () {
|
|
return this.nodes.length;
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(ex.default);
|
|
Or.default = ox;
|
|
Nc.exports = Or.default;
|
|
});
|
|
var zs = v((Er, $c) => {
|
|
l();
|
|
("use strict");
|
|
Er.__esModule = !0;
|
|
Er.default = void 0;
|
|
var lx = fx(Zi()),
|
|
ux = se();
|
|
function fx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function Lc(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function cx(i, e, t) {
|
|
return (
|
|
e && Lc(i.prototype, e),
|
|
t && Lc(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
function px(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
js(i, e);
|
|
}
|
|
function js(i, e) {
|
|
return (
|
|
(js = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
js(i, e)
|
|
);
|
|
}
|
|
var dx = (function (i) {
|
|
px(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (n = i.call(this, r) || this), (n.type = ux.ROOT), n;
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.toString = function () {
|
|
var n = this.reduce(function (a, s) {
|
|
return a.push(String(s)), a;
|
|
}, []).join(",");
|
|
return this.trailingComma ? n + "," : n;
|
|
}),
|
|
(t.error = function (n, a) {
|
|
return this._error ? this._error(n, a) : new Error(n);
|
|
}),
|
|
cx(e, [
|
|
{
|
|
key: "errorGenerator",
|
|
set: function (n) {
|
|
this._error = n;
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(lx.default);
|
|
Er.default = dx;
|
|
$c.exports = Er.default;
|
|
});
|
|
var Us = v((Tr, jc) => {
|
|
l();
|
|
("use strict");
|
|
Tr.__esModule = !0;
|
|
Tr.default = void 0;
|
|
var hx = gx(Zi()),
|
|
mx = se();
|
|
function gx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function yx(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Vs(i, e);
|
|
}
|
|
function Vs(i, e) {
|
|
return (
|
|
(Vs = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Vs(i, e)
|
|
);
|
|
}
|
|
var wx = (function (i) {
|
|
yx(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (r = i.call(this, t) || this), (r.type = mx.SELECTOR), r;
|
|
}
|
|
return e;
|
|
})(hx.default);
|
|
Tr.default = wx;
|
|
jc.exports = Tr.default;
|
|
});
|
|
var en = v((g3, zc) => {
|
|
l();
|
|
("use strict");
|
|
var bx = {},
|
|
vx = bx.hasOwnProperty,
|
|
xx = function (e, t) {
|
|
if (!e) return t;
|
|
var r = {};
|
|
for (var n in t) r[n] = vx.call(e, n) ? e[n] : t[n];
|
|
return r;
|
|
},
|
|
kx = /[ -,\.\/:-@\[-\^`\{-~]/,
|
|
Sx = /[ -,\.\/:-@\[\]\^`\{-~]/,
|
|
Cx = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g,
|
|
Ws = function i(e, t) {
|
|
(t = xx(t, i.options)),
|
|
t.quotes != "single" && t.quotes != "double" && (t.quotes = "single");
|
|
for (
|
|
var r = t.quotes == "double" ? '"' : "'",
|
|
n = t.isIdentifier,
|
|
a = e.charAt(0),
|
|
s = "",
|
|
o = 0,
|
|
u = e.length;
|
|
o < u;
|
|
|
|
) {
|
|
var c = e.charAt(o++),
|
|
f = c.charCodeAt(),
|
|
d = void 0;
|
|
if (f < 32 || f > 126) {
|
|
if (f >= 55296 && f <= 56319 && o < u) {
|
|
var p = e.charCodeAt(o++);
|
|
(p & 64512) == 56320
|
|
? (f = ((f & 1023) << 10) + (p & 1023) + 65536)
|
|
: o--;
|
|
}
|
|
d = "\\" + f.toString(16).toUpperCase() + " ";
|
|
} else
|
|
t.escapeEverything
|
|
? kx.test(c)
|
|
? (d = "\\" + c)
|
|
: (d = "\\" + f.toString(16).toUpperCase() + " ")
|
|
: /[\t\n\f\r\x0B]/.test(c)
|
|
? (d = "\\" + f.toString(16).toUpperCase() + " ")
|
|
: c == "\\" ||
|
|
(!n && ((c == '"' && r == c) || (c == "'" && r == c))) ||
|
|
(n && Sx.test(c))
|
|
? (d = "\\" + c)
|
|
: (d = c);
|
|
s += d;
|
|
}
|
|
return (
|
|
n &&
|
|
(/^-[-\d]/.test(s)
|
|
? (s = "\\-" + s.slice(1))
|
|
: /\d/.test(a) && (s = "\\3" + a + " " + s.slice(1))),
|
|
(s = s.replace(Cx, function (m, w, x) {
|
|
return w && w.length % 2 ? m : (w || "") + x;
|
|
})),
|
|
!n && t.wrap ? r + s + r : s
|
|
);
|
|
};
|
|
Ws.options = {
|
|
escapeEverything: !1,
|
|
isIdentifier: !1,
|
|
quotes: "single",
|
|
wrap: !1,
|
|
};
|
|
Ws.version = "3.0.0";
|
|
zc.exports = Ws;
|
|
});
|
|
var Hs = v((Pr, Wc) => {
|
|
l();
|
|
("use strict");
|
|
Pr.__esModule = !0;
|
|
Pr.default = void 0;
|
|
var Ax = Vc(en()),
|
|
_x = Ar(),
|
|
Ox = Vc(Ue()),
|
|
Ex = se();
|
|
function Vc(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function Uc(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function Tx(i, e, t) {
|
|
return (
|
|
e && Uc(i.prototype, e),
|
|
t && Uc(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
function Px(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Gs(i, e);
|
|
}
|
|
function Gs(i, e) {
|
|
return (
|
|
(Gs = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Gs(i, e)
|
|
);
|
|
}
|
|
var Dx = (function (i) {
|
|
Px(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (
|
|
(n = i.call(this, r) || this),
|
|
(n.type = Ex.CLASS),
|
|
(n._constructed = !0),
|
|
n
|
|
);
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.valueToString = function () {
|
|
return "." + i.prototype.valueToString.call(this);
|
|
}),
|
|
Tx(e, [
|
|
{
|
|
key: "value",
|
|
get: function () {
|
|
return this._value;
|
|
},
|
|
set: function (n) {
|
|
if (this._constructed) {
|
|
var a = (0, Ax.default)(n, { isIdentifier: !0 });
|
|
a !== n
|
|
? ((0, _x.ensureObject)(this, "raws"), (this.raws.value = a))
|
|
: this.raws && delete this.raws.value;
|
|
}
|
|
this._value = n;
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(Ox.default);
|
|
Pr.default = Dx;
|
|
Wc.exports = Pr.default;
|
|
});
|
|
var Qs = v((Dr, Gc) => {
|
|
l();
|
|
("use strict");
|
|
Dr.__esModule = !0;
|
|
Dr.default = void 0;
|
|
var Ix = Rx(Ue()),
|
|
qx = se();
|
|
function Rx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function Mx(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Ys(i, e);
|
|
}
|
|
function Ys(i, e) {
|
|
return (
|
|
(Ys = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Ys(i, e)
|
|
);
|
|
}
|
|
var Bx = (function (i) {
|
|
Mx(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (r = i.call(this, t) || this), (r.type = qx.COMMENT), r;
|
|
}
|
|
return e;
|
|
})(Ix.default);
|
|
Dr.default = Bx;
|
|
Gc.exports = Dr.default;
|
|
});
|
|
var Xs = v((Ir, Hc) => {
|
|
l();
|
|
("use strict");
|
|
Ir.__esModule = !0;
|
|
Ir.default = void 0;
|
|
var Fx = Lx(Ue()),
|
|
Nx = se();
|
|
function Lx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function $x(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Js(i, e);
|
|
}
|
|
function Js(i, e) {
|
|
return (
|
|
(Js = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Js(i, e)
|
|
);
|
|
}
|
|
var jx = (function (i) {
|
|
$x(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (n = i.call(this, r) || this), (n.type = Nx.ID), n;
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.valueToString = function () {
|
|
return "#" + i.prototype.valueToString.call(this);
|
|
}),
|
|
e
|
|
);
|
|
})(Fx.default);
|
|
Ir.default = jx;
|
|
Hc.exports = Ir.default;
|
|
});
|
|
var tn = v((qr, Jc) => {
|
|
l();
|
|
("use strict");
|
|
qr.__esModule = !0;
|
|
qr.default = void 0;
|
|
var zx = Yc(en()),
|
|
Vx = Ar(),
|
|
Ux = Yc(Ue());
|
|
function Yc(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function Qc(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function Wx(i, e, t) {
|
|
return (
|
|
e && Qc(i.prototype, e),
|
|
t && Qc(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
function Gx(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Ks(i, e);
|
|
}
|
|
function Ks(i, e) {
|
|
return (
|
|
(Ks = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Ks(i, e)
|
|
);
|
|
}
|
|
var Hx = (function (i) {
|
|
Gx(e, i);
|
|
function e() {
|
|
return i.apply(this, arguments) || this;
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.qualifiedName = function (n) {
|
|
return this.namespace ? this.namespaceString + "|" + n : n;
|
|
}),
|
|
(t.valueToString = function () {
|
|
return this.qualifiedName(i.prototype.valueToString.call(this));
|
|
}),
|
|
Wx(e, [
|
|
{
|
|
key: "namespace",
|
|
get: function () {
|
|
return this._namespace;
|
|
},
|
|
set: function (n) {
|
|
if (n === !0 || n === "*" || n === "&") {
|
|
(this._namespace = n), this.raws && delete this.raws.namespace;
|
|
return;
|
|
}
|
|
var a = (0, zx.default)(n, { isIdentifier: !0 });
|
|
(this._namespace = n),
|
|
a !== n
|
|
? ((0, Vx.ensureObject)(this, "raws"),
|
|
(this.raws.namespace = a))
|
|
: this.raws && delete this.raws.namespace;
|
|
},
|
|
},
|
|
{
|
|
key: "ns",
|
|
get: function () {
|
|
return this._namespace;
|
|
},
|
|
set: function (n) {
|
|
this.namespace = n;
|
|
},
|
|
},
|
|
{
|
|
key: "namespaceString",
|
|
get: function () {
|
|
if (this.namespace) {
|
|
var n = this.stringifyProperty("namespace");
|
|
return n === !0 ? "" : n;
|
|
} else return "";
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(Ux.default);
|
|
qr.default = Hx;
|
|
Jc.exports = qr.default;
|
|
});
|
|
var ea = v((Rr, Xc) => {
|
|
l();
|
|
("use strict");
|
|
Rr.__esModule = !0;
|
|
Rr.default = void 0;
|
|
var Yx = Jx(tn()),
|
|
Qx = se();
|
|
function Jx(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function Xx(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
Zs(i, e);
|
|
}
|
|
function Zs(i, e) {
|
|
return (
|
|
(Zs = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
Zs(i, e)
|
|
);
|
|
}
|
|
var Kx = (function (i) {
|
|
Xx(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (r = i.call(this, t) || this), (r.type = Qx.TAG), r;
|
|
}
|
|
return e;
|
|
})(Yx.default);
|
|
Rr.default = Kx;
|
|
Xc.exports = Rr.default;
|
|
});
|
|
var ra = v((Mr, Kc) => {
|
|
l();
|
|
("use strict");
|
|
Mr.__esModule = !0;
|
|
Mr.default = void 0;
|
|
var Zx = t1(Ue()),
|
|
e1 = se();
|
|
function t1(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function r1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
ta(i, e);
|
|
}
|
|
function ta(i, e) {
|
|
return (
|
|
(ta = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
ta(i, e)
|
|
);
|
|
}
|
|
var i1 = (function (i) {
|
|
r1(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (r = i.call(this, t) || this), (r.type = e1.STRING), r;
|
|
}
|
|
return e;
|
|
})(Zx.default);
|
|
Mr.default = i1;
|
|
Kc.exports = Mr.default;
|
|
});
|
|
var na = v((Br, Zc) => {
|
|
l();
|
|
("use strict");
|
|
Br.__esModule = !0;
|
|
Br.default = void 0;
|
|
var n1 = a1(Zi()),
|
|
s1 = se();
|
|
function a1(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function o1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
ia(i, e);
|
|
}
|
|
function ia(i, e) {
|
|
return (
|
|
(ia = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
ia(i, e)
|
|
);
|
|
}
|
|
var l1 = (function (i) {
|
|
o1(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (n = i.call(this, r) || this), (n.type = s1.PSEUDO), n;
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.toString = function () {
|
|
var n = this.length ? "(" + this.map(String).join(",") + ")" : "";
|
|
return [
|
|
this.rawSpaceBefore,
|
|
this.stringifyProperty("value"),
|
|
n,
|
|
this.rawSpaceAfter,
|
|
].join("");
|
|
}),
|
|
e
|
|
);
|
|
})(n1.default);
|
|
Br.default = l1;
|
|
Zc.exports = Br.default;
|
|
});
|
|
var ep = {};
|
|
Ae(ep, { deprecate: () => u1 });
|
|
function u1(i) {
|
|
return i;
|
|
}
|
|
var tp = C(() => {
|
|
l();
|
|
});
|
|
var ip = v((y3, rp) => {
|
|
l();
|
|
rp.exports = (tp(), ep).deprecate;
|
|
});
|
|
var fa = v((Lr) => {
|
|
l();
|
|
("use strict");
|
|
Lr.__esModule = !0;
|
|
Lr.default = void 0;
|
|
Lr.unescapeValue = la;
|
|
var Fr = aa(en()),
|
|
f1 = aa(Yi()),
|
|
c1 = aa(tn()),
|
|
p1 = se(),
|
|
sa;
|
|
function aa(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function np(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function d1(i, e, t) {
|
|
return (
|
|
e && np(i.prototype, e),
|
|
t && np(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
function h1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
oa(i, e);
|
|
}
|
|
function oa(i, e) {
|
|
return (
|
|
(oa = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
oa(i, e)
|
|
);
|
|
}
|
|
var Nr = ip(),
|
|
m1 = /^('|")([^]*)\1$/,
|
|
g1 = Nr(
|
|
function () {},
|
|
"Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.",
|
|
),
|
|
y1 = Nr(
|
|
function () {},
|
|
"Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.",
|
|
),
|
|
w1 = Nr(
|
|
function () {},
|
|
"Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.",
|
|
);
|
|
function la(i) {
|
|
var e = !1,
|
|
t = null,
|
|
r = i,
|
|
n = r.match(m1);
|
|
return (
|
|
n && ((t = n[1]), (r = n[2])),
|
|
(r = (0, f1.default)(r)),
|
|
r !== i && (e = !0),
|
|
{ deprecatedUsage: e, unescaped: r, quoteMark: t }
|
|
);
|
|
}
|
|
function b1(i) {
|
|
if (i.quoteMark !== void 0 || i.value === void 0) return i;
|
|
w1();
|
|
var e = la(i.value),
|
|
t = e.quoteMark,
|
|
r = e.unescaped;
|
|
return (
|
|
i.raws || (i.raws = {}),
|
|
i.raws.value === void 0 && (i.raws.value = i.value),
|
|
(i.value = r),
|
|
(i.quoteMark = t),
|
|
i
|
|
);
|
|
}
|
|
var rn = (function (i) {
|
|
h1(e, i);
|
|
function e(r) {
|
|
var n;
|
|
return (
|
|
r === void 0 && (r = {}),
|
|
(n = i.call(this, b1(r)) || this),
|
|
(n.type = p1.ATTRIBUTE),
|
|
(n.raws = n.raws || {}),
|
|
Object.defineProperty(n.raws, "unquoted", {
|
|
get: Nr(function () {
|
|
return n.value;
|
|
}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
|
|
set: Nr(function () {
|
|
return n.value;
|
|
}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now."),
|
|
}),
|
|
(n._constructed = !0),
|
|
n
|
|
);
|
|
}
|
|
var t = e.prototype;
|
|
return (
|
|
(t.getQuotedValue = function (n) {
|
|
n === void 0 && (n = {});
|
|
var a = this._determineQuoteMark(n),
|
|
s = ua[a],
|
|
o = (0, Fr.default)(this._value, s);
|
|
return o;
|
|
}),
|
|
(t._determineQuoteMark = function (n) {
|
|
return n.smart ? this.smartQuoteMark(n) : this.preferredQuoteMark(n);
|
|
}),
|
|
(t.setValue = function (n, a) {
|
|
a === void 0 && (a = {}),
|
|
(this._value = n),
|
|
(this._quoteMark = this._determineQuoteMark(a)),
|
|
this._syncRawValue();
|
|
}),
|
|
(t.smartQuoteMark = function (n) {
|
|
var a = this.value,
|
|
s = a.replace(/[^']/g, "").length,
|
|
o = a.replace(/[^"]/g, "").length;
|
|
if (s + o === 0) {
|
|
var u = (0, Fr.default)(a, { isIdentifier: !0 });
|
|
if (u === a) return e.NO_QUOTE;
|
|
var c = this.preferredQuoteMark(n);
|
|
if (c === e.NO_QUOTE) {
|
|
var f = this.quoteMark || n.quoteMark || e.DOUBLE_QUOTE,
|
|
d = ua[f],
|
|
p = (0, Fr.default)(a, d);
|
|
if (p.length < u.length) return f;
|
|
}
|
|
return c;
|
|
} else
|
|
return o === s
|
|
? this.preferredQuoteMark(n)
|
|
: o < s
|
|
? e.DOUBLE_QUOTE
|
|
: e.SINGLE_QUOTE;
|
|
}),
|
|
(t.preferredQuoteMark = function (n) {
|
|
var a = n.preferCurrentQuoteMark ? this.quoteMark : n.quoteMark;
|
|
return (
|
|
a === void 0 &&
|
|
(a = n.preferCurrentQuoteMark ? n.quoteMark : this.quoteMark),
|
|
a === void 0 && (a = e.DOUBLE_QUOTE),
|
|
a
|
|
);
|
|
}),
|
|
(t._syncRawValue = function () {
|
|
var n = (0, Fr.default)(this._value, ua[this.quoteMark]);
|
|
n === this._value
|
|
? this.raws && delete this.raws.value
|
|
: (this.raws.value = n);
|
|
}),
|
|
(t._handleEscapes = function (n, a) {
|
|
if (this._constructed) {
|
|
var s = (0, Fr.default)(a, { isIdentifier: !0 });
|
|
s !== a ? (this.raws[n] = s) : delete this.raws[n];
|
|
}
|
|
}),
|
|
(t._spacesFor = function (n) {
|
|
var a = { before: "", after: "" },
|
|
s = this.spaces[n] || {},
|
|
o = (this.raws.spaces && this.raws.spaces[n]) || {};
|
|
return Object.assign(a, s, o);
|
|
}),
|
|
(t._stringFor = function (n, a, s) {
|
|
a === void 0 && (a = n), s === void 0 && (s = sp);
|
|
var o = this._spacesFor(a);
|
|
return s(this.stringifyProperty(n), o);
|
|
}),
|
|
(t.offsetOf = function (n) {
|
|
var a = 1,
|
|
s = this._spacesFor("attribute");
|
|
if (((a += s.before.length), n === "namespace" || n === "ns"))
|
|
return this.namespace ? a : -1;
|
|
if (
|
|
n === "attributeNS" ||
|
|
((a += this.namespaceString.length),
|
|
this.namespace && (a += 1),
|
|
n === "attribute")
|
|
)
|
|
return a;
|
|
(a += this.stringifyProperty("attribute").length),
|
|
(a += s.after.length);
|
|
var o = this._spacesFor("operator");
|
|
a += o.before.length;
|
|
var u = this.stringifyProperty("operator");
|
|
if (n === "operator") return u ? a : -1;
|
|
(a += u.length), (a += o.after.length);
|
|
var c = this._spacesFor("value");
|
|
a += c.before.length;
|
|
var f = this.stringifyProperty("value");
|
|
if (n === "value") return f ? a : -1;
|
|
(a += f.length), (a += c.after.length);
|
|
var d = this._spacesFor("insensitive");
|
|
return (
|
|
(a += d.before.length),
|
|
n === "insensitive" && this.insensitive ? a : -1
|
|
);
|
|
}),
|
|
(t.toString = function () {
|
|
var n = this,
|
|
a = [this.rawSpaceBefore, "["];
|
|
return (
|
|
a.push(this._stringFor("qualifiedAttribute", "attribute")),
|
|
this.operator &&
|
|
(this.value || this.value === "") &&
|
|
(a.push(this._stringFor("operator")),
|
|
a.push(this._stringFor("value")),
|
|
a.push(
|
|
this._stringFor(
|
|
"insensitiveFlag",
|
|
"insensitive",
|
|
function (s, o) {
|
|
return (
|
|
s.length > 0 &&
|
|
!n.quoted &&
|
|
o.before.length === 0 &&
|
|
!(n.spaces.value && n.spaces.value.after) &&
|
|
(o.before = " "),
|
|
sp(s, o)
|
|
);
|
|
},
|
|
),
|
|
)),
|
|
a.push("]"),
|
|
a.push(this.rawSpaceAfter),
|
|
a.join("")
|
|
);
|
|
}),
|
|
d1(e, [
|
|
{
|
|
key: "quoted",
|
|
get: function () {
|
|
var n = this.quoteMark;
|
|
return n === "'" || n === '"';
|
|
},
|
|
set: function (n) {
|
|
y1();
|
|
},
|
|
},
|
|
{
|
|
key: "quoteMark",
|
|
get: function () {
|
|
return this._quoteMark;
|
|
},
|
|
set: function (n) {
|
|
if (!this._constructed) {
|
|
this._quoteMark = n;
|
|
return;
|
|
}
|
|
this._quoteMark !== n &&
|
|
((this._quoteMark = n), this._syncRawValue());
|
|
},
|
|
},
|
|
{
|
|
key: "qualifiedAttribute",
|
|
get: function () {
|
|
return this.qualifiedName(this.raws.attribute || this.attribute);
|
|
},
|
|
},
|
|
{
|
|
key: "insensitiveFlag",
|
|
get: function () {
|
|
return this.insensitive ? "i" : "";
|
|
},
|
|
},
|
|
{
|
|
key: "value",
|
|
get: function () {
|
|
return this._value;
|
|
},
|
|
set: function (n) {
|
|
if (this._constructed) {
|
|
var a = la(n),
|
|
s = a.deprecatedUsage,
|
|
o = a.unescaped,
|
|
u = a.quoteMark;
|
|
if ((s && g1(), o === this._value && u === this._quoteMark))
|
|
return;
|
|
(this._value = o), (this._quoteMark = u), this._syncRawValue();
|
|
} else this._value = n;
|
|
},
|
|
},
|
|
{
|
|
key: "insensitive",
|
|
get: function () {
|
|
return this._insensitive;
|
|
},
|
|
set: function (n) {
|
|
n ||
|
|
((this._insensitive = !1),
|
|
this.raws &&
|
|
(this.raws.insensitiveFlag === "I" ||
|
|
this.raws.insensitiveFlag === "i") &&
|
|
(this.raws.insensitiveFlag = void 0)),
|
|
(this._insensitive = n);
|
|
},
|
|
},
|
|
{
|
|
key: "attribute",
|
|
get: function () {
|
|
return this._attribute;
|
|
},
|
|
set: function (n) {
|
|
this._handleEscapes("attribute", n), (this._attribute = n);
|
|
},
|
|
},
|
|
]),
|
|
e
|
|
);
|
|
})(c1.default);
|
|
Lr.default = rn;
|
|
rn.NO_QUOTE = null;
|
|
rn.SINGLE_QUOTE = "'";
|
|
rn.DOUBLE_QUOTE = '"';
|
|
var ua =
|
|
((sa = {
|
|
"'": { quotes: "single", wrap: !0 },
|
|
'"': { quotes: "double", wrap: !0 },
|
|
}),
|
|
(sa[null] = { isIdentifier: !0 }),
|
|
sa);
|
|
function sp(i, e) {
|
|
return "" + e.before + i + e.after;
|
|
}
|
|
});
|
|
var pa = v(($r, ap) => {
|
|
l();
|
|
("use strict");
|
|
$r.__esModule = !0;
|
|
$r.default = void 0;
|
|
var v1 = k1(tn()),
|
|
x1 = se();
|
|
function k1(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function S1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
ca(i, e);
|
|
}
|
|
function ca(i, e) {
|
|
return (
|
|
(ca = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
ca(i, e)
|
|
);
|
|
}
|
|
var C1 = (function (i) {
|
|
S1(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (
|
|
(r = i.call(this, t) || this),
|
|
(r.type = x1.UNIVERSAL),
|
|
(r.value = "*"),
|
|
r
|
|
);
|
|
}
|
|
return e;
|
|
})(v1.default);
|
|
$r.default = C1;
|
|
ap.exports = $r.default;
|
|
});
|
|
var ha = v((jr, op) => {
|
|
l();
|
|
("use strict");
|
|
jr.__esModule = !0;
|
|
jr.default = void 0;
|
|
var A1 = O1(Ue()),
|
|
_1 = se();
|
|
function O1(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function E1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
da(i, e);
|
|
}
|
|
function da(i, e) {
|
|
return (
|
|
(da = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
da(i, e)
|
|
);
|
|
}
|
|
var T1 = (function (i) {
|
|
E1(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (r = i.call(this, t) || this), (r.type = _1.COMBINATOR), r;
|
|
}
|
|
return e;
|
|
})(A1.default);
|
|
jr.default = T1;
|
|
op.exports = jr.default;
|
|
});
|
|
var ga = v((zr, lp) => {
|
|
l();
|
|
("use strict");
|
|
zr.__esModule = !0;
|
|
zr.default = void 0;
|
|
var P1 = I1(Ue()),
|
|
D1 = se();
|
|
function I1(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function q1(i, e) {
|
|
(i.prototype = Object.create(e.prototype)),
|
|
(i.prototype.constructor = i),
|
|
ma(i, e);
|
|
}
|
|
function ma(i, e) {
|
|
return (
|
|
(ma = Object.setPrototypeOf
|
|
? Object.setPrototypeOf.bind()
|
|
: function (r, n) {
|
|
return (r.__proto__ = n), r;
|
|
}),
|
|
ma(i, e)
|
|
);
|
|
}
|
|
var R1 = (function (i) {
|
|
q1(e, i);
|
|
function e(t) {
|
|
var r;
|
|
return (
|
|
(r = i.call(this, t) || this),
|
|
(r.type = D1.NESTING),
|
|
(r.value = "&"),
|
|
r
|
|
);
|
|
}
|
|
return e;
|
|
})(P1.default);
|
|
zr.default = R1;
|
|
lp.exports = zr.default;
|
|
});
|
|
var fp = v((nn, up) => {
|
|
l();
|
|
("use strict");
|
|
nn.__esModule = !0;
|
|
nn.default = M1;
|
|
function M1(i) {
|
|
return i.sort(function (e, t) {
|
|
return e - t;
|
|
});
|
|
}
|
|
up.exports = nn.default;
|
|
});
|
|
var ya = v((D) => {
|
|
l();
|
|
("use strict");
|
|
D.__esModule = !0;
|
|
D.word =
|
|
D.tilde =
|
|
D.tab =
|
|
D.str =
|
|
D.space =
|
|
D.slash =
|
|
D.singleQuote =
|
|
D.semicolon =
|
|
D.plus =
|
|
D.pipe =
|
|
D.openSquare =
|
|
D.openParenthesis =
|
|
D.newline =
|
|
D.greaterThan =
|
|
D.feed =
|
|
D.equals =
|
|
D.doubleQuote =
|
|
D.dollar =
|
|
D.cr =
|
|
D.comment =
|
|
D.comma =
|
|
D.combinator =
|
|
D.colon =
|
|
D.closeSquare =
|
|
D.closeParenthesis =
|
|
D.caret =
|
|
D.bang =
|
|
D.backslash =
|
|
D.at =
|
|
D.asterisk =
|
|
D.ampersand =
|
|
void 0;
|
|
var B1 = 38;
|
|
D.ampersand = B1;
|
|
var F1 = 42;
|
|
D.asterisk = F1;
|
|
var N1 = 64;
|
|
D.at = N1;
|
|
var L1 = 44;
|
|
D.comma = L1;
|
|
var $1 = 58;
|
|
D.colon = $1;
|
|
var j1 = 59;
|
|
D.semicolon = j1;
|
|
var z1 = 40;
|
|
D.openParenthesis = z1;
|
|
var V1 = 41;
|
|
D.closeParenthesis = V1;
|
|
var U1 = 91;
|
|
D.openSquare = U1;
|
|
var W1 = 93;
|
|
D.closeSquare = W1;
|
|
var G1 = 36;
|
|
D.dollar = G1;
|
|
var H1 = 126;
|
|
D.tilde = H1;
|
|
var Y1 = 94;
|
|
D.caret = Y1;
|
|
var Q1 = 43;
|
|
D.plus = Q1;
|
|
var J1 = 61;
|
|
D.equals = J1;
|
|
var X1 = 124;
|
|
D.pipe = X1;
|
|
var K1 = 62;
|
|
D.greaterThan = K1;
|
|
var Z1 = 32;
|
|
D.space = Z1;
|
|
var cp = 39;
|
|
D.singleQuote = cp;
|
|
var ek = 34;
|
|
D.doubleQuote = ek;
|
|
var tk = 47;
|
|
D.slash = tk;
|
|
var rk = 33;
|
|
D.bang = rk;
|
|
var ik = 92;
|
|
D.backslash = ik;
|
|
var nk = 13;
|
|
D.cr = nk;
|
|
var sk = 12;
|
|
D.feed = sk;
|
|
var ak = 10;
|
|
D.newline = ak;
|
|
var ok = 9;
|
|
D.tab = ok;
|
|
var lk = cp;
|
|
D.str = lk;
|
|
var uk = -1;
|
|
D.comment = uk;
|
|
var fk = -2;
|
|
D.word = fk;
|
|
var ck = -3;
|
|
D.combinator = ck;
|
|
});
|
|
var hp = v((Vr) => {
|
|
l();
|
|
("use strict");
|
|
Vr.__esModule = !0;
|
|
Vr.FIELDS = void 0;
|
|
Vr.default = wk;
|
|
var E = pk(ya()),
|
|
Dt,
|
|
U;
|
|
function pp(i) {
|
|
if (typeof WeakMap != "function") return null;
|
|
var e = new WeakMap(),
|
|
t = new WeakMap();
|
|
return (pp = function (n) {
|
|
return n ? t : e;
|
|
})(i);
|
|
}
|
|
function pk(i, e) {
|
|
if (!e && i && i.__esModule) return i;
|
|
if (i === null || (typeof i != "object" && typeof i != "function"))
|
|
return { default: i };
|
|
var t = pp(e);
|
|
if (t && t.has(i)) return t.get(i);
|
|
var r = {},
|
|
n = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var a in i)
|
|
if (a !== "default" && Object.prototype.hasOwnProperty.call(i, a)) {
|
|
var s = n ? Object.getOwnPropertyDescriptor(i, a) : null;
|
|
s && (s.get || s.set)
|
|
? Object.defineProperty(r, a, s)
|
|
: (r[a] = i[a]);
|
|
}
|
|
return (r.default = i), t && t.set(i, r), r;
|
|
}
|
|
var dk =
|
|
((Dt = {}),
|
|
(Dt[E.tab] = !0),
|
|
(Dt[E.newline] = !0),
|
|
(Dt[E.cr] = !0),
|
|
(Dt[E.feed] = !0),
|
|
Dt),
|
|
hk =
|
|
((U = {}),
|
|
(U[E.space] = !0),
|
|
(U[E.tab] = !0),
|
|
(U[E.newline] = !0),
|
|
(U[E.cr] = !0),
|
|
(U[E.feed] = !0),
|
|
(U[E.ampersand] = !0),
|
|
(U[E.asterisk] = !0),
|
|
(U[E.bang] = !0),
|
|
(U[E.comma] = !0),
|
|
(U[E.colon] = !0),
|
|
(U[E.semicolon] = !0),
|
|
(U[E.openParenthesis] = !0),
|
|
(U[E.closeParenthesis] = !0),
|
|
(U[E.openSquare] = !0),
|
|
(U[E.closeSquare] = !0),
|
|
(U[E.singleQuote] = !0),
|
|
(U[E.doubleQuote] = !0),
|
|
(U[E.plus] = !0),
|
|
(U[E.pipe] = !0),
|
|
(U[E.tilde] = !0),
|
|
(U[E.greaterThan] = !0),
|
|
(U[E.equals] = !0),
|
|
(U[E.dollar] = !0),
|
|
(U[E.caret] = !0),
|
|
(U[E.slash] = !0),
|
|
U),
|
|
wa = {},
|
|
dp = "0123456789abcdefABCDEF";
|
|
for (sn = 0; sn < dp.length; sn++) wa[dp.charCodeAt(sn)] = !0;
|
|
var sn;
|
|
function mk(i, e) {
|
|
var t = e,
|
|
r;
|
|
do {
|
|
if (((r = i.charCodeAt(t)), hk[r])) return t - 1;
|
|
r === E.backslash ? (t = gk(i, t) + 1) : t++;
|
|
} while (t < i.length);
|
|
return t - 1;
|
|
}
|
|
function gk(i, e) {
|
|
var t = e,
|
|
r = i.charCodeAt(t + 1);
|
|
if (!dk[r])
|
|
if (wa[r]) {
|
|
var n = 0;
|
|
do t++, n++, (r = i.charCodeAt(t + 1));
|
|
while (wa[r] && n < 6);
|
|
n < 6 && r === E.space && t++;
|
|
} else t++;
|
|
return t;
|
|
}
|
|
var yk = {
|
|
TYPE: 0,
|
|
START_LINE: 1,
|
|
START_COL: 2,
|
|
END_LINE: 3,
|
|
END_COL: 4,
|
|
START_POS: 5,
|
|
END_POS: 6,
|
|
};
|
|
Vr.FIELDS = yk;
|
|
function wk(i) {
|
|
var e = [],
|
|
t = i.css.valueOf(),
|
|
r = t,
|
|
n = r.length,
|
|
a = -1,
|
|
s = 1,
|
|
o = 0,
|
|
u = 0,
|
|
c,
|
|
f,
|
|
d,
|
|
p,
|
|
m,
|
|
w,
|
|
x,
|
|
y,
|
|
b,
|
|
k,
|
|
S,
|
|
_,
|
|
O;
|
|
function I(B, q) {
|
|
if (i.safe) (t += q), (b = t.length - 1);
|
|
else throw i.error("Unclosed " + B, s, o - a, o);
|
|
}
|
|
for (; o < n; ) {
|
|
switch (
|
|
((c = t.charCodeAt(o)), c === E.newline && ((a = o), (s += 1)), c)
|
|
) {
|
|
case E.space:
|
|
case E.tab:
|
|
case E.newline:
|
|
case E.cr:
|
|
case E.feed:
|
|
b = o;
|
|
do
|
|
(b += 1),
|
|
(c = t.charCodeAt(b)),
|
|
c === E.newline && ((a = b), (s += 1));
|
|
while (
|
|
c === E.space ||
|
|
c === E.newline ||
|
|
c === E.tab ||
|
|
c === E.cr ||
|
|
c === E.feed
|
|
);
|
|
(O = E.space), (p = s), (d = b - a - 1), (u = b);
|
|
break;
|
|
case E.plus:
|
|
case E.greaterThan:
|
|
case E.tilde:
|
|
case E.pipe:
|
|
b = o;
|
|
do (b += 1), (c = t.charCodeAt(b));
|
|
while (
|
|
c === E.plus ||
|
|
c === E.greaterThan ||
|
|
c === E.tilde ||
|
|
c === E.pipe
|
|
);
|
|
(O = E.combinator), (p = s), (d = o - a), (u = b);
|
|
break;
|
|
case E.asterisk:
|
|
case E.ampersand:
|
|
case E.bang:
|
|
case E.comma:
|
|
case E.equals:
|
|
case E.dollar:
|
|
case E.caret:
|
|
case E.openSquare:
|
|
case E.closeSquare:
|
|
case E.colon:
|
|
case E.semicolon:
|
|
case E.openParenthesis:
|
|
case E.closeParenthesis:
|
|
(b = o), (O = c), (p = s), (d = o - a), (u = b + 1);
|
|
break;
|
|
case E.singleQuote:
|
|
case E.doubleQuote:
|
|
(_ = c === E.singleQuote ? "'" : '"'), (b = o);
|
|
do
|
|
for (
|
|
m = !1,
|
|
b = t.indexOf(_, b + 1),
|
|
b === -1 && I("quote", _),
|
|
w = b;
|
|
t.charCodeAt(w - 1) === E.backslash;
|
|
|
|
)
|
|
(w -= 1), (m = !m);
|
|
while (m);
|
|
(O = E.str), (p = s), (d = o - a), (u = b + 1);
|
|
break;
|
|
default:
|
|
c === E.slash && t.charCodeAt(o + 1) === E.asterisk
|
|
? ((b = t.indexOf("*/", o + 2) + 1),
|
|
b === 0 && I("comment", "*/"),
|
|
(f = t.slice(o, b + 1)),
|
|
(y = f.split(`
|
|
`)),
|
|
(x = y.length - 1),
|
|
x > 0
|
|
? ((k = s + x), (S = b - y[x].length))
|
|
: ((k = s), (S = a)),
|
|
(O = E.comment),
|
|
(s = k),
|
|
(p = k),
|
|
(d = b - S))
|
|
: c === E.slash
|
|
? ((b = o), (O = c), (p = s), (d = o - a), (u = b + 1))
|
|
: ((b = mk(t, o)), (O = E.word), (p = s), (d = b - a)),
|
|
(u = b + 1);
|
|
break;
|
|
}
|
|
e.push([O, s, o - a, p, d, o, u]), S && ((a = S), (S = null)), (o = u);
|
|
}
|
|
return e;
|
|
}
|
|
});
|
|
var kp = v((Ur, xp) => {
|
|
l();
|
|
("use strict");
|
|
Ur.__esModule = !0;
|
|
Ur.default = void 0;
|
|
var bk = be(zs()),
|
|
ba = be(Us()),
|
|
vk = be(Hs()),
|
|
mp = be(Qs()),
|
|
xk = be(Xs()),
|
|
kk = be(ea()),
|
|
va = be(ra()),
|
|
Sk = be(na()),
|
|
gp = an(fa()),
|
|
Ck = be(pa()),
|
|
xa = be(ha()),
|
|
Ak = be(ga()),
|
|
_k = be(fp()),
|
|
A = an(hp()),
|
|
T = an(ya()),
|
|
Ok = an(se()),
|
|
Q = Ar(),
|
|
wt,
|
|
ka;
|
|
function yp(i) {
|
|
if (typeof WeakMap != "function") return null;
|
|
var e = new WeakMap(),
|
|
t = new WeakMap();
|
|
return (yp = function (n) {
|
|
return n ? t : e;
|
|
})(i);
|
|
}
|
|
function an(i, e) {
|
|
if (!e && i && i.__esModule) return i;
|
|
if (i === null || (typeof i != "object" && typeof i != "function"))
|
|
return { default: i };
|
|
var t = yp(e);
|
|
if (t && t.has(i)) return t.get(i);
|
|
var r = {},
|
|
n = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var a in i)
|
|
if (a !== "default" && Object.prototype.hasOwnProperty.call(i, a)) {
|
|
var s = n ? Object.getOwnPropertyDescriptor(i, a) : null;
|
|
s && (s.get || s.set)
|
|
? Object.defineProperty(r, a, s)
|
|
: (r[a] = i[a]);
|
|
}
|
|
return (r.default = i), t && t.set(i, r), r;
|
|
}
|
|
function be(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
function wp(i, e) {
|
|
for (var t = 0; t < e.length; t++) {
|
|
var r = e[t];
|
|
(r.enumerable = r.enumerable || !1),
|
|
(r.configurable = !0),
|
|
"value" in r && (r.writable = !0),
|
|
Object.defineProperty(i, r.key, r);
|
|
}
|
|
}
|
|
function Ek(i, e, t) {
|
|
return (
|
|
e && wp(i.prototype, e),
|
|
t && wp(i, t),
|
|
Object.defineProperty(i, "prototype", { writable: !1 }),
|
|
i
|
|
);
|
|
}
|
|
var Sa =
|
|
((wt = {}),
|
|
(wt[T.space] = !0),
|
|
(wt[T.cr] = !0),
|
|
(wt[T.feed] = !0),
|
|
(wt[T.newline] = !0),
|
|
(wt[T.tab] = !0),
|
|
wt),
|
|
Tk = Object.assign({}, Sa, ((ka = {}), (ka[T.comment] = !0), ka));
|
|
function bp(i) {
|
|
return { line: i[A.FIELDS.START_LINE], column: i[A.FIELDS.START_COL] };
|
|
}
|
|
function vp(i) {
|
|
return { line: i[A.FIELDS.END_LINE], column: i[A.FIELDS.END_COL] };
|
|
}
|
|
function bt(i, e, t, r) {
|
|
return { start: { line: i, column: e }, end: { line: t, column: r } };
|
|
}
|
|
function It(i) {
|
|
return bt(
|
|
i[A.FIELDS.START_LINE],
|
|
i[A.FIELDS.START_COL],
|
|
i[A.FIELDS.END_LINE],
|
|
i[A.FIELDS.END_COL],
|
|
);
|
|
}
|
|
function Ca(i, e) {
|
|
if (!!i)
|
|
return bt(
|
|
i[A.FIELDS.START_LINE],
|
|
i[A.FIELDS.START_COL],
|
|
e[A.FIELDS.END_LINE],
|
|
e[A.FIELDS.END_COL],
|
|
);
|
|
}
|
|
function qt(i, e) {
|
|
var t = i[e];
|
|
if (typeof t == "string")
|
|
return (
|
|
t.indexOf("\\") !== -1 &&
|
|
((0, Q.ensureObject)(i, "raws"),
|
|
(i[e] = (0, Q.unesc)(t)),
|
|
i.raws[e] === void 0 && (i.raws[e] = t)),
|
|
i
|
|
);
|
|
}
|
|
function Aa(i, e) {
|
|
for (var t = -1, r = []; (t = i.indexOf(e, t + 1)) !== -1; ) r.push(t);
|
|
return r;
|
|
}
|
|
function Pk() {
|
|
var i = Array.prototype.concat.apply([], arguments);
|
|
return i.filter(function (e, t) {
|
|
return t === i.indexOf(e);
|
|
});
|
|
}
|
|
var Dk = (function () {
|
|
function i(t, r) {
|
|
r === void 0 && (r = {}),
|
|
(this.rule = t),
|
|
(this.options = Object.assign({ lossy: !1, safe: !1 }, r)),
|
|
(this.position = 0),
|
|
(this.css =
|
|
typeof this.rule == "string" ? this.rule : this.rule.selector),
|
|
(this.tokens = (0, A.default)({
|
|
css: this.css,
|
|
error: this._errorGenerator(),
|
|
safe: this.options.safe,
|
|
}));
|
|
var n = Ca(this.tokens[0], this.tokens[this.tokens.length - 1]);
|
|
(this.root = new bk.default({ source: n })),
|
|
(this.root.errorGenerator = this._errorGenerator());
|
|
var a = new ba.default({ source: { start: { line: 1, column: 1 } } });
|
|
this.root.append(a), (this.current = a), this.loop();
|
|
}
|
|
var e = i.prototype;
|
|
return (
|
|
(e._errorGenerator = function () {
|
|
var r = this;
|
|
return function (n, a) {
|
|
return typeof r.rule == "string"
|
|
? new Error(n)
|
|
: r.rule.error(n, a);
|
|
};
|
|
}),
|
|
(e.attribute = function () {
|
|
var r = [],
|
|
n = this.currToken;
|
|
for (
|
|
this.position++;
|
|
this.position < this.tokens.length &&
|
|
this.currToken[A.FIELDS.TYPE] !== T.closeSquare;
|
|
|
|
)
|
|
r.push(this.currToken), this.position++;
|
|
if (this.currToken[A.FIELDS.TYPE] !== T.closeSquare)
|
|
return this.expected(
|
|
"closing square bracket",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
var a = r.length,
|
|
s = {
|
|
source: bt(n[1], n[2], this.currToken[3], this.currToken[4]),
|
|
sourceIndex: n[A.FIELDS.START_POS],
|
|
};
|
|
if (a === 1 && !~[T.word].indexOf(r[0][A.FIELDS.TYPE]))
|
|
return this.expected("attribute", r[0][A.FIELDS.START_POS]);
|
|
for (var o = 0, u = "", c = "", f = null, d = !1; o < a; ) {
|
|
var p = r[o],
|
|
m = this.content(p),
|
|
w = r[o + 1];
|
|
switch (p[A.FIELDS.TYPE]) {
|
|
case T.space:
|
|
if (((d = !0), this.options.lossy)) break;
|
|
if (f) {
|
|
(0, Q.ensureObject)(s, "spaces", f);
|
|
var x = s.spaces[f].after || "";
|
|
s.spaces[f].after = x + m;
|
|
var y =
|
|
(0, Q.getProp)(s, "raws", "spaces", f, "after") || null;
|
|
y && (s.raws.spaces[f].after = y + m);
|
|
} else (u = u + m), (c = c + m);
|
|
break;
|
|
case T.asterisk:
|
|
if (w[A.FIELDS.TYPE] === T.equals)
|
|
(s.operator = m), (f = "operator");
|
|
else if ((!s.namespace || (f === "namespace" && !d)) && w) {
|
|
u &&
|
|
((0, Q.ensureObject)(s, "spaces", "attribute"),
|
|
(s.spaces.attribute.before = u),
|
|
(u = "")),
|
|
c &&
|
|
((0, Q.ensureObject)(s, "raws", "spaces", "attribute"),
|
|
(s.raws.spaces.attribute.before = u),
|
|
(c = "")),
|
|
(s.namespace = (s.namespace || "") + m);
|
|
var b = (0, Q.getProp)(s, "raws", "namespace") || null;
|
|
b && (s.raws.namespace += m), (f = "namespace");
|
|
}
|
|
d = !1;
|
|
break;
|
|
case T.dollar:
|
|
if (f === "value") {
|
|
var k = (0, Q.getProp)(s, "raws", "value");
|
|
(s.value += "$"), k && (s.raws.value = k + "$");
|
|
break;
|
|
}
|
|
case T.caret:
|
|
w[A.FIELDS.TYPE] === T.equals &&
|
|
((s.operator = m), (f = "operator")),
|
|
(d = !1);
|
|
break;
|
|
case T.combinator:
|
|
if (
|
|
(m === "~" &&
|
|
w[A.FIELDS.TYPE] === T.equals &&
|
|
((s.operator = m), (f = "operator")),
|
|
m !== "|")
|
|
) {
|
|
d = !1;
|
|
break;
|
|
}
|
|
w[A.FIELDS.TYPE] === T.equals
|
|
? ((s.operator = m), (f = "operator"))
|
|
: !s.namespace && !s.attribute && (s.namespace = !0),
|
|
(d = !1);
|
|
break;
|
|
case T.word:
|
|
if (
|
|
w &&
|
|
this.content(w) === "|" &&
|
|
r[o + 2] &&
|
|
r[o + 2][A.FIELDS.TYPE] !== T.equals &&
|
|
!s.operator &&
|
|
!s.namespace
|
|
)
|
|
(s.namespace = m), (f = "namespace");
|
|
else if (!s.attribute || (f === "attribute" && !d)) {
|
|
u &&
|
|
((0, Q.ensureObject)(s, "spaces", "attribute"),
|
|
(s.spaces.attribute.before = u),
|
|
(u = "")),
|
|
c &&
|
|
((0, Q.ensureObject)(s, "raws", "spaces", "attribute"),
|
|
(s.raws.spaces.attribute.before = c),
|
|
(c = "")),
|
|
(s.attribute = (s.attribute || "") + m);
|
|
var S = (0, Q.getProp)(s, "raws", "attribute") || null;
|
|
S && (s.raws.attribute += m), (f = "attribute");
|
|
} else if (
|
|
(!s.value && s.value !== "") ||
|
|
(f === "value" && !(d || s.quoteMark))
|
|
) {
|
|
var _ = (0, Q.unesc)(m),
|
|
O = (0, Q.getProp)(s, "raws", "value") || "",
|
|
I = s.value || "";
|
|
(s.value = I + _),
|
|
(s.quoteMark = null),
|
|
(_ !== m || O) &&
|
|
((0, Q.ensureObject)(s, "raws"),
|
|
(s.raws.value = (O || I) + m)),
|
|
(f = "value");
|
|
} else {
|
|
var B = m === "i" || m === "I";
|
|
(s.value || s.value === "") && (s.quoteMark || d)
|
|
? ((s.insensitive = B),
|
|
(!B || m === "I") &&
|
|
((0, Q.ensureObject)(s, "raws"),
|
|
(s.raws.insensitiveFlag = m)),
|
|
(f = "insensitive"),
|
|
u &&
|
|
((0, Q.ensureObject)(s, "spaces", "insensitive"),
|
|
(s.spaces.insensitive.before = u),
|
|
(u = "")),
|
|
c &&
|
|
((0, Q.ensureObject)(
|
|
s,
|
|
"raws",
|
|
"spaces",
|
|
"insensitive",
|
|
),
|
|
(s.raws.spaces.insensitive.before = c),
|
|
(c = "")))
|
|
: (s.value || s.value === "") &&
|
|
((f = "value"),
|
|
(s.value += m),
|
|
s.raws.value && (s.raws.value += m));
|
|
}
|
|
d = !1;
|
|
break;
|
|
case T.str:
|
|
if (!s.attribute || !s.operator)
|
|
return this.error(
|
|
"Expected an attribute followed by an operator preceding the string.",
|
|
{ index: p[A.FIELDS.START_POS] },
|
|
);
|
|
var q = (0, gp.unescapeValue)(m),
|
|
X = q.unescaped,
|
|
le = q.quoteMark;
|
|
(s.value = X),
|
|
(s.quoteMark = le),
|
|
(f = "value"),
|
|
(0, Q.ensureObject)(s, "raws"),
|
|
(s.raws.value = m),
|
|
(d = !1);
|
|
break;
|
|
case T.equals:
|
|
if (!s.attribute)
|
|
return this.expected("attribute", p[A.FIELDS.START_POS], m);
|
|
if (s.value)
|
|
return this.error(
|
|
'Unexpected "=" found; an operator was already defined.',
|
|
{ index: p[A.FIELDS.START_POS] },
|
|
);
|
|
(s.operator = s.operator ? s.operator + m : m),
|
|
(f = "operator"),
|
|
(d = !1);
|
|
break;
|
|
case T.comment:
|
|
if (f)
|
|
if (
|
|
d ||
|
|
(w && w[A.FIELDS.TYPE] === T.space) ||
|
|
f === "insensitive"
|
|
) {
|
|
var ce = (0, Q.getProp)(s, "spaces", f, "after") || "",
|
|
$e =
|
|
(0, Q.getProp)(s, "raws", "spaces", f, "after") || ce;
|
|
(0, Q.ensureObject)(s, "raws", "spaces", f),
|
|
(s.raws.spaces[f].after = $e + m);
|
|
} else {
|
|
var j = s[f] || "",
|
|
ue = (0, Q.getProp)(s, "raws", f) || j;
|
|
(0, Q.ensureObject)(s, "raws"), (s.raws[f] = ue + m);
|
|
}
|
|
else c = c + m;
|
|
break;
|
|
default:
|
|
return this.error('Unexpected "' + m + '" found.', {
|
|
index: p[A.FIELDS.START_POS],
|
|
});
|
|
}
|
|
o++;
|
|
}
|
|
qt(s, "attribute"),
|
|
qt(s, "namespace"),
|
|
this.newNode(new gp.default(s)),
|
|
this.position++;
|
|
}),
|
|
(e.parseWhitespaceEquivalentTokens = function (r) {
|
|
r < 0 && (r = this.tokens.length);
|
|
var n = this.position,
|
|
a = [],
|
|
s = "",
|
|
o = void 0;
|
|
do
|
|
if (Sa[this.currToken[A.FIELDS.TYPE]])
|
|
this.options.lossy || (s += this.content());
|
|
else if (this.currToken[A.FIELDS.TYPE] === T.comment) {
|
|
var u = {};
|
|
s && ((u.before = s), (s = "")),
|
|
(o = new mp.default({
|
|
value: this.content(),
|
|
source: It(this.currToken),
|
|
sourceIndex: this.currToken[A.FIELDS.START_POS],
|
|
spaces: u,
|
|
})),
|
|
a.push(o);
|
|
}
|
|
while (++this.position < r);
|
|
if (s) {
|
|
if (o) o.spaces.after = s;
|
|
else if (!this.options.lossy) {
|
|
var c = this.tokens[n],
|
|
f = this.tokens[this.position - 1];
|
|
a.push(
|
|
new va.default({
|
|
value: "",
|
|
source: bt(
|
|
c[A.FIELDS.START_LINE],
|
|
c[A.FIELDS.START_COL],
|
|
f[A.FIELDS.END_LINE],
|
|
f[A.FIELDS.END_COL],
|
|
),
|
|
sourceIndex: c[A.FIELDS.START_POS],
|
|
spaces: { before: s, after: "" },
|
|
}),
|
|
);
|
|
}
|
|
}
|
|
return a;
|
|
}),
|
|
(e.convertWhitespaceNodesToSpace = function (r, n) {
|
|
var a = this;
|
|
n === void 0 && (n = !1);
|
|
var s = "",
|
|
o = "";
|
|
r.forEach(function (c) {
|
|
var f = a.lossySpace(c.spaces.before, n),
|
|
d = a.lossySpace(c.rawSpaceBefore, n);
|
|
(s += f + a.lossySpace(c.spaces.after, n && f.length === 0)),
|
|
(o +=
|
|
f +
|
|
c.value +
|
|
a.lossySpace(c.rawSpaceAfter, n && d.length === 0));
|
|
}),
|
|
o === s && (o = void 0);
|
|
var u = { space: s, rawSpace: o };
|
|
return u;
|
|
}),
|
|
(e.isNamedCombinator = function (r) {
|
|
return (
|
|
r === void 0 && (r = this.position),
|
|
this.tokens[r + 0] &&
|
|
this.tokens[r + 0][A.FIELDS.TYPE] === T.slash &&
|
|
this.tokens[r + 1] &&
|
|
this.tokens[r + 1][A.FIELDS.TYPE] === T.word &&
|
|
this.tokens[r + 2] &&
|
|
this.tokens[r + 2][A.FIELDS.TYPE] === T.slash
|
|
);
|
|
}),
|
|
(e.namedCombinator = function () {
|
|
if (this.isNamedCombinator()) {
|
|
var r = this.content(this.tokens[this.position + 1]),
|
|
n = (0, Q.unesc)(r).toLowerCase(),
|
|
a = {};
|
|
n !== r && (a.value = "/" + r + "/");
|
|
var s = new xa.default({
|
|
value: "/" + n + "/",
|
|
source: bt(
|
|
this.currToken[A.FIELDS.START_LINE],
|
|
this.currToken[A.FIELDS.START_COL],
|
|
this.tokens[this.position + 2][A.FIELDS.END_LINE],
|
|
this.tokens[this.position + 2][A.FIELDS.END_COL],
|
|
),
|
|
sourceIndex: this.currToken[A.FIELDS.START_POS],
|
|
raws: a,
|
|
});
|
|
return (this.position = this.position + 3), s;
|
|
} else this.unexpected();
|
|
}),
|
|
(e.combinator = function () {
|
|
var r = this;
|
|
if (this.content() === "|") return this.namespace();
|
|
var n = this.locateNextMeaningfulToken(this.position);
|
|
if (n < 0 || this.tokens[n][A.FIELDS.TYPE] === T.comma) {
|
|
var a = this.parseWhitespaceEquivalentTokens(n);
|
|
if (a.length > 0) {
|
|
var s = this.current.last;
|
|
if (s) {
|
|
var o = this.convertWhitespaceNodesToSpace(a),
|
|
u = o.space,
|
|
c = o.rawSpace;
|
|
c !== void 0 && (s.rawSpaceAfter += c), (s.spaces.after += u);
|
|
} else
|
|
a.forEach(function (O) {
|
|
return r.newNode(O);
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
var f = this.currToken,
|
|
d = void 0;
|
|
n > this.position && (d = this.parseWhitespaceEquivalentTokens(n));
|
|
var p;
|
|
if (
|
|
(this.isNamedCombinator()
|
|
? (p = this.namedCombinator())
|
|
: this.currToken[A.FIELDS.TYPE] === T.combinator
|
|
? ((p = new xa.default({
|
|
value: this.content(),
|
|
source: It(this.currToken),
|
|
sourceIndex: this.currToken[A.FIELDS.START_POS],
|
|
})),
|
|
this.position++)
|
|
: Sa[this.currToken[A.FIELDS.TYPE]] || d || this.unexpected(),
|
|
p)
|
|
) {
|
|
if (d) {
|
|
var m = this.convertWhitespaceNodesToSpace(d),
|
|
w = m.space,
|
|
x = m.rawSpace;
|
|
(p.spaces.before = w), (p.rawSpaceBefore = x);
|
|
}
|
|
} else {
|
|
var y = this.convertWhitespaceNodesToSpace(d, !0),
|
|
b = y.space,
|
|
k = y.rawSpace;
|
|
k || (k = b);
|
|
var S = {},
|
|
_ = { spaces: {} };
|
|
b.endsWith(" ") && k.endsWith(" ")
|
|
? ((S.before = b.slice(0, b.length - 1)),
|
|
(_.spaces.before = k.slice(0, k.length - 1)))
|
|
: b.startsWith(" ") && k.startsWith(" ")
|
|
? ((S.after = b.slice(1)), (_.spaces.after = k.slice(1)))
|
|
: (_.value = k),
|
|
(p = new xa.default({
|
|
value: " ",
|
|
source: Ca(f, this.tokens[this.position - 1]),
|
|
sourceIndex: f[A.FIELDS.START_POS],
|
|
spaces: S,
|
|
raws: _,
|
|
}));
|
|
}
|
|
return (
|
|
this.currToken &&
|
|
this.currToken[A.FIELDS.TYPE] === T.space &&
|
|
((p.spaces.after = this.optionalSpace(this.content())),
|
|
this.position++),
|
|
this.newNode(p)
|
|
);
|
|
}),
|
|
(e.comma = function () {
|
|
if (this.position === this.tokens.length - 1) {
|
|
(this.root.trailingComma = !0), this.position++;
|
|
return;
|
|
}
|
|
this.current._inferEndPosition();
|
|
var r = new ba.default({
|
|
source: { start: bp(this.tokens[this.position + 1]) },
|
|
});
|
|
this.current.parent.append(r), (this.current = r), this.position++;
|
|
}),
|
|
(e.comment = function () {
|
|
var r = this.currToken;
|
|
this.newNode(
|
|
new mp.default({
|
|
value: this.content(),
|
|
source: It(r),
|
|
sourceIndex: r[A.FIELDS.START_POS],
|
|
}),
|
|
),
|
|
this.position++;
|
|
}),
|
|
(e.error = function (r, n) {
|
|
throw this.root.error(r, n);
|
|
}),
|
|
(e.missingBackslash = function () {
|
|
return this.error("Expected a backslash preceding the semicolon.", {
|
|
index: this.currToken[A.FIELDS.START_POS],
|
|
});
|
|
}),
|
|
(e.missingParenthesis = function () {
|
|
return this.expected(
|
|
"opening parenthesis",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.missingSquareBracket = function () {
|
|
return this.expected(
|
|
"opening square bracket",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.unexpected = function () {
|
|
return this.error(
|
|
"Unexpected '" +
|
|
this.content() +
|
|
"'. Escaping special characters with \\ may help.",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.unexpectedPipe = function () {
|
|
return this.error(
|
|
"Unexpected '|'.",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.namespace = function () {
|
|
var r = (this.prevToken && this.content(this.prevToken)) || !0;
|
|
if (this.nextToken[A.FIELDS.TYPE] === T.word)
|
|
return this.position++, this.word(r);
|
|
if (this.nextToken[A.FIELDS.TYPE] === T.asterisk)
|
|
return this.position++, this.universal(r);
|
|
this.unexpectedPipe();
|
|
}),
|
|
(e.nesting = function () {
|
|
if (this.nextToken) {
|
|
var r = this.content(this.nextToken);
|
|
if (r === "|") {
|
|
this.position++;
|
|
return;
|
|
}
|
|
}
|
|
var n = this.currToken;
|
|
this.newNode(
|
|
new Ak.default({
|
|
value: this.content(),
|
|
source: It(n),
|
|
sourceIndex: n[A.FIELDS.START_POS],
|
|
}),
|
|
),
|
|
this.position++;
|
|
}),
|
|
(e.parentheses = function () {
|
|
var r = this.current.last,
|
|
n = 1;
|
|
if ((this.position++, r && r.type === Ok.PSEUDO)) {
|
|
var a = new ba.default({
|
|
source: { start: bp(this.tokens[this.position - 1]) },
|
|
}),
|
|
s = this.current;
|
|
for (
|
|
r.append(a), this.current = a;
|
|
this.position < this.tokens.length && n;
|
|
|
|
)
|
|
this.currToken[A.FIELDS.TYPE] === T.openParenthesis && n++,
|
|
this.currToken[A.FIELDS.TYPE] === T.closeParenthesis && n--,
|
|
n
|
|
? this.parse()
|
|
: ((this.current.source.end = vp(this.currToken)),
|
|
(this.current.parent.source.end = vp(this.currToken)),
|
|
this.position++);
|
|
this.current = s;
|
|
} else {
|
|
for (
|
|
var o = this.currToken, u = "(", c;
|
|
this.position < this.tokens.length && n;
|
|
|
|
)
|
|
this.currToken[A.FIELDS.TYPE] === T.openParenthesis && n++,
|
|
this.currToken[A.FIELDS.TYPE] === T.closeParenthesis && n--,
|
|
(c = this.currToken),
|
|
(u += this.parseParenthesisToken(this.currToken)),
|
|
this.position++;
|
|
r
|
|
? r.appendToPropertyAndEscape("value", u, u)
|
|
: this.newNode(
|
|
new va.default({
|
|
value: u,
|
|
source: bt(
|
|
o[A.FIELDS.START_LINE],
|
|
o[A.FIELDS.START_COL],
|
|
c[A.FIELDS.END_LINE],
|
|
c[A.FIELDS.END_COL],
|
|
),
|
|
sourceIndex: o[A.FIELDS.START_POS],
|
|
}),
|
|
);
|
|
}
|
|
if (n)
|
|
return this.expected(
|
|
"closing parenthesis",
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.pseudo = function () {
|
|
for (
|
|
var r = this, n = "", a = this.currToken;
|
|
this.currToken && this.currToken[A.FIELDS.TYPE] === T.colon;
|
|
|
|
)
|
|
(n += this.content()), this.position++;
|
|
if (!this.currToken)
|
|
return this.expected(
|
|
["pseudo-class", "pseudo-element"],
|
|
this.position - 1,
|
|
);
|
|
if (this.currToken[A.FIELDS.TYPE] === T.word)
|
|
this.splitWord(!1, function (s, o) {
|
|
(n += s),
|
|
r.newNode(
|
|
new Sk.default({
|
|
value: n,
|
|
source: Ca(a, r.currToken),
|
|
sourceIndex: a[A.FIELDS.START_POS],
|
|
}),
|
|
),
|
|
o > 1 &&
|
|
r.nextToken &&
|
|
r.nextToken[A.FIELDS.TYPE] === T.openParenthesis &&
|
|
r.error("Misplaced parenthesis.", {
|
|
index: r.nextToken[A.FIELDS.START_POS],
|
|
});
|
|
});
|
|
else
|
|
return this.expected(
|
|
["pseudo-class", "pseudo-element"],
|
|
this.currToken[A.FIELDS.START_POS],
|
|
);
|
|
}),
|
|
(e.space = function () {
|
|
var r = this.content();
|
|
this.position === 0 ||
|
|
this.prevToken[A.FIELDS.TYPE] === T.comma ||
|
|
this.prevToken[A.FIELDS.TYPE] === T.openParenthesis ||
|
|
this.current.nodes.every(function (n) {
|
|
return n.type === "comment";
|
|
})
|
|
? ((this.spaces = this.optionalSpace(r)), this.position++)
|
|
: this.position === this.tokens.length - 1 ||
|
|
this.nextToken[A.FIELDS.TYPE] === T.comma ||
|
|
this.nextToken[A.FIELDS.TYPE] === T.closeParenthesis
|
|
? ((this.current.last.spaces.after = this.optionalSpace(r)),
|
|
this.position++)
|
|
: this.combinator();
|
|
}),
|
|
(e.string = function () {
|
|
var r = this.currToken;
|
|
this.newNode(
|
|
new va.default({
|
|
value: this.content(),
|
|
source: It(r),
|
|
sourceIndex: r[A.FIELDS.START_POS],
|
|
}),
|
|
),
|
|
this.position++;
|
|
}),
|
|
(e.universal = function (r) {
|
|
var n = this.nextToken;
|
|
if (n && this.content(n) === "|")
|
|
return this.position++, this.namespace();
|
|
var a = this.currToken;
|
|
this.newNode(
|
|
new Ck.default({
|
|
value: this.content(),
|
|
source: It(a),
|
|
sourceIndex: a[A.FIELDS.START_POS],
|
|
}),
|
|
r,
|
|
),
|
|
this.position++;
|
|
}),
|
|
(e.splitWord = function (r, n) {
|
|
for (
|
|
var a = this, s = this.nextToken, o = this.content();
|
|
s &&
|
|
~[T.dollar, T.caret, T.equals, T.word].indexOf(s[A.FIELDS.TYPE]);
|
|
|
|
) {
|
|
this.position++;
|
|
var u = this.content();
|
|
if (((o += u), u.lastIndexOf("\\") === u.length - 1)) {
|
|
var c = this.nextToken;
|
|
c &&
|
|
c[A.FIELDS.TYPE] === T.space &&
|
|
((o += this.requiredSpace(this.content(c))), this.position++);
|
|
}
|
|
s = this.nextToken;
|
|
}
|
|
var f = Aa(o, ".").filter(function (w) {
|
|
var x = o[w - 1] === "\\",
|
|
y = /^\d+\.\d+%$/.test(o);
|
|
return !x && !y;
|
|
}),
|
|
d = Aa(o, "#").filter(function (w) {
|
|
return o[w - 1] !== "\\";
|
|
}),
|
|
p = Aa(o, "#{");
|
|
p.length &&
|
|
(d = d.filter(function (w) {
|
|
return !~p.indexOf(w);
|
|
}));
|
|
var m = (0, _k.default)(Pk([0].concat(f, d)));
|
|
m.forEach(function (w, x) {
|
|
var y = m[x + 1] || o.length,
|
|
b = o.slice(w, y);
|
|
if (x === 0 && n) return n.call(a, b, m.length);
|
|
var k,
|
|
S = a.currToken,
|
|
_ = S[A.FIELDS.START_POS] + m[x],
|
|
O = bt(S[1], S[2] + w, S[3], S[2] + (y - 1));
|
|
if (~f.indexOf(w)) {
|
|
var I = { value: b.slice(1), source: O, sourceIndex: _ };
|
|
k = new vk.default(qt(I, "value"));
|
|
} else if (~d.indexOf(w)) {
|
|
var B = { value: b.slice(1), source: O, sourceIndex: _ };
|
|
k = new xk.default(qt(B, "value"));
|
|
} else {
|
|
var q = { value: b, source: O, sourceIndex: _ };
|
|
qt(q, "value"), (k = new kk.default(q));
|
|
}
|
|
a.newNode(k, r), (r = null);
|
|
}),
|
|
this.position++;
|
|
}),
|
|
(e.word = function (r) {
|
|
var n = this.nextToken;
|
|
return n && this.content(n) === "|"
|
|
? (this.position++, this.namespace())
|
|
: this.splitWord(r);
|
|
}),
|
|
(e.loop = function () {
|
|
for (; this.position < this.tokens.length; ) this.parse(!0);
|
|
return this.current._inferEndPosition(), this.root;
|
|
}),
|
|
(e.parse = function (r) {
|
|
switch (this.currToken[A.FIELDS.TYPE]) {
|
|
case T.space:
|
|
this.space();
|
|
break;
|
|
case T.comment:
|
|
this.comment();
|
|
break;
|
|
case T.openParenthesis:
|
|
this.parentheses();
|
|
break;
|
|
case T.closeParenthesis:
|
|
r && this.missingParenthesis();
|
|
break;
|
|
case T.openSquare:
|
|
this.attribute();
|
|
break;
|
|
case T.dollar:
|
|
case T.caret:
|
|
case T.equals:
|
|
case T.word:
|
|
this.word();
|
|
break;
|
|
case T.colon:
|
|
this.pseudo();
|
|
break;
|
|
case T.comma:
|
|
this.comma();
|
|
break;
|
|
case T.asterisk:
|
|
this.universal();
|
|
break;
|
|
case T.ampersand:
|
|
this.nesting();
|
|
break;
|
|
case T.slash:
|
|
case T.combinator:
|
|
this.combinator();
|
|
break;
|
|
case T.str:
|
|
this.string();
|
|
break;
|
|
case T.closeSquare:
|
|
this.missingSquareBracket();
|
|
case T.semicolon:
|
|
this.missingBackslash();
|
|
default:
|
|
this.unexpected();
|
|
}
|
|
}),
|
|
(e.expected = function (r, n, a) {
|
|
if (Array.isArray(r)) {
|
|
var s = r.pop();
|
|
r = r.join(", ") + " or " + s;
|
|
}
|
|
var o = /^[aeiou]/.test(r[0]) ? "an" : "a";
|
|
return a
|
|
? this.error(
|
|
"Expected " + o + " " + r + ', found "' + a + '" instead.',
|
|
{ index: n },
|
|
)
|
|
: this.error("Expected " + o + " " + r + ".", { index: n });
|
|
}),
|
|
(e.requiredSpace = function (r) {
|
|
return this.options.lossy ? " " : r;
|
|
}),
|
|
(e.optionalSpace = function (r) {
|
|
return this.options.lossy ? "" : r;
|
|
}),
|
|
(e.lossySpace = function (r, n) {
|
|
return this.options.lossy ? (n ? " " : "") : r;
|
|
}),
|
|
(e.parseParenthesisToken = function (r) {
|
|
var n = this.content(r);
|
|
return r[A.FIELDS.TYPE] === T.space ? this.requiredSpace(n) : n;
|
|
}),
|
|
(e.newNode = function (r, n) {
|
|
return (
|
|
n &&
|
|
(/^ +$/.test(n) &&
|
|
(this.options.lossy || (this.spaces = (this.spaces || "") + n),
|
|
(n = !0)),
|
|
(r.namespace = n),
|
|
qt(r, "namespace")),
|
|
this.spaces &&
|
|
((r.spaces.before = this.spaces), (this.spaces = "")),
|
|
this.current.append(r)
|
|
);
|
|
}),
|
|
(e.content = function (r) {
|
|
return (
|
|
r === void 0 && (r = this.currToken),
|
|
this.css.slice(r[A.FIELDS.START_POS], r[A.FIELDS.END_POS])
|
|
);
|
|
}),
|
|
(e.locateNextMeaningfulToken = function (r) {
|
|
r === void 0 && (r = this.position + 1);
|
|
for (var n = r; n < this.tokens.length; )
|
|
if (Tk[this.tokens[n][A.FIELDS.TYPE]]) {
|
|
n++;
|
|
continue;
|
|
} else return n;
|
|
return -1;
|
|
}),
|
|
Ek(i, [
|
|
{
|
|
key: "currToken",
|
|
get: function () {
|
|
return this.tokens[this.position];
|
|
},
|
|
},
|
|
{
|
|
key: "nextToken",
|
|
get: function () {
|
|
return this.tokens[this.position + 1];
|
|
},
|
|
},
|
|
{
|
|
key: "prevToken",
|
|
get: function () {
|
|
return this.tokens[this.position - 1];
|
|
},
|
|
},
|
|
]),
|
|
i
|
|
);
|
|
})();
|
|
Ur.default = Dk;
|
|
xp.exports = Ur.default;
|
|
});
|
|
var Cp = v((Wr, Sp) => {
|
|
l();
|
|
("use strict");
|
|
Wr.__esModule = !0;
|
|
Wr.default = void 0;
|
|
var Ik = qk(kp());
|
|
function qk(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
var Rk = (function () {
|
|
function i(t, r) {
|
|
(this.func = t || function () {}),
|
|
(this.funcRes = null),
|
|
(this.options = r);
|
|
}
|
|
var e = i.prototype;
|
|
return (
|
|
(e._shouldUpdateSelector = function (r, n) {
|
|
n === void 0 && (n = {});
|
|
var a = Object.assign({}, this.options, n);
|
|
return a.updateSelector === !1 ? !1 : typeof r != "string";
|
|
}),
|
|
(e._isLossy = function (r) {
|
|
r === void 0 && (r = {});
|
|
var n = Object.assign({}, this.options, r);
|
|
return n.lossless === !1;
|
|
}),
|
|
(e._root = function (r, n) {
|
|
n === void 0 && (n = {});
|
|
var a = new Ik.default(r, this._parseOptions(n));
|
|
return a.root;
|
|
}),
|
|
(e._parseOptions = function (r) {
|
|
return { lossy: this._isLossy(r) };
|
|
}),
|
|
(e._run = function (r, n) {
|
|
var a = this;
|
|
return (
|
|
n === void 0 && (n = {}),
|
|
new Promise(function (s, o) {
|
|
try {
|
|
var u = a._root(r, n);
|
|
Promise.resolve(a.func(u))
|
|
.then(function (c) {
|
|
var f = void 0;
|
|
return (
|
|
a._shouldUpdateSelector(r, n) &&
|
|
((f = u.toString()), (r.selector = f)),
|
|
{ transform: c, root: u, string: f }
|
|
);
|
|
})
|
|
.then(s, o);
|
|
} catch (c) {
|
|
o(c);
|
|
return;
|
|
}
|
|
})
|
|
);
|
|
}),
|
|
(e._runSync = function (r, n) {
|
|
n === void 0 && (n = {});
|
|
var a = this._root(r, n),
|
|
s = this.func(a);
|
|
if (s && typeof s.then == "function")
|
|
throw new Error(
|
|
"Selector processor returned a promise to a synchronous call.",
|
|
);
|
|
var o = void 0;
|
|
return (
|
|
n.updateSelector &&
|
|
typeof r != "string" &&
|
|
((o = a.toString()), (r.selector = o)),
|
|
{ transform: s, root: a, string: o }
|
|
);
|
|
}),
|
|
(e.ast = function (r, n) {
|
|
return this._run(r, n).then(function (a) {
|
|
return a.root;
|
|
});
|
|
}),
|
|
(e.astSync = function (r, n) {
|
|
return this._runSync(r, n).root;
|
|
}),
|
|
(e.transform = function (r, n) {
|
|
return this._run(r, n).then(function (a) {
|
|
return a.transform;
|
|
});
|
|
}),
|
|
(e.transformSync = function (r, n) {
|
|
return this._runSync(r, n).transform;
|
|
}),
|
|
(e.process = function (r, n) {
|
|
return this._run(r, n).then(function (a) {
|
|
return a.string || a.root.toString();
|
|
});
|
|
}),
|
|
(e.processSync = function (r, n) {
|
|
var a = this._runSync(r, n);
|
|
return a.string || a.root.toString();
|
|
}),
|
|
i
|
|
);
|
|
})();
|
|
Wr.default = Rk;
|
|
Sp.exports = Wr.default;
|
|
});
|
|
var Ap = v((H) => {
|
|
l();
|
|
("use strict");
|
|
H.__esModule = !0;
|
|
H.universal =
|
|
H.tag =
|
|
H.string =
|
|
H.selector =
|
|
H.root =
|
|
H.pseudo =
|
|
H.nesting =
|
|
H.id =
|
|
H.comment =
|
|
H.combinator =
|
|
H.className =
|
|
H.attribute =
|
|
void 0;
|
|
var Mk = ve(fa()),
|
|
Bk = ve(Hs()),
|
|
Fk = ve(ha()),
|
|
Nk = ve(Qs()),
|
|
Lk = ve(Xs()),
|
|
$k = ve(ga()),
|
|
jk = ve(na()),
|
|
zk = ve(zs()),
|
|
Vk = ve(Us()),
|
|
Uk = ve(ra()),
|
|
Wk = ve(ea()),
|
|
Gk = ve(pa());
|
|
function ve(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
var Hk = function (e) {
|
|
return new Mk.default(e);
|
|
};
|
|
H.attribute = Hk;
|
|
var Yk = function (e) {
|
|
return new Bk.default(e);
|
|
};
|
|
H.className = Yk;
|
|
var Qk = function (e) {
|
|
return new Fk.default(e);
|
|
};
|
|
H.combinator = Qk;
|
|
var Jk = function (e) {
|
|
return new Nk.default(e);
|
|
};
|
|
H.comment = Jk;
|
|
var Xk = function (e) {
|
|
return new Lk.default(e);
|
|
};
|
|
H.id = Xk;
|
|
var Kk = function (e) {
|
|
return new $k.default(e);
|
|
};
|
|
H.nesting = Kk;
|
|
var Zk = function (e) {
|
|
return new jk.default(e);
|
|
};
|
|
H.pseudo = Zk;
|
|
var eS = function (e) {
|
|
return new zk.default(e);
|
|
};
|
|
H.root = eS;
|
|
var tS = function (e) {
|
|
return new Vk.default(e);
|
|
};
|
|
H.selector = tS;
|
|
var rS = function (e) {
|
|
return new Uk.default(e);
|
|
};
|
|
H.string = rS;
|
|
var iS = function (e) {
|
|
return new Wk.default(e);
|
|
};
|
|
H.tag = iS;
|
|
var nS = function (e) {
|
|
return new Gk.default(e);
|
|
};
|
|
H.universal = nS;
|
|
});
|
|
var Tp = v(($) => {
|
|
l();
|
|
("use strict");
|
|
$.__esModule = !0;
|
|
$.isComment = $.isCombinator = $.isClassName = $.isAttribute = void 0;
|
|
$.isContainer = gS;
|
|
$.isIdentifier = void 0;
|
|
$.isNamespace = yS;
|
|
$.isNesting = void 0;
|
|
$.isNode = _a;
|
|
$.isPseudo = void 0;
|
|
$.isPseudoClass = mS;
|
|
$.isPseudoElement = Ep;
|
|
$.isUniversal = $.isTag = $.isString = $.isSelector = $.isRoot = void 0;
|
|
var J = se(),
|
|
pe,
|
|
sS =
|
|
((pe = {}),
|
|
(pe[J.ATTRIBUTE] = !0),
|
|
(pe[J.CLASS] = !0),
|
|
(pe[J.COMBINATOR] = !0),
|
|
(pe[J.COMMENT] = !0),
|
|
(pe[J.ID] = !0),
|
|
(pe[J.NESTING] = !0),
|
|
(pe[J.PSEUDO] = !0),
|
|
(pe[J.ROOT] = !0),
|
|
(pe[J.SELECTOR] = !0),
|
|
(pe[J.STRING] = !0),
|
|
(pe[J.TAG] = !0),
|
|
(pe[J.UNIVERSAL] = !0),
|
|
pe);
|
|
function _a(i) {
|
|
return typeof i == "object" && sS[i.type];
|
|
}
|
|
function xe(i, e) {
|
|
return _a(e) && e.type === i;
|
|
}
|
|
var _p = xe.bind(null, J.ATTRIBUTE);
|
|
$.isAttribute = _p;
|
|
var aS = xe.bind(null, J.CLASS);
|
|
$.isClassName = aS;
|
|
var oS = xe.bind(null, J.COMBINATOR);
|
|
$.isCombinator = oS;
|
|
var lS = xe.bind(null, J.COMMENT);
|
|
$.isComment = lS;
|
|
var uS = xe.bind(null, J.ID);
|
|
$.isIdentifier = uS;
|
|
var fS = xe.bind(null, J.NESTING);
|
|
$.isNesting = fS;
|
|
var Oa = xe.bind(null, J.PSEUDO);
|
|
$.isPseudo = Oa;
|
|
var cS = xe.bind(null, J.ROOT);
|
|
$.isRoot = cS;
|
|
var pS = xe.bind(null, J.SELECTOR);
|
|
$.isSelector = pS;
|
|
var dS = xe.bind(null, J.STRING);
|
|
$.isString = dS;
|
|
var Op = xe.bind(null, J.TAG);
|
|
$.isTag = Op;
|
|
var hS = xe.bind(null, J.UNIVERSAL);
|
|
$.isUniversal = hS;
|
|
function Ep(i) {
|
|
return (
|
|
Oa(i) &&
|
|
i.value &&
|
|
(i.value.startsWith("::") ||
|
|
i.value.toLowerCase() === ":before" ||
|
|
i.value.toLowerCase() === ":after" ||
|
|
i.value.toLowerCase() === ":first-letter" ||
|
|
i.value.toLowerCase() === ":first-line")
|
|
);
|
|
}
|
|
function mS(i) {
|
|
return Oa(i) && !Ep(i);
|
|
}
|
|
function gS(i) {
|
|
return !!(_a(i) && i.walk);
|
|
}
|
|
function yS(i) {
|
|
return _p(i) || Op(i);
|
|
}
|
|
});
|
|
var Pp = v((Ee) => {
|
|
l();
|
|
("use strict");
|
|
Ee.__esModule = !0;
|
|
var Ea = se();
|
|
Object.keys(Ea).forEach(function (i) {
|
|
i === "default" ||
|
|
i === "__esModule" ||
|
|
(i in Ee && Ee[i] === Ea[i]) ||
|
|
(Ee[i] = Ea[i]);
|
|
});
|
|
var Ta = Ap();
|
|
Object.keys(Ta).forEach(function (i) {
|
|
i === "default" ||
|
|
i === "__esModule" ||
|
|
(i in Ee && Ee[i] === Ta[i]) ||
|
|
(Ee[i] = Ta[i]);
|
|
});
|
|
var Pa = Tp();
|
|
Object.keys(Pa).forEach(function (i) {
|
|
i === "default" ||
|
|
i === "__esModule" ||
|
|
(i in Ee && Ee[i] === Pa[i]) ||
|
|
(Ee[i] = Pa[i]);
|
|
});
|
|
});
|
|
var Re = v((Gr, Ip) => {
|
|
l();
|
|
("use strict");
|
|
Gr.__esModule = !0;
|
|
Gr.default = void 0;
|
|
var wS = xS(Cp()),
|
|
bS = vS(Pp());
|
|
function Dp(i) {
|
|
if (typeof WeakMap != "function") return null;
|
|
var e = new WeakMap(),
|
|
t = new WeakMap();
|
|
return (Dp = function (n) {
|
|
return n ? t : e;
|
|
})(i);
|
|
}
|
|
function vS(i, e) {
|
|
if (!e && i && i.__esModule) return i;
|
|
if (i === null || (typeof i != "object" && typeof i != "function"))
|
|
return { default: i };
|
|
var t = Dp(e);
|
|
if (t && t.has(i)) return t.get(i);
|
|
var r = {},
|
|
n = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var a in i)
|
|
if (a !== "default" && Object.prototype.hasOwnProperty.call(i, a)) {
|
|
var s = n ? Object.getOwnPropertyDescriptor(i, a) : null;
|
|
s && (s.get || s.set)
|
|
? Object.defineProperty(r, a, s)
|
|
: (r[a] = i[a]);
|
|
}
|
|
return (r.default = i), t && t.set(i, r), r;
|
|
}
|
|
function xS(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
var Da = function (e) {
|
|
return new wS.default(e);
|
|
};
|
|
Object.assign(Da, bS);
|
|
delete Da.__esModule;
|
|
var kS = Da;
|
|
Gr.default = kS;
|
|
Ip.exports = Gr.default;
|
|
});
|
|
function Ge(i) {
|
|
return ["fontSize", "outline"].includes(i)
|
|
? (e) => (
|
|
typeof e == "function" && (e = e({})),
|
|
Array.isArray(e) && (e = e[0]),
|
|
e
|
|
)
|
|
: i === "fontFamily"
|
|
? (e) => {
|
|
typeof e == "function" && (e = e({}));
|
|
let t = Array.isArray(e) && ne(e[1]) ? e[0] : e;
|
|
return Array.isArray(t) ? t.join(", ") : t;
|
|
}
|
|
: [
|
|
"boxShadow",
|
|
"transitionProperty",
|
|
"transitionDuration",
|
|
"transitionDelay",
|
|
"transitionTimingFunction",
|
|
"backgroundImage",
|
|
"backgroundSize",
|
|
"backgroundColor",
|
|
"cursor",
|
|
"animation",
|
|
].includes(i)
|
|
? (e) => (
|
|
typeof e == "function" && (e = e({})),
|
|
Array.isArray(e) && (e = e.join(", ")),
|
|
e
|
|
)
|
|
: [
|
|
"gridTemplateColumns",
|
|
"gridTemplateRows",
|
|
"objectPosition",
|
|
].includes(i)
|
|
? (e) => (
|
|
typeof e == "function" && (e = e({})),
|
|
typeof e == "string" && (e = V.list.comma(e).join(" ")),
|
|
e
|
|
)
|
|
: (e, t = {}) => (typeof e == "function" && (e = e(t)), e);
|
|
}
|
|
var Hr = C(() => {
|
|
l();
|
|
nt();
|
|
kt();
|
|
});
|
|
var Lp = v((O3, Ba) => {
|
|
l();
|
|
var { Rule: qp, AtRule: SS } = ge(),
|
|
Rp = Re();
|
|
function Ia(i, e) {
|
|
let t;
|
|
try {
|
|
Rp((r) => {
|
|
t = r;
|
|
}).processSync(i);
|
|
} catch (r) {
|
|
throw i.includes(":")
|
|
? e
|
|
? e.error("Missed semicolon")
|
|
: r
|
|
: e
|
|
? e.error(r.message)
|
|
: r;
|
|
}
|
|
return t.at(0);
|
|
}
|
|
function Mp(i, e) {
|
|
let t = !1;
|
|
return (
|
|
i.each((r) => {
|
|
if (r.type === "nesting") {
|
|
let n = e.clone({});
|
|
r.value !== "&"
|
|
? r.replaceWith(Ia(r.value.replace("&", n.toString())))
|
|
: r.replaceWith(n),
|
|
(t = !0);
|
|
} else "nodes" in r && r.nodes && Mp(r, e) && (t = !0);
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
function Bp(i, e) {
|
|
let t = [];
|
|
return (
|
|
i.selectors.forEach((r) => {
|
|
let n = Ia(r, i);
|
|
e.selectors.forEach((a) => {
|
|
if (!a) return;
|
|
let s = Ia(a, e);
|
|
Mp(s, n) ||
|
|
(s.prepend(Rp.combinator({ value: " " })),
|
|
s.prepend(n.clone({}))),
|
|
t.push(s.toString());
|
|
});
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
function on(i, e) {
|
|
let t = i.prev();
|
|
for (e.after(i); t && t.type === "comment"; ) {
|
|
let r = t.prev();
|
|
e.after(t), (t = r);
|
|
}
|
|
return i;
|
|
}
|
|
function CS(i) {
|
|
return function e(t, r, n, a = n) {
|
|
let s = [];
|
|
if (
|
|
(r.each((o) => {
|
|
o.type === "rule" && n
|
|
? a && (o.selectors = Bp(t, o))
|
|
: o.type === "atrule" && o.nodes
|
|
? i[o.name]
|
|
? e(t, o, a)
|
|
: r[Ra] !== !1 && s.push(o)
|
|
: s.push(o);
|
|
}),
|
|
n && s.length)
|
|
) {
|
|
let o = t.clone({ nodes: [] });
|
|
for (let u of s) o.append(u);
|
|
r.prepend(o);
|
|
}
|
|
};
|
|
}
|
|
function qa(i, e, t) {
|
|
let r = new qp({ selector: i, nodes: [] });
|
|
return r.append(e), t.after(r), r;
|
|
}
|
|
function Fp(i, e) {
|
|
let t = {};
|
|
for (let r of i) t[r] = !0;
|
|
if (e) for (let r of e) t[r.replace(/^@/, "")] = !0;
|
|
return t;
|
|
}
|
|
function AS(i) {
|
|
i = i.trim();
|
|
let e = i.match(/^\((.*)\)$/);
|
|
if (!e) return { type: "basic", selector: i };
|
|
let t = e[1].match(/^(with(?:out)?):(.+)$/);
|
|
if (t) {
|
|
let r = t[1] === "with",
|
|
n = Object.fromEntries(
|
|
t[2]
|
|
.trim()
|
|
.split(/\s+/)
|
|
.map((s) => [s, !0]),
|
|
);
|
|
if (r && n.all) return { type: "noop" };
|
|
let a = (s) => !!n[s];
|
|
return (
|
|
n.all ? (a = () => !0) : r && (a = (s) => (s === "all" ? !1 : !n[s])),
|
|
{ type: "withrules", escapes: a }
|
|
);
|
|
}
|
|
return { type: "unknown" };
|
|
}
|
|
function _S(i) {
|
|
let e = [],
|
|
t = i.parent;
|
|
for (; t && t instanceof SS; ) e.push(t), (t = t.parent);
|
|
return e;
|
|
}
|
|
function OS(i) {
|
|
let e = i[Np];
|
|
if (!e) i.after(i.nodes);
|
|
else {
|
|
let t = i.nodes,
|
|
r,
|
|
n = -1,
|
|
a,
|
|
s,
|
|
o,
|
|
u = _S(i);
|
|
if (
|
|
(u.forEach((c, f) => {
|
|
if (e(c.name)) (r = c), (n = f), (s = o);
|
|
else {
|
|
let d = o;
|
|
(o = c.clone({ nodes: [] })), d && o.append(d), (a = a || o);
|
|
}
|
|
}),
|
|
r ? (s ? (a.append(t), r.after(s)) : r.after(t)) : i.after(t),
|
|
i.next() && r)
|
|
) {
|
|
let c;
|
|
u.slice(0, n + 1).forEach((f, d, p) => {
|
|
let m = c;
|
|
(c = f.clone({ nodes: [] })), m && c.append(m);
|
|
let w = [],
|
|
y = (p[d - 1] || i).next();
|
|
for (; y; ) w.push(y), (y = y.next());
|
|
c.append(w);
|
|
}),
|
|
c && (s || t[t.length - 1]).after(c);
|
|
}
|
|
}
|
|
i.remove();
|
|
}
|
|
var Ra = Symbol("rootRuleMergeSel"),
|
|
Np = Symbol("rootRuleEscapes");
|
|
function ES(i) {
|
|
let { params: e } = i,
|
|
{ type: t, selector: r, escapes: n } = AS(e);
|
|
if (t === "unknown")
|
|
throw i.error(`Unknown @${i.name} parameter ${JSON.stringify(e)}`);
|
|
if (t === "basic" && r) {
|
|
let a = new qp({ selector: r, nodes: i.nodes });
|
|
i.removeAll(), i.append(a);
|
|
}
|
|
(i[Np] = n), (i[Ra] = n ? !n("all") : t === "noop");
|
|
}
|
|
var Ma = Symbol("hasRootRule");
|
|
Ba.exports = (i = {}) => {
|
|
let e = Fp(["media", "supports", "layer", "container"], i.bubble),
|
|
t = CS(e),
|
|
r = Fp(
|
|
[
|
|
"document",
|
|
"font-face",
|
|
"keyframes",
|
|
"-webkit-keyframes",
|
|
"-moz-keyframes",
|
|
],
|
|
i.unwrap,
|
|
),
|
|
n = (i.rootRuleName || "at-root").replace(/^@/, ""),
|
|
a = i.preserveEmpty;
|
|
return {
|
|
postcssPlugin: "postcss-nested",
|
|
Once(s) {
|
|
s.walkAtRules(n, (o) => {
|
|
ES(o), (s[Ma] = !0);
|
|
});
|
|
},
|
|
Rule(s) {
|
|
let o = !1,
|
|
u = s,
|
|
c = !1,
|
|
f = [];
|
|
s.each((d) => {
|
|
d.type === "rule"
|
|
? (f.length && ((u = qa(s.selector, f, u)), (f = [])),
|
|
(c = !0),
|
|
(o = !0),
|
|
(d.selectors = Bp(s, d)),
|
|
(u = on(d, u)))
|
|
: d.type === "atrule"
|
|
? (f.length && ((u = qa(s.selector, f, u)), (f = [])),
|
|
d.name === n
|
|
? ((o = !0), t(s, d, !0, d[Ra]), (u = on(d, u)))
|
|
: e[d.name]
|
|
? ((c = !0), (o = !0), t(s, d, !0), (u = on(d, u)))
|
|
: r[d.name]
|
|
? ((c = !0), (o = !0), t(s, d, !1), (u = on(d, u)))
|
|
: c && f.push(d))
|
|
: d.type === "decl" && c && f.push(d);
|
|
}),
|
|
f.length && (u = qa(s.selector, f, u)),
|
|
o &&
|
|
a !== !0 &&
|
|
((s.raws.semicolon = !0), s.nodes.length === 0 && s.remove());
|
|
},
|
|
RootExit(s) {
|
|
s[Ma] && (s.walkAtRules(n, OS), (s[Ma] = !1));
|
|
},
|
|
};
|
|
};
|
|
Ba.exports.postcss = !0;
|
|
});
|
|
var Vp = v((E3, zp) => {
|
|
l();
|
|
("use strict");
|
|
var $p = /-(\w|$)/g,
|
|
jp = (i, e) => e.toUpperCase(),
|
|
TS = (i) => (
|
|
(i = i.toLowerCase()),
|
|
i === "float"
|
|
? "cssFloat"
|
|
: i.startsWith("-ms-")
|
|
? i.substr(1).replace($p, jp)
|
|
: i.replace($p, jp)
|
|
);
|
|
zp.exports = TS;
|
|
});
|
|
var La = v((T3, Up) => {
|
|
l();
|
|
var PS = Vp(),
|
|
DS = {
|
|
boxFlex: !0,
|
|
boxFlexGroup: !0,
|
|
columnCount: !0,
|
|
flex: !0,
|
|
flexGrow: !0,
|
|
flexPositive: !0,
|
|
flexShrink: !0,
|
|
flexNegative: !0,
|
|
fontWeight: !0,
|
|
lineClamp: !0,
|
|
lineHeight: !0,
|
|
opacity: !0,
|
|
order: !0,
|
|
orphans: !0,
|
|
tabSize: !0,
|
|
widows: !0,
|
|
zIndex: !0,
|
|
zoom: !0,
|
|
fillOpacity: !0,
|
|
strokeDashoffset: !0,
|
|
strokeOpacity: !0,
|
|
strokeWidth: !0,
|
|
};
|
|
function Fa(i) {
|
|
return typeof i.nodes == "undefined" ? !0 : Na(i);
|
|
}
|
|
function Na(i) {
|
|
let e,
|
|
t = {};
|
|
return (
|
|
i.each((r) => {
|
|
if (r.type === "atrule")
|
|
(e = "@" + r.name),
|
|
r.params && (e += " " + r.params),
|
|
typeof t[e] == "undefined"
|
|
? (t[e] = Fa(r))
|
|
: Array.isArray(t[e])
|
|
? t[e].push(Fa(r))
|
|
: (t[e] = [t[e], Fa(r)]);
|
|
else if (r.type === "rule") {
|
|
let n = Na(r);
|
|
if (t[r.selector]) for (let a in n) t[r.selector][a] = n[a];
|
|
else t[r.selector] = n;
|
|
} else if (r.type === "decl") {
|
|
(r.prop[0] === "-" && r.prop[1] === "-") ||
|
|
(r.parent && r.parent.selector === ":export")
|
|
? (e = r.prop)
|
|
: (e = PS(r.prop));
|
|
let n = r.value;
|
|
!isNaN(r.value) && DS[e] && (n = parseFloat(r.value)),
|
|
r.important && (n += " !important"),
|
|
typeof t[e] == "undefined"
|
|
? (t[e] = n)
|
|
: Array.isArray(t[e])
|
|
? t[e].push(n)
|
|
: (t[e] = [t[e], n]);
|
|
}
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
Up.exports = Na;
|
|
});
|
|
var ln = v((P3, Yp) => {
|
|
l();
|
|
var Yr = ge(),
|
|
Wp = /\s*!important\s*$/i,
|
|
IS = {
|
|
"box-flex": !0,
|
|
"box-flex-group": !0,
|
|
"column-count": !0,
|
|
flex: !0,
|
|
"flex-grow": !0,
|
|
"flex-positive": !0,
|
|
"flex-shrink": !0,
|
|
"flex-negative": !0,
|
|
"font-weight": !0,
|
|
"line-clamp": !0,
|
|
"line-height": !0,
|
|
opacity: !0,
|
|
order: !0,
|
|
orphans: !0,
|
|
"tab-size": !0,
|
|
widows: !0,
|
|
"z-index": !0,
|
|
zoom: !0,
|
|
"fill-opacity": !0,
|
|
"stroke-dashoffset": !0,
|
|
"stroke-opacity": !0,
|
|
"stroke-width": !0,
|
|
};
|
|
function qS(i) {
|
|
return i
|
|
.replace(/([A-Z])/g, "-$1")
|
|
.replace(/^ms-/, "-ms-")
|
|
.toLowerCase();
|
|
}
|
|
function Gp(i, e, t) {
|
|
t === !1 ||
|
|
t === null ||
|
|
(e.startsWith("--") || (e = qS(e)),
|
|
typeof t == "number" &&
|
|
(t === 0 || IS[e] ? (t = t.toString()) : (t += "px")),
|
|
e === "css-float" && (e = "float"),
|
|
Wp.test(t)
|
|
? ((t = t.replace(Wp, "")),
|
|
i.push(Yr.decl({ prop: e, value: t, important: !0 })))
|
|
: i.push(Yr.decl({ prop: e, value: t })));
|
|
}
|
|
function Hp(i, e, t) {
|
|
let r = Yr.atRule({ name: e[1], params: e[3] || "" });
|
|
typeof t == "object" && ((r.nodes = []), $a(t, r)), i.push(r);
|
|
}
|
|
function $a(i, e) {
|
|
let t, r, n;
|
|
for (t in i)
|
|
if (((r = i[t]), !(r === null || typeof r == "undefined")))
|
|
if (t[0] === "@") {
|
|
let a = t.match(/@(\S+)(\s+([\W\w]*)\s*)?/);
|
|
if (Array.isArray(r)) for (let s of r) Hp(e, a, s);
|
|
else Hp(e, a, r);
|
|
} else if (Array.isArray(r)) for (let a of r) Gp(e, t, a);
|
|
else
|
|
typeof r == "object"
|
|
? ((n = Yr.rule({ selector: t })), $a(r, n), e.push(n))
|
|
: Gp(e, t, r);
|
|
}
|
|
Yp.exports = function (i) {
|
|
let e = Yr.root();
|
|
return $a(i, e), e;
|
|
};
|
|
});
|
|
var ja = v((D3, Qp) => {
|
|
l();
|
|
var RS = La();
|
|
Qp.exports = function (e) {
|
|
return (
|
|
console &&
|
|
console.warn &&
|
|
e.warnings().forEach((t) => {
|
|
let r = t.plugin || "PostCSS";
|
|
console.warn(r + ": " + t.text);
|
|
}),
|
|
RS(e.root)
|
|
);
|
|
};
|
|
});
|
|
var Xp = v((I3, Jp) => {
|
|
l();
|
|
var MS = ge(),
|
|
BS = ja(),
|
|
FS = ln();
|
|
Jp.exports = function (e) {
|
|
let t = MS(e);
|
|
return async (r) => {
|
|
let n = await t.process(r, { parser: FS, from: void 0 });
|
|
return BS(n);
|
|
};
|
|
};
|
|
});
|
|
var Zp = v((q3, Kp) => {
|
|
l();
|
|
var NS = ge(),
|
|
LS = ja(),
|
|
$S = ln();
|
|
Kp.exports = function (i) {
|
|
let e = NS(i);
|
|
return (t) => {
|
|
let r = e.process(t, { parser: $S, from: void 0 });
|
|
return LS(r);
|
|
};
|
|
};
|
|
});
|
|
var td = v((R3, ed) => {
|
|
l();
|
|
var jS = La(),
|
|
zS = ln(),
|
|
VS = Xp(),
|
|
US = Zp();
|
|
ed.exports = { objectify: jS, parse: zS, async: VS, sync: US };
|
|
});
|
|
var Rt,
|
|
rd,
|
|
M3,
|
|
B3,
|
|
F3,
|
|
N3,
|
|
id = C(() => {
|
|
l();
|
|
(Rt = K(td())),
|
|
(rd = Rt.default),
|
|
(M3 = Rt.default.objectify),
|
|
(B3 = Rt.default.parse),
|
|
(F3 = Rt.default.async),
|
|
(N3 = Rt.default.sync);
|
|
});
|
|
function Mt(i) {
|
|
return Array.isArray(i)
|
|
? i.flatMap(
|
|
(e) =>
|
|
V([(0, nd.default)({ bubble: ["screen"] })]).process(e, {
|
|
parser: rd,
|
|
}).root.nodes,
|
|
)
|
|
: Mt([i]);
|
|
}
|
|
var nd,
|
|
za = C(() => {
|
|
l();
|
|
nt();
|
|
nd = K(Lp());
|
|
id();
|
|
});
|
|
function Bt(i, e, t = !1) {
|
|
if (i === "") return e;
|
|
let r = typeof e == "string" ? (0, sd.default)().astSync(e) : e;
|
|
return (
|
|
r.walkClasses((n) => {
|
|
let a = n.value,
|
|
s = t && a.startsWith("-");
|
|
n.value = s ? `-${i}${a.slice(1)}` : `${i}${a}`;
|
|
}),
|
|
typeof e == "string" ? r.toString() : r
|
|
);
|
|
}
|
|
var sd,
|
|
un = C(() => {
|
|
l();
|
|
sd = K(Re());
|
|
});
|
|
function de(i) {
|
|
let e = ad.default.className();
|
|
return (e.value = i), mt(e?.raws?.value ?? e.value);
|
|
}
|
|
var ad,
|
|
Ft = C(() => {
|
|
l();
|
|
ad = K(Re());
|
|
mi();
|
|
});
|
|
function Va(i) {
|
|
return mt(`.${de(i)}`);
|
|
}
|
|
function fn(i, e) {
|
|
return Va(Qr(i, e));
|
|
}
|
|
function Qr(i, e) {
|
|
return e === "DEFAULT"
|
|
? i
|
|
: e === "-" || e === "-DEFAULT"
|
|
? `-${i}`
|
|
: e.startsWith("-")
|
|
? `-${i}${e}`
|
|
: e.startsWith("/")
|
|
? `${i}${e}`
|
|
: `${i}-${e}`;
|
|
}
|
|
var Ua = C(() => {
|
|
l();
|
|
Ft();
|
|
mi();
|
|
});
|
|
function P(i, e = [[i, [i]]], { filterDefault: t = !1, ...r } = {}) {
|
|
let n = Ge(i);
|
|
return function ({ matchUtilities: a, theme: s }) {
|
|
for (let o of e) {
|
|
let u = Array.isArray(o[0]) ? o : [o];
|
|
a(
|
|
u.reduce(
|
|
(c, [f, d]) =>
|
|
Object.assign(c, {
|
|
[f]: (p) =>
|
|
d.reduce(
|
|
(m, w) =>
|
|
Array.isArray(w)
|
|
? Object.assign(m, { [w[0]]: w[1] })
|
|
: Object.assign(m, { [w]: n(p) }),
|
|
{},
|
|
),
|
|
}),
|
|
{},
|
|
),
|
|
{
|
|
...r,
|
|
values: t
|
|
? Object.fromEntries(
|
|
Object.entries(s(i) ?? {}).filter(([c]) => c !== "DEFAULT"),
|
|
)
|
|
: s(i),
|
|
},
|
|
);
|
|
}
|
|
};
|
|
}
|
|
var od = C(() => {
|
|
l();
|
|
Hr();
|
|
});
|
|
function st(i) {
|
|
return (
|
|
(i = Array.isArray(i) ? i : [i]),
|
|
i
|
|
.map((e) => {
|
|
let t = e.values.map((r) =>
|
|
r.raw !== void 0
|
|
? r.raw
|
|
: [
|
|
r.min && `(min-width: ${r.min})`,
|
|
r.max && `(max-width: ${r.max})`,
|
|
]
|
|
.filter(Boolean)
|
|
.join(" and "),
|
|
);
|
|
return e.not ? `not all and ${t}` : t;
|
|
})
|
|
.join(", ")
|
|
);
|
|
}
|
|
var cn = C(() => {
|
|
l();
|
|
});
|
|
function Wa(i) {
|
|
return i.split(XS).map((t) => {
|
|
let r = t.trim(),
|
|
n = { value: r },
|
|
a = r.split(KS),
|
|
s = new Set();
|
|
for (let o of a)
|
|
!s.has("DIRECTIONS") && WS.has(o)
|
|
? ((n.direction = o), s.add("DIRECTIONS"))
|
|
: !s.has("PLAY_STATES") && GS.has(o)
|
|
? ((n.playState = o), s.add("PLAY_STATES"))
|
|
: !s.has("FILL_MODES") && HS.has(o)
|
|
? ((n.fillMode = o), s.add("FILL_MODES"))
|
|
: !s.has("ITERATION_COUNTS") && (YS.has(o) || ZS.test(o))
|
|
? ((n.iterationCount = o), s.add("ITERATION_COUNTS"))
|
|
: (!s.has("TIMING_FUNCTION") && QS.has(o)) ||
|
|
(!s.has("TIMING_FUNCTION") &&
|
|
JS.some((u) => o.startsWith(`${u}(`)))
|
|
? ((n.timingFunction = o), s.add("TIMING_FUNCTION"))
|
|
: !s.has("DURATION") && ld.test(o)
|
|
? ((n.duration = o), s.add("DURATION"))
|
|
: !s.has("DELAY") && ld.test(o)
|
|
? ((n.delay = o), s.add("DELAY"))
|
|
: s.has("NAME")
|
|
? (n.unknown || (n.unknown = []), n.unknown.push(o))
|
|
: ((n.name = o), s.add("NAME"));
|
|
return n;
|
|
});
|
|
}
|
|
var WS,
|
|
GS,
|
|
HS,
|
|
YS,
|
|
QS,
|
|
JS,
|
|
XS,
|
|
KS,
|
|
ld,
|
|
ZS,
|
|
ud = C(() => {
|
|
l();
|
|
(WS = new Set(["normal", "reverse", "alternate", "alternate-reverse"])),
|
|
(GS = new Set(["running", "paused"])),
|
|
(HS = new Set(["none", "forwards", "backwards", "both"])),
|
|
(YS = new Set(["infinite"])),
|
|
(QS = new Set([
|
|
"linear",
|
|
"ease",
|
|
"ease-in",
|
|
"ease-out",
|
|
"ease-in-out",
|
|
"step-start",
|
|
"step-end",
|
|
])),
|
|
(JS = ["cubic-bezier", "steps"]),
|
|
(XS = /\,(?![^(]*\))/g),
|
|
(KS = /\ +(?![^(]*\))/g),
|
|
(ld = /^(-?[\d.]+m?s)$/),
|
|
(ZS = /^(\d+)$/);
|
|
});
|
|
var fd,
|
|
ie,
|
|
cd = C(() => {
|
|
l();
|
|
(fd = (i) =>
|
|
Object.assign(
|
|
{},
|
|
...Object.entries(i ?? {}).flatMap(([e, t]) =>
|
|
typeof t == "object"
|
|
? Object.entries(fd(t)).map(([r, n]) => ({
|
|
[e + (r === "DEFAULT" ? "" : `-${r}`)]: n,
|
|
}))
|
|
: [{ [`${e}`]: t }],
|
|
),
|
|
)),
|
|
(ie = fd);
|
|
});
|
|
var eC,
|
|
Ha,
|
|
tC,
|
|
rC,
|
|
iC,
|
|
nC,
|
|
sC,
|
|
aC,
|
|
oC,
|
|
lC,
|
|
uC,
|
|
fC,
|
|
cC,
|
|
pC,
|
|
dC,
|
|
hC,
|
|
mC,
|
|
gC,
|
|
Ya,
|
|
Ga = C(() => {
|
|
(eC = "tailwindcss"),
|
|
(Ha = "3.4.1"),
|
|
(tC =
|
|
"A utility-first CSS framework for rapidly building custom user interfaces."),
|
|
(rC = "MIT"),
|
|
(iC = "lib/index.js"),
|
|
(nC = "types/index.d.ts"),
|
|
(sC = "https://github.com/tailwindlabs/tailwindcss.git"),
|
|
(aC = "https://github.com/tailwindlabs/tailwindcss/issues"),
|
|
(oC = "https://tailwindcss.com"),
|
|
(lC = { tailwind: "lib/cli.js", tailwindcss: "lib/cli.js" }),
|
|
(uC = { engine: "stable" }),
|
|
(fC = {
|
|
prebuild: "npm run generate && rimraf lib",
|
|
build: `swc src --out-dir lib --copy-files --config jsc.transform.optimizer.globals.vars.__OXIDE__='"false"'`,
|
|
postbuild:
|
|
"esbuild lib/cli-peer-dependencies.js --bundle --platform=node --outfile=peers/index.js --define:process.env.CSS_TRANSFORMER_WASM=false",
|
|
"rebuild-fixtures":
|
|
"npm run build && node -r @swc/register scripts/rebuildFixtures.js",
|
|
style: "eslint .",
|
|
pretest: "npm run generate",
|
|
test: "jest",
|
|
"test:integrations": "npm run test --prefix ./integrations",
|
|
"install:integrations": "node scripts/install-integrations.js",
|
|
"generate:plugin-list":
|
|
"node -r @swc/register scripts/create-plugin-list.js",
|
|
"generate:types": "node -r @swc/register scripts/generate-types.js",
|
|
generate: "npm run generate:plugin-list && npm run generate:types",
|
|
"release-channel": "node ./scripts/release-channel.js",
|
|
"release-notes": "node ./scripts/release-notes.js",
|
|
prepublishOnly: "npm install --force && npm run build",
|
|
}),
|
|
(cC = [
|
|
"src/*",
|
|
"cli/*",
|
|
"lib/*",
|
|
"peers/*",
|
|
"scripts/*.js",
|
|
"stubs/*",
|
|
"nesting/*",
|
|
"types/**/*",
|
|
"*.d.ts",
|
|
"*.css",
|
|
"*.js",
|
|
]),
|
|
(pC = {
|
|
"@swc/cli": "^0.1.62",
|
|
"@swc/core": "^1.3.55",
|
|
"@swc/jest": "^0.2.26",
|
|
"@swc/register": "^0.1.10",
|
|
autoprefixer: "^10.4.14",
|
|
browserslist: "^4.21.5",
|
|
concurrently: "^8.0.1",
|
|
cssnano: "^6.0.0",
|
|
esbuild: "^0.17.18",
|
|
eslint: "^8.39.0",
|
|
"eslint-config-prettier": "^8.8.0",
|
|
"eslint-plugin-prettier": "^4.2.1",
|
|
jest: "^29.6.0",
|
|
"jest-diff": "^29.6.0",
|
|
lightningcss: "1.18.0",
|
|
prettier: "^2.8.8",
|
|
rimraf: "^5.0.0",
|
|
"source-map-js": "^1.0.2",
|
|
turbo: "^1.9.3",
|
|
}),
|
|
(dC = {
|
|
"@alloc/quick-lru": "^5.2.0",
|
|
arg: "^5.0.2",
|
|
chokidar: "^3.5.3",
|
|
didyoumean: "^1.2.2",
|
|
dlv: "^1.1.3",
|
|
"fast-glob": "^3.3.0",
|
|
"glob-parent": "^6.0.2",
|
|
"is-glob": "^4.0.3",
|
|
jiti: "^1.19.1",
|
|
lilconfig: "^2.1.0",
|
|
micromatch: "^4.0.5",
|
|
"normalize-path": "^3.0.0",
|
|
"object-hash": "^3.0.0",
|
|
picocolors: "^1.0.0",
|
|
postcss: "^8.4.23",
|
|
"postcss-import": "^15.1.0",
|
|
"postcss-js": "^4.0.1",
|
|
"postcss-load-config": "^4.0.1",
|
|
"postcss-nested": "^6.0.1",
|
|
"postcss-selector-parser": "^6.0.11",
|
|
resolve: "^1.22.2",
|
|
sucrase: "^3.32.0",
|
|
}),
|
|
(hC = ["> 1%", "not edge <= 18", "not ie 11", "not op_mini all"]),
|
|
(mC = {
|
|
testTimeout: 3e4,
|
|
setupFilesAfterEnv: ["<rootDir>/jest/customMatchers.js"],
|
|
testPathIgnorePatterns: [
|
|
"/node_modules/",
|
|
"/integrations/",
|
|
"/standalone-cli/",
|
|
"\\.test\\.skip\\.js$",
|
|
],
|
|
transformIgnorePatterns: ["node_modules/(?!lightningcss)"],
|
|
transform: { "\\.js$": "@swc/jest", "\\.ts$": "@swc/jest" },
|
|
}),
|
|
(gC = { node: ">=14.0.0" }),
|
|
(Ya = {
|
|
name: eC,
|
|
version: Ha,
|
|
description: tC,
|
|
license: rC,
|
|
main: iC,
|
|
types: nC,
|
|
repository: sC,
|
|
bugs: aC,
|
|
homepage: oC,
|
|
bin: lC,
|
|
tailwindcss: uC,
|
|
scripts: fC,
|
|
files: cC,
|
|
devDependencies: pC,
|
|
dependencies: dC,
|
|
browserslist: hC,
|
|
jest: mC,
|
|
engines: gC,
|
|
});
|
|
});
|
|
function at(i, e = !0) {
|
|
return Array.isArray(i)
|
|
? i.map((t) => {
|
|
if (e && Array.isArray(t))
|
|
throw new Error("The tuple syntax is not supported for `screens`.");
|
|
if (typeof t == "string")
|
|
return {
|
|
name: t.toString(),
|
|
not: !1,
|
|
values: [{ min: t, max: void 0 }],
|
|
};
|
|
let [r, n] = t;
|
|
return (
|
|
(r = r.toString()),
|
|
typeof n == "string"
|
|
? { name: r, not: !1, values: [{ min: n, max: void 0 }] }
|
|
: Array.isArray(n)
|
|
? { name: r, not: !1, values: n.map((a) => dd(a)) }
|
|
: { name: r, not: !1, values: [dd(n)] }
|
|
);
|
|
})
|
|
: at(Object.entries(i ?? {}), !1);
|
|
}
|
|
function pn(i) {
|
|
return i.values.length !== 1
|
|
? { result: !1, reason: "multiple-values" }
|
|
: i.values[0].raw !== void 0
|
|
? { result: !1, reason: "raw-values" }
|
|
: i.values[0].min !== void 0 && i.values[0].max !== void 0
|
|
? { result: !1, reason: "min-and-max" }
|
|
: { result: !0, reason: null };
|
|
}
|
|
function pd(i, e, t) {
|
|
let r = dn(e, i),
|
|
n = dn(t, i),
|
|
a = pn(r),
|
|
s = pn(n);
|
|
if (a.reason === "multiple-values" || s.reason === "multiple-values")
|
|
throw new Error(
|
|
"Attempted to sort a screen with multiple values. This should never happen. Please open a bug report.",
|
|
);
|
|
if (a.reason === "raw-values" || s.reason === "raw-values")
|
|
throw new Error(
|
|
"Attempted to sort a screen with raw values. This should never happen. Please open a bug report.",
|
|
);
|
|
if (a.reason === "min-and-max" || s.reason === "min-and-max")
|
|
throw new Error(
|
|
"Attempted to sort a screen with both min and max values. This should never happen. Please open a bug report.",
|
|
);
|
|
let { min: o, max: u } = r.values[0],
|
|
{ min: c, max: f } = n.values[0];
|
|
e.not && ([o, u] = [u, o]),
|
|
t.not && ([c, f] = [f, c]),
|
|
(o = o === void 0 ? o : parseFloat(o)),
|
|
(u = u === void 0 ? u : parseFloat(u)),
|
|
(c = c === void 0 ? c : parseFloat(c)),
|
|
(f = f === void 0 ? f : parseFloat(f));
|
|
let [d, p] = i === "min" ? [o, c] : [f, u];
|
|
return d - p;
|
|
}
|
|
function dn(i, e) {
|
|
return typeof i == "object"
|
|
? i
|
|
: { name: "arbitrary-screen", values: [{ [e]: i }] };
|
|
}
|
|
function dd({ "min-width": i, min: e = i, max: t, raw: r } = {}) {
|
|
return { min: e, max: t, raw: r };
|
|
}
|
|
var hn = C(() => {
|
|
l();
|
|
});
|
|
function mn(i, e) {
|
|
i.walkDecls((t) => {
|
|
if (e.includes(t.prop)) {
|
|
t.remove();
|
|
return;
|
|
}
|
|
for (let r of e)
|
|
t.value.includes(`/ var(${r})`) &&
|
|
(t.value = t.value.replace(`/ var(${r})`, ""));
|
|
});
|
|
}
|
|
var hd = C(() => {
|
|
l();
|
|
});
|
|
var Y,
|
|
Te,
|
|
Me,
|
|
Be,
|
|
md,
|
|
gd = C(() => {
|
|
l();
|
|
je();
|
|
gt();
|
|
nt();
|
|
od();
|
|
cn();
|
|
Ft();
|
|
ud();
|
|
cd();
|
|
or();
|
|
cs();
|
|
kt();
|
|
Hr();
|
|
Ga();
|
|
Oe();
|
|
hn();
|
|
ns();
|
|
hd();
|
|
ze();
|
|
fr();
|
|
Xr();
|
|
(Y = {
|
|
childVariant: ({ addVariant: i }) => {
|
|
i("*", "& > *");
|
|
},
|
|
pseudoElementVariants: ({ addVariant: i }) => {
|
|
i("first-letter", "&::first-letter"),
|
|
i("first-line", "&::first-line"),
|
|
i("marker", [
|
|
({ container: e }) => (
|
|
mn(e, ["--tw-text-opacity"]), "& *::marker"
|
|
),
|
|
({ container: e }) => (mn(e, ["--tw-text-opacity"]), "&::marker"),
|
|
]),
|
|
i("selection", ["& *::selection", "&::selection"]),
|
|
i("file", "&::file-selector-button"),
|
|
i("placeholder", "&::placeholder"),
|
|
i("backdrop", "&::backdrop"),
|
|
i(
|
|
"before",
|
|
({ container: e }) => (
|
|
e.walkRules((t) => {
|
|
let r = !1;
|
|
t.walkDecls("content", () => {
|
|
r = !0;
|
|
}),
|
|
r ||
|
|
t.prepend(
|
|
V.decl({ prop: "content", value: "var(--tw-content)" }),
|
|
);
|
|
}),
|
|
"&::before"
|
|
),
|
|
),
|
|
i(
|
|
"after",
|
|
({ container: e }) => (
|
|
e.walkRules((t) => {
|
|
let r = !1;
|
|
t.walkDecls("content", () => {
|
|
r = !0;
|
|
}),
|
|
r ||
|
|
t.prepend(
|
|
V.decl({ prop: "content", value: "var(--tw-content)" }),
|
|
);
|
|
}),
|
|
"&::after"
|
|
),
|
|
);
|
|
},
|
|
pseudoClassVariants: ({
|
|
addVariant: i,
|
|
matchVariant: e,
|
|
config: t,
|
|
prefix: r,
|
|
}) => {
|
|
let n = [
|
|
["first", "&:first-child"],
|
|
["last", "&:last-child"],
|
|
["only", "&:only-child"],
|
|
["odd", "&:nth-child(odd)"],
|
|
["even", "&:nth-child(even)"],
|
|
"first-of-type",
|
|
"last-of-type",
|
|
"only-of-type",
|
|
[
|
|
"visited",
|
|
({ container: s }) => (
|
|
mn(s, [
|
|
"--tw-text-opacity",
|
|
"--tw-border-opacity",
|
|
"--tw-bg-opacity",
|
|
]),
|
|
"&:visited"
|
|
),
|
|
],
|
|
"target",
|
|
["open", "&[open]"],
|
|
"default",
|
|
"checked",
|
|
"indeterminate",
|
|
"placeholder-shown",
|
|
"autofill",
|
|
"optional",
|
|
"required",
|
|
"valid",
|
|
"invalid",
|
|
"in-range",
|
|
"out-of-range",
|
|
"read-only",
|
|
"empty",
|
|
"focus-within",
|
|
[
|
|
"hover",
|
|
Z(t(), "hoverOnlyWhenSupported")
|
|
? "@media (hover: hover) and (pointer: fine) { &:hover }"
|
|
: "&:hover",
|
|
],
|
|
"focus",
|
|
"focus-visible",
|
|
"active",
|
|
"enabled",
|
|
"disabled",
|
|
].map((s) => (Array.isArray(s) ? s : [s, `&:${s}`]));
|
|
for (let [s, o] of n)
|
|
i(s, (u) => (typeof o == "function" ? o(u) : o));
|
|
let a = {
|
|
group: (s, { modifier: o }) =>
|
|
o
|
|
? [`:merge(${r(".group")}\\/${de(o)})`, " &"]
|
|
: [`:merge(${r(".group")})`, " &"],
|
|
peer: (s, { modifier: o }) =>
|
|
o
|
|
? [`:merge(${r(".peer")}\\/${de(o)})`, " ~ &"]
|
|
: [`:merge(${r(".peer")})`, " ~ &"],
|
|
};
|
|
for (let [s, o] of Object.entries(a))
|
|
e(
|
|
s,
|
|
(u = "", c) => {
|
|
let f = N(typeof u == "function" ? u(c) : u);
|
|
f.includes("&") || (f = "&" + f);
|
|
let [d, p] = o("", c),
|
|
m = null,
|
|
w = null,
|
|
x = 0;
|
|
for (let y = 0; y < f.length; ++y) {
|
|
let b = f[y];
|
|
b === "&"
|
|
? (m = y)
|
|
: b === "'" || b === '"'
|
|
? (x += 1)
|
|
: m !== null && b === " " && !x && (w = y);
|
|
}
|
|
return (
|
|
m !== null && w === null && (w = f.length),
|
|
f.slice(0, m) + d + f.slice(m + 1, w) + p + f.slice(w)
|
|
);
|
|
},
|
|
{ values: Object.fromEntries(n), [Jr]: { respectPrefix: !1 } },
|
|
);
|
|
},
|
|
directionVariants: ({ addVariant: i }) => {
|
|
i("ltr", '&:where([dir="ltr"], [dir="ltr"] *)'),
|
|
i("rtl", '&:where([dir="rtl"], [dir="rtl"] *)');
|
|
},
|
|
reducedMotionVariants: ({ addVariant: i }) => {
|
|
i("motion-safe", "@media (prefers-reduced-motion: no-preference)"),
|
|
i("motion-reduce", "@media (prefers-reduced-motion: reduce)");
|
|
},
|
|
darkVariants: ({ config: i, addVariant: e }) => {
|
|
let [t, r = ".dark"] = [].concat(i("darkMode", "media"));
|
|
if (
|
|
(t === !1 &&
|
|
((t = "media"),
|
|
F.warn("darkmode-false", [
|
|
"The `darkMode` option in your Tailwind CSS configuration is set to `false`, which now behaves the same as `media`.",
|
|
"Change `darkMode` to `media` or remove it entirely.",
|
|
"https://tailwindcss.com/docs/upgrade-guide#remove-dark-mode-configuration",
|
|
])),
|
|
t === "variant")
|
|
) {
|
|
let n;
|
|
if (
|
|
(Array.isArray(r) || typeof r == "function"
|
|
? (n = r)
|
|
: typeof r == "string" && (n = [r]),
|
|
Array.isArray(n))
|
|
)
|
|
for (let a of n)
|
|
a === ".dark"
|
|
? ((t = !1),
|
|
F.warn("darkmode-variant-without-selector", [
|
|
"When using `variant` for `darkMode`, you must provide a selector.",
|
|
'Example: `darkMode: ["variant", ".your-selector &"]`',
|
|
]))
|
|
: a.includes("&") ||
|
|
((t = !1),
|
|
F.warn("darkmode-variant-without-ampersand", [
|
|
"When using `variant` for `darkMode`, your selector must contain `&`.",
|
|
'Example `darkMode: ["variant", ".your-selector &"]`',
|
|
]));
|
|
r = n;
|
|
}
|
|
t === "selector"
|
|
? e("dark", `&:where(${r}, ${r} *)`)
|
|
: t === "media"
|
|
? e("dark", "@media (prefers-color-scheme: dark)")
|
|
: t === "variant"
|
|
? e("dark", r)
|
|
: t === "class" && e("dark", `:is(${r} &)`);
|
|
},
|
|
printVariant: ({ addVariant: i }) => {
|
|
i("print", "@media print");
|
|
},
|
|
screenVariants: ({ theme: i, addVariant: e, matchVariant: t }) => {
|
|
let r = i("screens") ?? {},
|
|
n = Object.values(r).every((b) => typeof b == "string"),
|
|
a = at(i("screens")),
|
|
s = new Set([]);
|
|
function o(b) {
|
|
return b.match(/(\D+)$/)?.[1] ?? "(none)";
|
|
}
|
|
function u(b) {
|
|
b !== void 0 && s.add(o(b));
|
|
}
|
|
function c(b) {
|
|
return u(b), s.size === 1;
|
|
}
|
|
for (let b of a) for (let k of b.values) u(k.min), u(k.max);
|
|
let f = s.size <= 1;
|
|
function d(b) {
|
|
return Object.fromEntries(
|
|
a
|
|
.filter((k) => pn(k).result)
|
|
.map((k) => {
|
|
let { min: S, max: _ } = k.values[0];
|
|
if (b === "min" && S !== void 0) return k;
|
|
if (b === "min" && _ !== void 0) return { ...k, not: !k.not };
|
|
if (b === "max" && _ !== void 0) return k;
|
|
if (b === "max" && S !== void 0) return { ...k, not: !k.not };
|
|
})
|
|
.map((k) => [k.name, k]),
|
|
);
|
|
}
|
|
function p(b) {
|
|
return (k, S) => pd(b, k.value, S.value);
|
|
}
|
|
let m = p("max"),
|
|
w = p("min");
|
|
function x(b) {
|
|
return (k) => {
|
|
if (n)
|
|
if (f) {
|
|
if (typeof k == "string" && !c(k))
|
|
return (
|
|
F.warn("minmax-have-mixed-units", [
|
|
"The `min-*` and `max-*` variants are not supported with a `screens` configuration containing mixed units.",
|
|
]),
|
|
[]
|
|
);
|
|
} else
|
|
return (
|
|
F.warn("mixed-screen-units", [
|
|
"The `min-*` and `max-*` variants are not supported with a `screens` configuration containing mixed units.",
|
|
]),
|
|
[]
|
|
);
|
|
else
|
|
return (
|
|
F.warn("complex-screen-config", [
|
|
"The `min-*` and `max-*` variants are not supported with a `screens` configuration containing objects.",
|
|
]),
|
|
[]
|
|
);
|
|
return [`@media ${st(dn(k, b))}`];
|
|
};
|
|
}
|
|
t("max", x("max"), { sort: m, values: n ? d("max") : {} });
|
|
let y = "min-screens";
|
|
for (let b of a)
|
|
e(b.name, `@media ${st(b)}`, {
|
|
id: y,
|
|
sort: n && f ? w : void 0,
|
|
value: b,
|
|
});
|
|
t("min", x("min"), { id: y, sort: w });
|
|
},
|
|
supportsVariants: ({ matchVariant: i, theme: e }) => {
|
|
i(
|
|
"supports",
|
|
(t = "") => {
|
|
let r = N(t),
|
|
n = /^\w*\s*\(/.test(r);
|
|
return (
|
|
(r = n ? r.replace(/\b(and|or|not)\b/g, " $1 ") : r),
|
|
n
|
|
? `@supports ${r}`
|
|
: (r.includes(":") || (r = `${r}: var(--tw)`),
|
|
(r.startsWith("(") && r.endsWith(")")) || (r = `(${r})`),
|
|
`@supports ${r}`)
|
|
);
|
|
},
|
|
{ values: e("supports") ?? {} },
|
|
);
|
|
},
|
|
hasVariants: ({ matchVariant: i }) => {
|
|
i("has", (e) => `&:has(${N(e)})`, { values: {} }),
|
|
i(
|
|
"group-has",
|
|
(e, { modifier: t }) =>
|
|
t
|
|
? `:merge(.group\\/${t}):has(${N(e)}) &`
|
|
: `:merge(.group):has(${N(e)}) &`,
|
|
{ values: {} },
|
|
),
|
|
i(
|
|
"peer-has",
|
|
(e, { modifier: t }) =>
|
|
t
|
|
? `:merge(.peer\\/${t}):has(${N(e)}) ~ &`
|
|
: `:merge(.peer):has(${N(e)}) ~ &`,
|
|
{ values: {} },
|
|
);
|
|
},
|
|
ariaVariants: ({ matchVariant: i, theme: e }) => {
|
|
i("aria", (t) => `&[aria-${N(t)}]`, { values: e("aria") ?? {} }),
|
|
i(
|
|
"group-aria",
|
|
(t, { modifier: r }) =>
|
|
r
|
|
? `:merge(.group\\/${r})[aria-${N(t)}] &`
|
|
: `:merge(.group)[aria-${N(t)}] &`,
|
|
{ values: e("aria") ?? {} },
|
|
),
|
|
i(
|
|
"peer-aria",
|
|
(t, { modifier: r }) =>
|
|
r
|
|
? `:merge(.peer\\/${r})[aria-${N(t)}] ~ &`
|
|
: `:merge(.peer)[aria-${N(t)}] ~ &`,
|
|
{ values: e("aria") ?? {} },
|
|
);
|
|
},
|
|
dataVariants: ({ matchVariant: i, theme: e }) => {
|
|
i("data", (t) => `&[data-${N(t)}]`, { values: e("data") ?? {} }),
|
|
i(
|
|
"group-data",
|
|
(t, { modifier: r }) =>
|
|
r
|
|
? `:merge(.group\\/${r})[data-${N(t)}] &`
|
|
: `:merge(.group)[data-${N(t)}] &`,
|
|
{ values: e("data") ?? {} },
|
|
),
|
|
i(
|
|
"peer-data",
|
|
(t, { modifier: r }) =>
|
|
r
|
|
? `:merge(.peer\\/${r})[data-${N(t)}] ~ &`
|
|
: `:merge(.peer)[data-${N(t)}] ~ &`,
|
|
{ values: e("data") ?? {} },
|
|
);
|
|
},
|
|
orientationVariants: ({ addVariant: i }) => {
|
|
i("portrait", "@media (orientation: portrait)"),
|
|
i("landscape", "@media (orientation: landscape)");
|
|
},
|
|
prefersContrastVariants: ({ addVariant: i }) => {
|
|
i("contrast-more", "@media (prefers-contrast: more)"),
|
|
i("contrast-less", "@media (prefers-contrast: less)");
|
|
},
|
|
forcedColorsVariants: ({ addVariant: i }) => {
|
|
i("forced-colors", "@media (forced-colors: active)");
|
|
},
|
|
}),
|
|
(Te = [
|
|
"translate(var(--tw-translate-x), var(--tw-translate-y))",
|
|
"rotate(var(--tw-rotate))",
|
|
"skewX(var(--tw-skew-x))",
|
|
"skewY(var(--tw-skew-y))",
|
|
"scaleX(var(--tw-scale-x))",
|
|
"scaleY(var(--tw-scale-y))",
|
|
].join(" ")),
|
|
(Me = [
|
|
"var(--tw-blur)",
|
|
"var(--tw-brightness)",
|
|
"var(--tw-contrast)",
|
|
"var(--tw-grayscale)",
|
|
"var(--tw-hue-rotate)",
|
|
"var(--tw-invert)",
|
|
"var(--tw-saturate)",
|
|
"var(--tw-sepia)",
|
|
"var(--tw-drop-shadow)",
|
|
].join(" ")),
|
|
(Be = [
|
|
"var(--tw-backdrop-blur)",
|
|
"var(--tw-backdrop-brightness)",
|
|
"var(--tw-backdrop-contrast)",
|
|
"var(--tw-backdrop-grayscale)",
|
|
"var(--tw-backdrop-hue-rotate)",
|
|
"var(--tw-backdrop-invert)",
|
|
"var(--tw-backdrop-opacity)",
|
|
"var(--tw-backdrop-saturate)",
|
|
"var(--tw-backdrop-sepia)",
|
|
].join(" ")),
|
|
(md = {
|
|
preflight: ({ addBase: i }) => {
|
|
let e = V.parse(
|
|
`*,::after,::before{box-sizing:border-box;border-width:0;border-style:solid;border-color:theme('borderColor.DEFAULT', currentColor)}::after,::before{--tw-content:''}:host,html{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;font-family:theme('fontFamily.sans', ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:theme('fontFamily.sans[1].fontFeatureSettings', normal);font-variation-settings:theme('fontFamily.sans[1].fontVariationSettings', normal);-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,pre,samp{font-family:theme('fontFamily.mono', ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:theme('fontFamily.mono[1].fontFeatureSettings', normal);font-variation-settings:theme('fontFamily.mono[1].fontVariationSettings', normal);font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dd,dl,figure,h1,h2,h3,h4,h5,h6,hr,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}menu,ol,ul{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::placeholder,textarea::placeholder{opacity:1;color:theme('colors.gray.4', #9ca3af)}[role=button],button{cursor:pointer}:disabled{cursor:default}audio,canvas,embed,iframe,img,object,svg,video{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]{display:none}`,
|
|
);
|
|
i([
|
|
V.comment({
|
|
text: `! tailwindcss v${Ha} | MIT License | https://tailwindcss.com`,
|
|
}),
|
|
...e.nodes,
|
|
]);
|
|
},
|
|
container: (() => {
|
|
function i(t = []) {
|
|
return t
|
|
.flatMap((r) => r.values.map((n) => n.min))
|
|
.filter((r) => r !== void 0);
|
|
}
|
|
function e(t, r, n) {
|
|
if (typeof n == "undefined") return [];
|
|
if (!(typeof n == "object" && n !== null))
|
|
return [{ screen: "DEFAULT", minWidth: 0, padding: n }];
|
|
let a = [];
|
|
n.DEFAULT &&
|
|
a.push({ screen: "DEFAULT", minWidth: 0, padding: n.DEFAULT });
|
|
for (let s of t)
|
|
for (let o of r)
|
|
for (let { min: u } of o.values)
|
|
u === s && a.push({ minWidth: s, padding: n[o.name] });
|
|
return a;
|
|
}
|
|
return function ({ addComponents: t, theme: r }) {
|
|
let n = at(r("container.screens", r("screens"))),
|
|
a = i(n),
|
|
s = e(a, n, r("container.padding")),
|
|
o = (c) => {
|
|
let f = s.find((d) => d.minWidth === c);
|
|
return f
|
|
? { paddingRight: f.padding, paddingLeft: f.padding }
|
|
: {};
|
|
},
|
|
u = Array.from(
|
|
new Set(a.slice().sort((c, f) => parseInt(c) - parseInt(f))),
|
|
).map((c) => ({
|
|
[`@media (min-width: ${c})`]: {
|
|
".container": { "max-width": c, ...o(c) },
|
|
},
|
|
}));
|
|
t([
|
|
{
|
|
".container": Object.assign(
|
|
{ width: "100%" },
|
|
r("container.center", !1)
|
|
? { marginRight: "auto", marginLeft: "auto" }
|
|
: {},
|
|
o(0),
|
|
),
|
|
},
|
|
...u,
|
|
]);
|
|
};
|
|
})(),
|
|
accessibility: ({ addUtilities: i }) => {
|
|
i({
|
|
".sr-only": {
|
|
position: "absolute",
|
|
width: "1px",
|
|
height: "1px",
|
|
padding: "0",
|
|
margin: "-1px",
|
|
overflow: "hidden",
|
|
clip: "rect(0, 0, 0, 0)",
|
|
whiteSpace: "nowrap",
|
|
borderWidth: "0",
|
|
},
|
|
".not-sr-only": {
|
|
position: "static",
|
|
width: "auto",
|
|
height: "auto",
|
|
padding: "0",
|
|
margin: "0",
|
|
overflow: "visible",
|
|
clip: "auto",
|
|
whiteSpace: "normal",
|
|
},
|
|
});
|
|
},
|
|
pointerEvents: ({ addUtilities: i }) => {
|
|
i({
|
|
".pointer-events-none": { "pointer-events": "none" },
|
|
".pointer-events-auto": { "pointer-events": "auto" },
|
|
});
|
|
},
|
|
visibility: ({ addUtilities: i }) => {
|
|
i({
|
|
".visible": { visibility: "visible" },
|
|
".invisible": { visibility: "hidden" },
|
|
".collapse": { visibility: "collapse" },
|
|
});
|
|
},
|
|
position: ({ addUtilities: i }) => {
|
|
i({
|
|
".static": { position: "static" },
|
|
".fixed": { position: "fixed" },
|
|
".absolute": { position: "absolute" },
|
|
".relative": { position: "relative" },
|
|
".sticky": { position: "sticky" },
|
|
});
|
|
},
|
|
inset: P(
|
|
"inset",
|
|
[
|
|
["inset", ["inset"]],
|
|
[
|
|
["inset-x", ["left", "right"]],
|
|
["inset-y", ["top", "bottom"]],
|
|
],
|
|
[
|
|
["start", ["inset-inline-start"]],
|
|
["end", ["inset-inline-end"]],
|
|
["top", ["top"]],
|
|
["right", ["right"]],
|
|
["bottom", ["bottom"]],
|
|
["left", ["left"]],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
isolation: ({ addUtilities: i }) => {
|
|
i({
|
|
".isolate": { isolation: "isolate" },
|
|
".isolation-auto": { isolation: "auto" },
|
|
});
|
|
},
|
|
zIndex: P("zIndex", [["z", ["zIndex"]]], {
|
|
supportsNegativeValues: !0,
|
|
}),
|
|
order: P("order", void 0, { supportsNegativeValues: !0 }),
|
|
gridColumn: P("gridColumn", [["col", ["gridColumn"]]]),
|
|
gridColumnStart: P("gridColumnStart", [
|
|
["col-start", ["gridColumnStart"]],
|
|
]),
|
|
gridColumnEnd: P("gridColumnEnd", [["col-end", ["gridColumnEnd"]]]),
|
|
gridRow: P("gridRow", [["row", ["gridRow"]]]),
|
|
gridRowStart: P("gridRowStart", [["row-start", ["gridRowStart"]]]),
|
|
gridRowEnd: P("gridRowEnd", [["row-end", ["gridRowEnd"]]]),
|
|
float: ({ addUtilities: i }) => {
|
|
i({
|
|
".float-start": { float: "inline-start" },
|
|
".float-end": { float: "inline-end" },
|
|
".float-right": { float: "right" },
|
|
".float-left": { float: "left" },
|
|
".float-none": { float: "none" },
|
|
});
|
|
},
|
|
clear: ({ addUtilities: i }) => {
|
|
i({
|
|
".clear-start": { clear: "inline-start" },
|
|
".clear-end": { clear: "inline-end" },
|
|
".clear-left": { clear: "left" },
|
|
".clear-right": { clear: "right" },
|
|
".clear-both": { clear: "both" },
|
|
".clear-none": { clear: "none" },
|
|
});
|
|
},
|
|
margin: P(
|
|
"margin",
|
|
[
|
|
["m", ["margin"]],
|
|
[
|
|
["mx", ["margin-left", "margin-right"]],
|
|
["my", ["margin-top", "margin-bottom"]],
|
|
],
|
|
[
|
|
["ms", ["margin-inline-start"]],
|
|
["me", ["margin-inline-end"]],
|
|
["mt", ["margin-top"]],
|
|
["mr", ["margin-right"]],
|
|
["mb", ["margin-bottom"]],
|
|
["ml", ["margin-left"]],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
boxSizing: ({ addUtilities: i }) => {
|
|
i({
|
|
".box-border": { "box-sizing": "border-box" },
|
|
".box-content": { "box-sizing": "content-box" },
|
|
});
|
|
},
|
|
lineClamp: ({ matchUtilities: i, addUtilities: e, theme: t }) => {
|
|
i(
|
|
{
|
|
"line-clamp": (r) => ({
|
|
overflow: "hidden",
|
|
display: "-webkit-box",
|
|
"-webkit-box-orient": "vertical",
|
|
"-webkit-line-clamp": `${r}`,
|
|
}),
|
|
},
|
|
{ values: t("lineClamp") },
|
|
),
|
|
e({
|
|
".line-clamp-none": {
|
|
overflow: "visible",
|
|
display: "block",
|
|
"-webkit-box-orient": "horizontal",
|
|
"-webkit-line-clamp": "none",
|
|
},
|
|
});
|
|
},
|
|
display: ({ addUtilities: i }) => {
|
|
i({
|
|
".block": { display: "block" },
|
|
".inline-block": { display: "inline-block" },
|
|
".inline": { display: "inline" },
|
|
".flex": { display: "flex" },
|
|
".inline-flex": { display: "inline-flex" },
|
|
".table": { display: "table" },
|
|
".inline-table": { display: "inline-table" },
|
|
".table-caption": { display: "table-caption" },
|
|
".table-cell": { display: "table-cell" },
|
|
".table-column": { display: "table-column" },
|
|
".table-column-group": { display: "table-column-group" },
|
|
".table-footer-group": { display: "table-footer-group" },
|
|
".table-header-group": { display: "table-header-group" },
|
|
".table-row-group": { display: "table-row-group" },
|
|
".table-row": { display: "table-row" },
|
|
".flow-root": { display: "flow-root" },
|
|
".grid": { display: "grid" },
|
|
".inline-grid": { display: "inline-grid" },
|
|
".contents": { display: "contents" },
|
|
".list-item": { display: "list-item" },
|
|
".hidden": { display: "none" },
|
|
});
|
|
},
|
|
aspectRatio: P("aspectRatio", [["aspect", ["aspect-ratio"]]]),
|
|
size: P("size", [["size", ["width", "height"]]]),
|
|
height: P("height", [["h", ["height"]]]),
|
|
maxHeight: P("maxHeight", [["max-h", ["maxHeight"]]]),
|
|
minHeight: P("minHeight", [["min-h", ["minHeight"]]]),
|
|
width: P("width", [["w", ["width"]]]),
|
|
minWidth: P("minWidth", [["min-w", ["minWidth"]]]),
|
|
maxWidth: P("maxWidth", [["max-w", ["maxWidth"]]]),
|
|
flex: P("flex"),
|
|
flexShrink: P("flexShrink", [
|
|
["flex-shrink", ["flex-shrink"]],
|
|
["shrink", ["flex-shrink"]],
|
|
]),
|
|
flexGrow: P("flexGrow", [
|
|
["flex-grow", ["flex-grow"]],
|
|
["grow", ["flex-grow"]],
|
|
]),
|
|
flexBasis: P("flexBasis", [["basis", ["flex-basis"]]]),
|
|
tableLayout: ({ addUtilities: i }) => {
|
|
i({
|
|
".table-auto": { "table-layout": "auto" },
|
|
".table-fixed": { "table-layout": "fixed" },
|
|
});
|
|
},
|
|
captionSide: ({ addUtilities: i }) => {
|
|
i({
|
|
".caption-top": { "caption-side": "top" },
|
|
".caption-bottom": { "caption-side": "bottom" },
|
|
});
|
|
},
|
|
borderCollapse: ({ addUtilities: i }) => {
|
|
i({
|
|
".border-collapse": { "border-collapse": "collapse" },
|
|
".border-separate": { "border-collapse": "separate" },
|
|
});
|
|
},
|
|
borderSpacing: ({ addDefaults: i, matchUtilities: e, theme: t }) => {
|
|
i("border-spacing", {
|
|
"--tw-border-spacing-x": 0,
|
|
"--tw-border-spacing-y": 0,
|
|
}),
|
|
e(
|
|
{
|
|
"border-spacing": (r) => ({
|
|
"--tw-border-spacing-x": r,
|
|
"--tw-border-spacing-y": r,
|
|
"@defaults border-spacing": {},
|
|
"border-spacing":
|
|
"var(--tw-border-spacing-x) var(--tw-border-spacing-y)",
|
|
}),
|
|
"border-spacing-x": (r) => ({
|
|
"--tw-border-spacing-x": r,
|
|
"@defaults border-spacing": {},
|
|
"border-spacing":
|
|
"var(--tw-border-spacing-x) var(--tw-border-spacing-y)",
|
|
}),
|
|
"border-spacing-y": (r) => ({
|
|
"--tw-border-spacing-y": r,
|
|
"@defaults border-spacing": {},
|
|
"border-spacing":
|
|
"var(--tw-border-spacing-x) var(--tw-border-spacing-y)",
|
|
}),
|
|
},
|
|
{ values: t("borderSpacing") },
|
|
);
|
|
},
|
|
transformOrigin: P("transformOrigin", [
|
|
["origin", ["transformOrigin"]],
|
|
]),
|
|
translate: P(
|
|
"translate",
|
|
[
|
|
[
|
|
[
|
|
"translate-x",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-translate-x",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
[
|
|
"translate-y",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-translate-y",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
rotate: P(
|
|
"rotate",
|
|
[
|
|
[
|
|
"rotate",
|
|
[["@defaults transform", {}], "--tw-rotate", ["transform", Te]],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
skew: P(
|
|
"skew",
|
|
[
|
|
[
|
|
[
|
|
"skew-x",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-skew-x",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
[
|
|
"skew-y",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-skew-y",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
scale: P(
|
|
"scale",
|
|
[
|
|
[
|
|
"scale",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-scale-x",
|
|
"--tw-scale-y",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
[
|
|
[
|
|
"scale-x",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-scale-x",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
[
|
|
"scale-y",
|
|
[
|
|
["@defaults transform", {}],
|
|
"--tw-scale-y",
|
|
["transform", Te],
|
|
],
|
|
],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
transform: ({ addDefaults: i, addUtilities: e }) => {
|
|
i("transform", {
|
|
"--tw-translate-x": "0",
|
|
"--tw-translate-y": "0",
|
|
"--tw-rotate": "0",
|
|
"--tw-skew-x": "0",
|
|
"--tw-skew-y": "0",
|
|
"--tw-scale-x": "1",
|
|
"--tw-scale-y": "1",
|
|
}),
|
|
e({
|
|
".transform": { "@defaults transform": {}, transform: Te },
|
|
".transform-cpu": { transform: Te },
|
|
".transform-gpu": {
|
|
transform: Te.replace(
|
|
"translate(var(--tw-translate-x), var(--tw-translate-y))",
|
|
"translate3d(var(--tw-translate-x), var(--tw-translate-y), 0)",
|
|
),
|
|
},
|
|
".transform-none": { transform: "none" },
|
|
});
|
|
},
|
|
animation: ({ matchUtilities: i, theme: e, config: t }) => {
|
|
let r = (a) => de(t("prefix") + a),
|
|
n = Object.fromEntries(
|
|
Object.entries(e("keyframes") ?? {}).map(([a, s]) => [
|
|
a,
|
|
{ [`@keyframes ${r(a)}`]: s },
|
|
]),
|
|
);
|
|
i(
|
|
{
|
|
animate: (a) => {
|
|
let s = Wa(a);
|
|
return [
|
|
...s.flatMap((o) => n[o.name]),
|
|
{
|
|
animation: s
|
|
.map(({ name: o, value: u }) =>
|
|
o === void 0 || n[o] === void 0
|
|
? u
|
|
: u.replace(o, r(o)),
|
|
)
|
|
.join(", "),
|
|
},
|
|
];
|
|
},
|
|
},
|
|
{ values: e("animation") },
|
|
);
|
|
},
|
|
cursor: P("cursor"),
|
|
touchAction: ({ addDefaults: i, addUtilities: e }) => {
|
|
i("touch-action", {
|
|
"--tw-pan-x": " ",
|
|
"--tw-pan-y": " ",
|
|
"--tw-pinch-zoom": " ",
|
|
});
|
|
let t = "var(--tw-pan-x) var(--tw-pan-y) var(--tw-pinch-zoom)";
|
|
e({
|
|
".touch-auto": { "touch-action": "auto" },
|
|
".touch-none": { "touch-action": "none" },
|
|
".touch-pan-x": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-x": "pan-x",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pan-left": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-x": "pan-left",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pan-right": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-x": "pan-right",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pan-y": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-y": "pan-y",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pan-up": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-y": "pan-up",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pan-down": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pan-y": "pan-down",
|
|
"touch-action": t,
|
|
},
|
|
".touch-pinch-zoom": {
|
|
"@defaults touch-action": {},
|
|
"--tw-pinch-zoom": "pinch-zoom",
|
|
"touch-action": t,
|
|
},
|
|
".touch-manipulation": { "touch-action": "manipulation" },
|
|
});
|
|
},
|
|
userSelect: ({ addUtilities: i }) => {
|
|
i({
|
|
".select-none": { "user-select": "none" },
|
|
".select-text": { "user-select": "text" },
|
|
".select-all": { "user-select": "all" },
|
|
".select-auto": { "user-select": "auto" },
|
|
});
|
|
},
|
|
resize: ({ addUtilities: i }) => {
|
|
i({
|
|
".resize-none": { resize: "none" },
|
|
".resize-y": { resize: "vertical" },
|
|
".resize-x": { resize: "horizontal" },
|
|
".resize": { resize: "both" },
|
|
});
|
|
},
|
|
scrollSnapType: ({ addDefaults: i, addUtilities: e }) => {
|
|
i("scroll-snap-type", {
|
|
"--tw-scroll-snap-strictness": "proximity",
|
|
}),
|
|
e({
|
|
".snap-none": { "scroll-snap-type": "none" },
|
|
".snap-x": {
|
|
"@defaults scroll-snap-type": {},
|
|
"scroll-snap-type": "x var(--tw-scroll-snap-strictness)",
|
|
},
|
|
".snap-y": {
|
|
"@defaults scroll-snap-type": {},
|
|
"scroll-snap-type": "y var(--tw-scroll-snap-strictness)",
|
|
},
|
|
".snap-both": {
|
|
"@defaults scroll-snap-type": {},
|
|
"scroll-snap-type": "both var(--tw-scroll-snap-strictness)",
|
|
},
|
|
".snap-mandatory": {
|
|
"--tw-scroll-snap-strictness": "mandatory",
|
|
},
|
|
".snap-proximity": {
|
|
"--tw-scroll-snap-strictness": "proximity",
|
|
},
|
|
});
|
|
},
|
|
scrollSnapAlign: ({ addUtilities: i }) => {
|
|
i({
|
|
".snap-start": { "scroll-snap-align": "start" },
|
|
".snap-end": { "scroll-snap-align": "end" },
|
|
".snap-center": { "scroll-snap-align": "center" },
|
|
".snap-align-none": { "scroll-snap-align": "none" },
|
|
});
|
|
},
|
|
scrollSnapStop: ({ addUtilities: i }) => {
|
|
i({
|
|
".snap-normal": { "scroll-snap-stop": "normal" },
|
|
".snap-always": { "scroll-snap-stop": "always" },
|
|
});
|
|
},
|
|
scrollMargin: P(
|
|
"scrollMargin",
|
|
[
|
|
["scroll-m", ["scroll-margin"]],
|
|
[
|
|
["scroll-mx", ["scroll-margin-left", "scroll-margin-right"]],
|
|
["scroll-my", ["scroll-margin-top", "scroll-margin-bottom"]],
|
|
],
|
|
[
|
|
["scroll-ms", ["scroll-margin-inline-start"]],
|
|
["scroll-me", ["scroll-margin-inline-end"]],
|
|
["scroll-mt", ["scroll-margin-top"]],
|
|
["scroll-mr", ["scroll-margin-right"]],
|
|
["scroll-mb", ["scroll-margin-bottom"]],
|
|
["scroll-ml", ["scroll-margin-left"]],
|
|
],
|
|
],
|
|
{ supportsNegativeValues: !0 },
|
|
),
|
|
scrollPadding: P("scrollPadding", [
|
|
["scroll-p", ["scroll-padding"]],
|
|
[
|
|
["scroll-px", ["scroll-padding-left", "scroll-padding-right"]],
|
|
["scroll-py", ["scroll-padding-top", "scroll-padding-bottom"]],
|
|
],
|
|
[
|
|
["scroll-ps", ["scroll-padding-inline-start"]],
|
|
["scroll-pe", ["scroll-padding-inline-end"]],
|
|
["scroll-pt", ["scroll-padding-top"]],
|
|
["scroll-pr", ["scroll-padding-right"]],
|
|
["scroll-pb", ["scroll-padding-bottom"]],
|
|
["scroll-pl", ["scroll-padding-left"]],
|
|
],
|
|
]),
|
|
listStylePosition: ({ addUtilities: i }) => {
|
|
i({
|
|
".list-inside": { "list-style-position": "inside" },
|
|
".list-outside": { "list-style-position": "outside" },
|
|
});
|
|
},
|
|
listStyleType: P("listStyleType", [["list", ["listStyleType"]]]),
|
|
listStyleImage: P("listStyleImage", [
|
|
["list-image", ["listStyleImage"]],
|
|
]),
|
|
appearance: ({ addUtilities: i }) => {
|
|
i({
|
|
".appearance-none": { appearance: "none" },
|
|
".appearance-auto": { appearance: "auto" },
|
|
});
|
|
},
|
|
columns: P("columns", [["columns", ["columns"]]]),
|
|
breakBefore: ({ addUtilities: i }) => {
|
|
i({
|
|
".break-before-auto": { "break-before": "auto" },
|
|
".break-before-avoid": { "break-before": "avoid" },
|
|
".break-before-all": { "break-before": "all" },
|
|
".break-before-avoid-page": { "break-before": "avoid-page" },
|
|
".break-before-page": { "break-before": "page" },
|
|
".break-before-left": { "break-before": "left" },
|
|
".break-before-right": { "break-before": "right" },
|
|
".break-before-column": { "break-before": "column" },
|
|
});
|
|
},
|
|
breakInside: ({ addUtilities: i }) => {
|
|
i({
|
|
".break-inside-auto": { "break-inside": "auto" },
|
|
".break-inside-avoid": { "break-inside": "avoid" },
|
|
".break-inside-avoid-page": { "break-inside": "avoid-page" },
|
|
".break-inside-avoid-column": { "break-inside": "avoid-column" },
|
|
});
|
|
},
|
|
breakAfter: ({ addUtilities: i }) => {
|
|
i({
|
|
".break-after-auto": { "break-after": "auto" },
|
|
".break-after-avoid": { "break-after": "avoid" },
|
|
".break-after-all": { "break-after": "all" },
|
|
".break-after-avoid-page": { "break-after": "avoid-page" },
|
|
".break-after-page": { "break-after": "page" },
|
|
".break-after-left": { "break-after": "left" },
|
|
".break-after-right": { "break-after": "right" },
|
|
".break-after-column": { "break-after": "column" },
|
|
});
|
|
},
|
|
gridAutoColumns: P("gridAutoColumns", [
|
|
["auto-cols", ["gridAutoColumns"]],
|
|
]),
|
|
gridAutoFlow: ({ addUtilities: i }) => {
|
|
i({
|
|
".grid-flow-row": { gridAutoFlow: "row" },
|
|
".grid-flow-col": { gridAutoFlow: "column" },
|
|
".grid-flow-dense": { gridAutoFlow: "dense" },
|
|
".grid-flow-row-dense": { gridAutoFlow: "row dense" },
|
|
".grid-flow-col-dense": { gridAutoFlow: "column dense" },
|
|
});
|
|
},
|
|
gridAutoRows: P("gridAutoRows", [["auto-rows", ["gridAutoRows"]]]),
|
|
gridTemplateColumns: P("gridTemplateColumns", [
|
|
["grid-cols", ["gridTemplateColumns"]],
|
|
]),
|
|
gridTemplateRows: P("gridTemplateRows", [
|
|
["grid-rows", ["gridTemplateRows"]],
|
|
]),
|
|
flexDirection: ({ addUtilities: i }) => {
|
|
i({
|
|
".flex-row": { "flex-direction": "row" },
|
|
".flex-row-reverse": { "flex-direction": "row-reverse" },
|
|
".flex-col": { "flex-direction": "column" },
|
|
".flex-col-reverse": { "flex-direction": "column-reverse" },
|
|
});
|
|
},
|
|
flexWrap: ({ addUtilities: i }) => {
|
|
i({
|
|
".flex-wrap": { "flex-wrap": "wrap" },
|
|
".flex-wrap-reverse": { "flex-wrap": "wrap-reverse" },
|
|
".flex-nowrap": { "flex-wrap": "nowrap" },
|
|
});
|
|
},
|
|
placeContent: ({ addUtilities: i }) => {
|
|
i({
|
|
".place-content-center": { "place-content": "center" },
|
|
".place-content-start": { "place-content": "start" },
|
|
".place-content-end": { "place-content": "end" },
|
|
".place-content-between": { "place-content": "space-between" },
|
|
".place-content-around": { "place-content": "space-around" },
|
|
".place-content-evenly": { "place-content": "space-evenly" },
|
|
".place-content-baseline": { "place-content": "baseline" },
|
|
".place-content-stretch": { "place-content": "stretch" },
|
|
});
|
|
},
|
|
placeItems: ({ addUtilities: i }) => {
|
|
i({
|
|
".place-items-start": { "place-items": "start" },
|
|
".place-items-end": { "place-items": "end" },
|
|
".place-items-center": { "place-items": "center" },
|
|
".place-items-baseline": { "place-items": "baseline" },
|
|
".place-items-stretch": { "place-items": "stretch" },
|
|
});
|
|
},
|
|
alignContent: ({ addUtilities: i }) => {
|
|
i({
|
|
".content-normal": { "align-content": "normal" },
|
|
".content-center": { "align-content": "center" },
|
|
".content-start": { "align-content": "flex-start" },
|
|
".content-end": { "align-content": "flex-end" },
|
|
".content-between": { "align-content": "space-between" },
|
|
".content-around": { "align-content": "space-around" },
|
|
".content-evenly": { "align-content": "space-evenly" },
|
|
".content-baseline": { "align-content": "baseline" },
|
|
".content-stretch": { "align-content": "stretch" },
|
|
});
|
|
},
|
|
alignItems: ({ addUtilities: i }) => {
|
|
i({
|
|
".items-start": { "align-items": "flex-start" },
|
|
".items-end": { "align-items": "flex-end" },
|
|
".items-center": { "align-items": "center" },
|
|
".items-baseline": { "align-items": "baseline" },
|
|
".items-stretch": { "align-items": "stretch" },
|
|
});
|
|
},
|
|
justifyContent: ({ addUtilities: i }) => {
|
|
i({
|
|
".justify-normal": { "justify-content": "normal" },
|
|
".justify-start": { "justify-content": "flex-start" },
|
|
".justify-end": { "justify-content": "flex-end" },
|
|
".justify-center": { "justify-content": "center" },
|
|
".justify-between": { "justify-content": "space-between" },
|
|
".justify-around": { "justify-content": "space-around" },
|
|
".justify-evenly": { "justify-content": "space-evenly" },
|
|
".justify-stretch": { "justify-content": "stretch" },
|
|
});
|
|
},
|
|
justifyItems: ({ addUtilities: i }) => {
|
|
i({
|
|
".justify-items-start": { "justify-items": "start" },
|
|
".justify-items-end": { "justify-items": "end" },
|
|
".justify-items-center": { "justify-items": "center" },
|
|
".justify-items-stretch": { "justify-items": "stretch" },
|
|
});
|
|
},
|
|
gap: P("gap", [
|
|
["gap", ["gap"]],
|
|
[
|
|
["gap-x", ["columnGap"]],
|
|
["gap-y", ["rowGap"]],
|
|
],
|
|
]),
|
|
space: ({ matchUtilities: i, addUtilities: e, theme: t }) => {
|
|
i(
|
|
{
|
|
"space-x": (r) => (
|
|
(r = r === "0" ? "0px" : r),
|
|
{
|
|
"& > :not([hidden]) ~ :not([hidden])": {
|
|
"--tw-space-x-reverse": "0",
|
|
"margin-right": `calc(${r} * var(--tw-space-x-reverse))`,
|
|
"margin-left": `calc(${r} * calc(1 - var(--tw-space-x-reverse)))`,
|
|
},
|
|
}
|
|
),
|
|
"space-y": (r) => (
|
|
(r = r === "0" ? "0px" : r),
|
|
{
|
|
"& > :not([hidden]) ~ :not([hidden])": {
|
|
"--tw-space-y-reverse": "0",
|
|
"margin-top": `calc(${r} * calc(1 - var(--tw-space-y-reverse)))`,
|
|
"margin-bottom": `calc(${r} * var(--tw-space-y-reverse))`,
|
|
},
|
|
}
|
|
),
|
|
},
|
|
{ values: t("space"), supportsNegativeValues: !0 },
|
|
),
|
|
e({
|
|
".space-y-reverse > :not([hidden]) ~ :not([hidden])": {
|
|
"--tw-space-y-reverse": "1",
|
|
},
|
|
".space-x-reverse > :not([hidden]) ~ :not([hidden])": {
|
|
"--tw-space-x-reverse": "1",
|
|
},
|
|
});
|
|
},
|
|
divideWidth: ({ matchUtilities: i, addUtilities: e, theme: t }) => {
|
|
i(
|
|
{
|
|
"divide-x": (r) => (
|
|
(r = r === "0" ? "0px" : r),
|
|
{
|
|
"& > :not([hidden]) ~ :not([hidden])": {
|
|
"@defaults border-width": {},
|
|
"--tw-divide-x-reverse": "0",
|
|
"border-right-width": `calc(${r} * var(--tw-divide-x-reverse))`,
|
|
"border-left-width": `calc(${r} * calc(1 - var(--tw-divide-x-reverse)))`,
|
|
},
|
|
}
|
|
),
|
|
"divide-y": (r) => (
|
|
(r = r === "0" ? "0px" : r),
|
|
{
|
|
"& > :not([hidden]) ~ :not([hidden])": {
|
|
"@defaults border-width": {},
|
|
"--tw-divide-y-reverse": "0",
|
|
"border-top-width": `calc(${r} * calc(1 - var(--tw-divide-y-reverse)))`,
|
|
"border-bottom-width": `calc(${r} * var(--tw-divide-y-reverse))`,
|
|
},
|
|
}
|
|
),
|
|
},
|
|
{
|
|
values: t("divideWidth"),
|
|
type: ["line-width", "length", "any"],
|
|
},
|
|
),
|
|
e({
|
|
".divide-y-reverse > :not([hidden]) ~ :not([hidden])": {
|
|
"@defaults border-width": {},
|
|
"--tw-divide-y-reverse": "1",
|
|
},
|
|
".divide-x-reverse > :not([hidden]) ~ :not([hidden])": {
|
|
"@defaults border-width": {},
|
|
"--tw-divide-x-reverse": "1",
|
|
},
|
|
});
|
|
},
|
|
divideStyle: ({ addUtilities: i }) => {
|
|
i({
|
|
".divide-solid > :not([hidden]) ~ :not([hidden])": {
|
|
"border-style": "solid",
|
|
},
|
|
".divide-dashed > :not([hidden]) ~ :not([hidden])": {
|
|
"border-style": "dashed",
|
|
},
|
|
".divide-dotted > :not([hidden]) ~ :not([hidden])": {
|
|
"border-style": "dotted",
|
|
},
|
|
".divide-double > :not([hidden]) ~ :not([hidden])": {
|
|
"border-style": "double",
|
|
},
|
|
".divide-none > :not([hidden]) ~ :not([hidden])": {
|
|
"border-style": "none",
|
|
},
|
|
});
|
|
},
|
|
divideColor: ({ matchUtilities: i, theme: e, corePlugins: t }) => {
|
|
i(
|
|
{
|
|
divide: (r) =>
|
|
t("divideOpacity")
|
|
? {
|
|
["& > :not([hidden]) ~ :not([hidden])"]: ae({
|
|
color: r,
|
|
property: "border-color",
|
|
variable: "--tw-divide-opacity",
|
|
}),
|
|
}
|
|
: {
|
|
["& > :not([hidden]) ~ :not([hidden])"]: {
|
|
"border-color": L(r),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
values: (({ DEFAULT: r, ...n }) => n)(ie(e("divideColor"))),
|
|
type: ["color", "any"],
|
|
},
|
|
);
|
|
},
|
|
divideOpacity: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"divide-opacity": (t) => ({
|
|
["& > :not([hidden]) ~ :not([hidden])"]: {
|
|
"--tw-divide-opacity": t,
|
|
},
|
|
}),
|
|
},
|
|
{ values: e("divideOpacity") },
|
|
);
|
|
},
|
|
placeSelf: ({ addUtilities: i }) => {
|
|
i({
|
|
".place-self-auto": { "place-self": "auto" },
|
|
".place-self-start": { "place-self": "start" },
|
|
".place-self-end": { "place-self": "end" },
|
|
".place-self-center": { "place-self": "center" },
|
|
".place-self-stretch": { "place-self": "stretch" },
|
|
});
|
|
},
|
|
alignSelf: ({ addUtilities: i }) => {
|
|
i({
|
|
".self-auto": { "align-self": "auto" },
|
|
".self-start": { "align-self": "flex-start" },
|
|
".self-end": { "align-self": "flex-end" },
|
|
".self-center": { "align-self": "center" },
|
|
".self-stretch": { "align-self": "stretch" },
|
|
".self-baseline": { "align-self": "baseline" },
|
|
});
|
|
},
|
|
justifySelf: ({ addUtilities: i }) => {
|
|
i({
|
|
".justify-self-auto": { "justify-self": "auto" },
|
|
".justify-self-start": { "justify-self": "start" },
|
|
".justify-self-end": { "justify-self": "end" },
|
|
".justify-self-center": { "justify-self": "center" },
|
|
".justify-self-stretch": { "justify-self": "stretch" },
|
|
});
|
|
},
|
|
overflow: ({ addUtilities: i }) => {
|
|
i({
|
|
".overflow-auto": { overflow: "auto" },
|
|
".overflow-hidden": { overflow: "hidden" },
|
|
".overflow-clip": { overflow: "clip" },
|
|
".overflow-visible": { overflow: "visible" },
|
|
".overflow-scroll": { overflow: "scroll" },
|
|
".overflow-x-auto": { "overflow-x": "auto" },
|
|
".overflow-y-auto": { "overflow-y": "auto" },
|
|
".overflow-x-hidden": { "overflow-x": "hidden" },
|
|
".overflow-y-hidden": { "overflow-y": "hidden" },
|
|
".overflow-x-clip": { "overflow-x": "clip" },
|
|
".overflow-y-clip": { "overflow-y": "clip" },
|
|
".overflow-x-visible": { "overflow-x": "visible" },
|
|
".overflow-y-visible": { "overflow-y": "visible" },
|
|
".overflow-x-scroll": { "overflow-x": "scroll" },
|
|
".overflow-y-scroll": { "overflow-y": "scroll" },
|
|
});
|
|
},
|
|
overscrollBehavior: ({ addUtilities: i }) => {
|
|
i({
|
|
".overscroll-auto": { "overscroll-behavior": "auto" },
|
|
".overscroll-contain": { "overscroll-behavior": "contain" },
|
|
".overscroll-none": { "overscroll-behavior": "none" },
|
|
".overscroll-y-auto": { "overscroll-behavior-y": "auto" },
|
|
".overscroll-y-contain": { "overscroll-behavior-y": "contain" },
|
|
".overscroll-y-none": { "overscroll-behavior-y": "none" },
|
|
".overscroll-x-auto": { "overscroll-behavior-x": "auto" },
|
|
".overscroll-x-contain": { "overscroll-behavior-x": "contain" },
|
|
".overscroll-x-none": { "overscroll-behavior-x": "none" },
|
|
});
|
|
},
|
|
scrollBehavior: ({ addUtilities: i }) => {
|
|
i({
|
|
".scroll-auto": { "scroll-behavior": "auto" },
|
|
".scroll-smooth": { "scroll-behavior": "smooth" },
|
|
});
|
|
},
|
|
textOverflow: ({ addUtilities: i }) => {
|
|
i({
|
|
".truncate": {
|
|
overflow: "hidden",
|
|
"text-overflow": "ellipsis",
|
|
"white-space": "nowrap",
|
|
},
|
|
".overflow-ellipsis": { "text-overflow": "ellipsis" },
|
|
".text-ellipsis": { "text-overflow": "ellipsis" },
|
|
".text-clip": { "text-overflow": "clip" },
|
|
});
|
|
},
|
|
hyphens: ({ addUtilities: i }) => {
|
|
i({
|
|
".hyphens-none": { hyphens: "none" },
|
|
".hyphens-manual": { hyphens: "manual" },
|
|
".hyphens-auto": { hyphens: "auto" },
|
|
});
|
|
},
|
|
whitespace: ({ addUtilities: i }) => {
|
|
i({
|
|
".whitespace-normal": { "white-space": "normal" },
|
|
".whitespace-nowrap": { "white-space": "nowrap" },
|
|
".whitespace-pre": { "white-space": "pre" },
|
|
".whitespace-pre-line": { "white-space": "pre-line" },
|
|
".whitespace-pre-wrap": { "white-space": "pre-wrap" },
|
|
".whitespace-break-spaces": { "white-space": "break-spaces" },
|
|
});
|
|
},
|
|
textWrap: ({ addUtilities: i }) => {
|
|
i({
|
|
".text-wrap": { "text-wrap": "wrap" },
|
|
".text-nowrap": { "text-wrap": "nowrap" },
|
|
".text-balance": { "text-wrap": "balance" },
|
|
".text-pretty": { "text-wrap": "pretty" },
|
|
});
|
|
},
|
|
wordBreak: ({ addUtilities: i }) => {
|
|
i({
|
|
".break-normal": {
|
|
"overflow-wrap": "normal",
|
|
"word-break": "normal",
|
|
},
|
|
".break-words": { "overflow-wrap": "break-word" },
|
|
".break-all": { "word-break": "break-all" },
|
|
".break-keep": { "word-break": "keep-all" },
|
|
});
|
|
},
|
|
borderRadius: P("borderRadius", [
|
|
["rounded", ["border-radius"]],
|
|
[
|
|
[
|
|
"rounded-s",
|
|
["border-start-start-radius", "border-end-start-radius"],
|
|
],
|
|
[
|
|
"rounded-e",
|
|
["border-start-end-radius", "border-end-end-radius"],
|
|
],
|
|
[
|
|
"rounded-t",
|
|
["border-top-left-radius", "border-top-right-radius"],
|
|
],
|
|
[
|
|
"rounded-r",
|
|
["border-top-right-radius", "border-bottom-right-radius"],
|
|
],
|
|
[
|
|
"rounded-b",
|
|
["border-bottom-right-radius", "border-bottom-left-radius"],
|
|
],
|
|
[
|
|
"rounded-l",
|
|
["border-top-left-radius", "border-bottom-left-radius"],
|
|
],
|
|
],
|
|
[
|
|
["rounded-ss", ["border-start-start-radius"]],
|
|
["rounded-se", ["border-start-end-radius"]],
|
|
["rounded-ee", ["border-end-end-radius"]],
|
|
["rounded-es", ["border-end-start-radius"]],
|
|
["rounded-tl", ["border-top-left-radius"]],
|
|
["rounded-tr", ["border-top-right-radius"]],
|
|
["rounded-br", ["border-bottom-right-radius"]],
|
|
["rounded-bl", ["border-bottom-left-radius"]],
|
|
],
|
|
]),
|
|
borderWidth: P(
|
|
"borderWidth",
|
|
[
|
|
["border", [["@defaults border-width", {}], "border-width"]],
|
|
[
|
|
[
|
|
"border-x",
|
|
[
|
|
["@defaults border-width", {}],
|
|
"border-left-width",
|
|
"border-right-width",
|
|
],
|
|
],
|
|
[
|
|
"border-y",
|
|
[
|
|
["@defaults border-width", {}],
|
|
"border-top-width",
|
|
"border-bottom-width",
|
|
],
|
|
],
|
|
],
|
|
[
|
|
[
|
|
"border-s",
|
|
[["@defaults border-width", {}], "border-inline-start-width"],
|
|
],
|
|
[
|
|
"border-e",
|
|
[["@defaults border-width", {}], "border-inline-end-width"],
|
|
],
|
|
[
|
|
"border-t",
|
|
[["@defaults border-width", {}], "border-top-width"],
|
|
],
|
|
[
|
|
"border-r",
|
|
[["@defaults border-width", {}], "border-right-width"],
|
|
],
|
|
[
|
|
"border-b",
|
|
[["@defaults border-width", {}], "border-bottom-width"],
|
|
],
|
|
[
|
|
"border-l",
|
|
[["@defaults border-width", {}], "border-left-width"],
|
|
],
|
|
],
|
|
],
|
|
{ type: ["line-width", "length"] },
|
|
),
|
|
borderStyle: ({ addUtilities: i }) => {
|
|
i({
|
|
".border-solid": { "border-style": "solid" },
|
|
".border-dashed": { "border-style": "dashed" },
|
|
".border-dotted": { "border-style": "dotted" },
|
|
".border-double": { "border-style": "double" },
|
|
".border-hidden": { "border-style": "hidden" },
|
|
".border-none": { "border-style": "none" },
|
|
});
|
|
},
|
|
borderColor: ({ matchUtilities: i, theme: e, corePlugins: t }) => {
|
|
i(
|
|
{
|
|
border: (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-color": L(r) },
|
|
},
|
|
{
|
|
values: (({ DEFAULT: r, ...n }) => n)(ie(e("borderColor"))),
|
|
type: ["color", "any"],
|
|
},
|
|
),
|
|
i(
|
|
{
|
|
"border-x": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: ["border-left-color", "border-right-color"],
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: {
|
|
"border-left-color": L(r),
|
|
"border-right-color": L(r),
|
|
},
|
|
"border-y": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: ["border-top-color", "border-bottom-color"],
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: {
|
|
"border-top-color": L(r),
|
|
"border-bottom-color": L(r),
|
|
},
|
|
},
|
|
{
|
|
values: (({ DEFAULT: r, ...n }) => n)(ie(e("borderColor"))),
|
|
type: ["color", "any"],
|
|
},
|
|
),
|
|
i(
|
|
{
|
|
"border-s": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-inline-start-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-inline-start-color": L(r) },
|
|
"border-e": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-inline-end-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-inline-end-color": L(r) },
|
|
"border-t": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-top-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-top-color": L(r) },
|
|
"border-r": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-right-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-right-color": L(r) },
|
|
"border-b": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-bottom-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-bottom-color": L(r) },
|
|
"border-l": (r) =>
|
|
t("borderOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "border-left-color",
|
|
variable: "--tw-border-opacity",
|
|
})
|
|
: { "border-left-color": L(r) },
|
|
},
|
|
{
|
|
values: (({ DEFAULT: r, ...n }) => n)(ie(e("borderColor"))),
|
|
type: ["color", "any"],
|
|
},
|
|
);
|
|
},
|
|
borderOpacity: P("borderOpacity", [
|
|
["border-opacity", ["--tw-border-opacity"]],
|
|
]),
|
|
backgroundColor: ({
|
|
matchUtilities: i,
|
|
theme: e,
|
|
corePlugins: t,
|
|
}) => {
|
|
i(
|
|
{
|
|
bg: (r) =>
|
|
t("backgroundOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "background-color",
|
|
variable: "--tw-bg-opacity",
|
|
})
|
|
: { "background-color": L(r) },
|
|
},
|
|
{ values: ie(e("backgroundColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
backgroundOpacity: P("backgroundOpacity", [
|
|
["bg-opacity", ["--tw-bg-opacity"]],
|
|
]),
|
|
backgroundImage: P(
|
|
"backgroundImage",
|
|
[["bg", ["background-image"]]],
|
|
{ type: ["lookup", "image", "url"] },
|
|
),
|
|
gradientColorStops: (() => {
|
|
function i(e) {
|
|
return De(e, 0, "rgb(255 255 255 / 0)");
|
|
}
|
|
return function ({ matchUtilities: e, theme: t, addDefaults: r }) {
|
|
r("gradient-color-stops", {
|
|
"--tw-gradient-from-position": " ",
|
|
"--tw-gradient-via-position": " ",
|
|
"--tw-gradient-to-position": " ",
|
|
});
|
|
let n = {
|
|
values: ie(t("gradientColorStops")),
|
|
type: ["color", "any"],
|
|
},
|
|
a = {
|
|
values: t("gradientColorStopPositions"),
|
|
type: ["length", "percentage"],
|
|
};
|
|
e(
|
|
{
|
|
from: (s) => {
|
|
let o = i(s);
|
|
return {
|
|
"@defaults gradient-color-stops": {},
|
|
"--tw-gradient-from": `${L(s)} var(--tw-gradient-from-position)`,
|
|
"--tw-gradient-to": `${o} var(--tw-gradient-to-position)`,
|
|
"--tw-gradient-stops":
|
|
"var(--tw-gradient-from), var(--tw-gradient-to)",
|
|
};
|
|
},
|
|
},
|
|
n,
|
|
),
|
|
e({ from: (s) => ({ "--tw-gradient-from-position": s }) }, a),
|
|
e(
|
|
{
|
|
via: (s) => {
|
|
let o = i(s);
|
|
return {
|
|
"@defaults gradient-color-stops": {},
|
|
"--tw-gradient-to": `${o} var(--tw-gradient-to-position)`,
|
|
"--tw-gradient-stops": `var(--tw-gradient-from), ${L(s)} var(--tw-gradient-via-position), var(--tw-gradient-to)`,
|
|
};
|
|
},
|
|
},
|
|
n,
|
|
),
|
|
e({ via: (s) => ({ "--tw-gradient-via-position": s }) }, a),
|
|
e(
|
|
{
|
|
to: (s) => ({
|
|
"@defaults gradient-color-stops": {},
|
|
"--tw-gradient-to": `${L(s)} var(--tw-gradient-to-position)`,
|
|
}),
|
|
},
|
|
n,
|
|
),
|
|
e({ to: (s) => ({ "--tw-gradient-to-position": s }) }, a);
|
|
};
|
|
})(),
|
|
boxDecorationBreak: ({ addUtilities: i }) => {
|
|
i({
|
|
".decoration-slice": { "box-decoration-break": "slice" },
|
|
".decoration-clone": { "box-decoration-break": "clone" },
|
|
".box-decoration-slice": { "box-decoration-break": "slice" },
|
|
".box-decoration-clone": { "box-decoration-break": "clone" },
|
|
});
|
|
},
|
|
backgroundSize: P("backgroundSize", [["bg", ["background-size"]]], {
|
|
type: ["lookup", "length", "percentage", "size"],
|
|
}),
|
|
backgroundAttachment: ({ addUtilities: i }) => {
|
|
i({
|
|
".bg-fixed": { "background-attachment": "fixed" },
|
|
".bg-local": { "background-attachment": "local" },
|
|
".bg-scroll": { "background-attachment": "scroll" },
|
|
});
|
|
},
|
|
backgroundClip: ({ addUtilities: i }) => {
|
|
i({
|
|
".bg-clip-border": { "background-clip": "border-box" },
|
|
".bg-clip-padding": { "background-clip": "padding-box" },
|
|
".bg-clip-content": { "background-clip": "content-box" },
|
|
".bg-clip-text": { "background-clip": "text" },
|
|
});
|
|
},
|
|
backgroundPosition: P(
|
|
"backgroundPosition",
|
|
[["bg", ["background-position"]]],
|
|
{ type: ["lookup", ["position", { preferOnConflict: !0 }]] },
|
|
),
|
|
backgroundRepeat: ({ addUtilities: i }) => {
|
|
i({
|
|
".bg-repeat": { "background-repeat": "repeat" },
|
|
".bg-no-repeat": { "background-repeat": "no-repeat" },
|
|
".bg-repeat-x": { "background-repeat": "repeat-x" },
|
|
".bg-repeat-y": { "background-repeat": "repeat-y" },
|
|
".bg-repeat-round": { "background-repeat": "round" },
|
|
".bg-repeat-space": { "background-repeat": "space" },
|
|
});
|
|
},
|
|
backgroundOrigin: ({ addUtilities: i }) => {
|
|
i({
|
|
".bg-origin-border": { "background-origin": "border-box" },
|
|
".bg-origin-padding": { "background-origin": "padding-box" },
|
|
".bg-origin-content": { "background-origin": "content-box" },
|
|
});
|
|
},
|
|
fill: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ fill: (t) => ({ fill: L(t) }) },
|
|
{ values: ie(e("fill")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
stroke: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ stroke: (t) => ({ stroke: L(t) }) },
|
|
{ values: ie(e("stroke")), type: ["color", "url", "any"] },
|
|
);
|
|
},
|
|
strokeWidth: P("strokeWidth", [["stroke", ["stroke-width"]]], {
|
|
type: ["length", "number", "percentage"],
|
|
}),
|
|
objectFit: ({ addUtilities: i }) => {
|
|
i({
|
|
".object-contain": { "object-fit": "contain" },
|
|
".object-cover": { "object-fit": "cover" },
|
|
".object-fill": { "object-fit": "fill" },
|
|
".object-none": { "object-fit": "none" },
|
|
".object-scale-down": { "object-fit": "scale-down" },
|
|
});
|
|
},
|
|
objectPosition: P("objectPosition", [
|
|
["object", ["object-position"]],
|
|
]),
|
|
padding: P("padding", [
|
|
["p", ["padding"]],
|
|
[
|
|
["px", ["padding-left", "padding-right"]],
|
|
["py", ["padding-top", "padding-bottom"]],
|
|
],
|
|
[
|
|
["ps", ["padding-inline-start"]],
|
|
["pe", ["padding-inline-end"]],
|
|
["pt", ["padding-top"]],
|
|
["pr", ["padding-right"]],
|
|
["pb", ["padding-bottom"]],
|
|
["pl", ["padding-left"]],
|
|
],
|
|
]),
|
|
textAlign: ({ addUtilities: i }) => {
|
|
i({
|
|
".text-left": { "text-align": "left" },
|
|
".text-center": { "text-align": "center" },
|
|
".text-right": { "text-align": "right" },
|
|
".text-justify": { "text-align": "justify" },
|
|
".text-start": { "text-align": "start" },
|
|
".text-end": { "text-align": "end" },
|
|
});
|
|
},
|
|
textIndent: P("textIndent", [["indent", ["text-indent"]]], {
|
|
supportsNegativeValues: !0,
|
|
}),
|
|
verticalAlign: ({ addUtilities: i, matchUtilities: e }) => {
|
|
i({
|
|
".align-baseline": { "vertical-align": "baseline" },
|
|
".align-top": { "vertical-align": "top" },
|
|
".align-middle": { "vertical-align": "middle" },
|
|
".align-bottom": { "vertical-align": "bottom" },
|
|
".align-text-top": { "vertical-align": "text-top" },
|
|
".align-text-bottom": { "vertical-align": "text-bottom" },
|
|
".align-sub": { "vertical-align": "sub" },
|
|
".align-super": { "vertical-align": "super" },
|
|
}),
|
|
e({ align: (t) => ({ "vertical-align": t }) });
|
|
},
|
|
fontFamily: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
font: (t) => {
|
|
let [r, n = {}] = Array.isArray(t) && ne(t[1]) ? t : [t],
|
|
{ fontFeatureSettings: a, fontVariationSettings: s } = n;
|
|
return {
|
|
"font-family": Array.isArray(r) ? r.join(", ") : r,
|
|
...(a === void 0 ? {} : { "font-feature-settings": a }),
|
|
...(s === void 0 ? {} : { "font-variation-settings": s }),
|
|
};
|
|
},
|
|
},
|
|
{
|
|
values: e("fontFamily"),
|
|
type: ["lookup", "generic-name", "family-name"],
|
|
},
|
|
);
|
|
},
|
|
fontSize: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
text: (t, { modifier: r }) => {
|
|
let [n, a] = Array.isArray(t) ? t : [t];
|
|
if (r) return { "font-size": n, "line-height": r };
|
|
let {
|
|
lineHeight: s,
|
|
letterSpacing: o,
|
|
fontWeight: u,
|
|
} = ne(a) ? a : { lineHeight: a };
|
|
return {
|
|
"font-size": n,
|
|
...(s === void 0 ? {} : { "line-height": s }),
|
|
...(o === void 0 ? {} : { "letter-spacing": o }),
|
|
...(u === void 0 ? {} : { "font-weight": u }),
|
|
};
|
|
},
|
|
},
|
|
{
|
|
values: e("fontSize"),
|
|
modifiers: e("lineHeight"),
|
|
type: [
|
|
"absolute-size",
|
|
"relative-size",
|
|
"length",
|
|
"percentage",
|
|
],
|
|
},
|
|
);
|
|
},
|
|
fontWeight: P("fontWeight", [["font", ["fontWeight"]]], {
|
|
type: ["lookup", "number", "any"],
|
|
}),
|
|
textTransform: ({ addUtilities: i }) => {
|
|
i({
|
|
".uppercase": { "text-transform": "uppercase" },
|
|
".lowercase": { "text-transform": "lowercase" },
|
|
".capitalize": { "text-transform": "capitalize" },
|
|
".normal-case": { "text-transform": "none" },
|
|
});
|
|
},
|
|
fontStyle: ({ addUtilities: i }) => {
|
|
i({
|
|
".italic": { "font-style": "italic" },
|
|
".not-italic": { "font-style": "normal" },
|
|
});
|
|
},
|
|
fontVariantNumeric: ({ addDefaults: i, addUtilities: e }) => {
|
|
let t =
|
|
"var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)";
|
|
i("font-variant-numeric", {
|
|
"--tw-ordinal": " ",
|
|
"--tw-slashed-zero": " ",
|
|
"--tw-numeric-figure": " ",
|
|
"--tw-numeric-spacing": " ",
|
|
"--tw-numeric-fraction": " ",
|
|
}),
|
|
e({
|
|
".normal-nums": { "font-variant-numeric": "normal" },
|
|
".ordinal": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-ordinal": "ordinal",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".slashed-zero": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-slashed-zero": "slashed-zero",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".lining-nums": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-figure": "lining-nums",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".oldstyle-nums": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-figure": "oldstyle-nums",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".proportional-nums": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-spacing": "proportional-nums",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".tabular-nums": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-spacing": "tabular-nums",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".diagonal-fractions": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-fraction": "diagonal-fractions",
|
|
"font-variant-numeric": t,
|
|
},
|
|
".stacked-fractions": {
|
|
"@defaults font-variant-numeric": {},
|
|
"--tw-numeric-fraction": "stacked-fractions",
|
|
"font-variant-numeric": t,
|
|
},
|
|
});
|
|
},
|
|
lineHeight: P("lineHeight", [["leading", ["lineHeight"]]]),
|
|
letterSpacing: P("letterSpacing", [["tracking", ["letterSpacing"]]], {
|
|
supportsNegativeValues: !0,
|
|
}),
|
|
textColor: ({ matchUtilities: i, theme: e, corePlugins: t }) => {
|
|
i(
|
|
{
|
|
text: (r) =>
|
|
t("textOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "color",
|
|
variable: "--tw-text-opacity",
|
|
})
|
|
: { color: L(r) },
|
|
},
|
|
{ values: ie(e("textColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
textOpacity: P("textOpacity", [
|
|
["text-opacity", ["--tw-text-opacity"]],
|
|
]),
|
|
textDecoration: ({ addUtilities: i }) => {
|
|
i({
|
|
".underline": { "text-decoration-line": "underline" },
|
|
".overline": { "text-decoration-line": "overline" },
|
|
".line-through": { "text-decoration-line": "line-through" },
|
|
".no-underline": { "text-decoration-line": "none" },
|
|
});
|
|
},
|
|
textDecorationColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ decoration: (t) => ({ "text-decoration-color": L(t) }) },
|
|
{ values: ie(e("textDecorationColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
textDecorationStyle: ({ addUtilities: i }) => {
|
|
i({
|
|
".decoration-solid": { "text-decoration-style": "solid" },
|
|
".decoration-double": { "text-decoration-style": "double" },
|
|
".decoration-dotted": { "text-decoration-style": "dotted" },
|
|
".decoration-dashed": { "text-decoration-style": "dashed" },
|
|
".decoration-wavy": { "text-decoration-style": "wavy" },
|
|
});
|
|
},
|
|
textDecorationThickness: P(
|
|
"textDecorationThickness",
|
|
[["decoration", ["text-decoration-thickness"]]],
|
|
{ type: ["length", "percentage"] },
|
|
),
|
|
textUnderlineOffset: P(
|
|
"textUnderlineOffset",
|
|
[["underline-offset", ["text-underline-offset"]]],
|
|
{ type: ["length", "percentage", "any"] },
|
|
),
|
|
fontSmoothing: ({ addUtilities: i }) => {
|
|
i({
|
|
".antialiased": {
|
|
"-webkit-font-smoothing": "antialiased",
|
|
"-moz-osx-font-smoothing": "grayscale",
|
|
},
|
|
".subpixel-antialiased": {
|
|
"-webkit-font-smoothing": "auto",
|
|
"-moz-osx-font-smoothing": "auto",
|
|
},
|
|
});
|
|
},
|
|
placeholderColor: ({
|
|
matchUtilities: i,
|
|
theme: e,
|
|
corePlugins: t,
|
|
}) => {
|
|
i(
|
|
{
|
|
placeholder: (r) =>
|
|
t("placeholderOpacity")
|
|
? {
|
|
"&::placeholder": ae({
|
|
color: r,
|
|
property: "color",
|
|
variable: "--tw-placeholder-opacity",
|
|
}),
|
|
}
|
|
: { "&::placeholder": { color: L(r) } },
|
|
},
|
|
{ values: ie(e("placeholderColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
placeholderOpacity: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"placeholder-opacity": (t) => ({
|
|
["&::placeholder"]: { "--tw-placeholder-opacity": t },
|
|
}),
|
|
},
|
|
{ values: e("placeholderOpacity") },
|
|
);
|
|
},
|
|
caretColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ caret: (t) => ({ "caret-color": L(t) }) },
|
|
{ values: ie(e("caretColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
accentColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ accent: (t) => ({ "accent-color": L(t) }) },
|
|
{ values: ie(e("accentColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
opacity: P("opacity", [["opacity", ["opacity"]]]),
|
|
backgroundBlendMode: ({ addUtilities: i }) => {
|
|
i({
|
|
".bg-blend-normal": { "background-blend-mode": "normal" },
|
|
".bg-blend-multiply": { "background-blend-mode": "multiply" },
|
|
".bg-blend-screen": { "background-blend-mode": "screen" },
|
|
".bg-blend-overlay": { "background-blend-mode": "overlay" },
|
|
".bg-blend-darken": { "background-blend-mode": "darken" },
|
|
".bg-blend-lighten": { "background-blend-mode": "lighten" },
|
|
".bg-blend-color-dodge": {
|
|
"background-blend-mode": "color-dodge",
|
|
},
|
|
".bg-blend-color-burn": { "background-blend-mode": "color-burn" },
|
|
".bg-blend-hard-light": { "background-blend-mode": "hard-light" },
|
|
".bg-blend-soft-light": { "background-blend-mode": "soft-light" },
|
|
".bg-blend-difference": { "background-blend-mode": "difference" },
|
|
".bg-blend-exclusion": { "background-blend-mode": "exclusion" },
|
|
".bg-blend-hue": { "background-blend-mode": "hue" },
|
|
".bg-blend-saturation": { "background-blend-mode": "saturation" },
|
|
".bg-blend-color": { "background-blend-mode": "color" },
|
|
".bg-blend-luminosity": { "background-blend-mode": "luminosity" },
|
|
});
|
|
},
|
|
mixBlendMode: ({ addUtilities: i }) => {
|
|
i({
|
|
".mix-blend-normal": { "mix-blend-mode": "normal" },
|
|
".mix-blend-multiply": { "mix-blend-mode": "multiply" },
|
|
".mix-blend-screen": { "mix-blend-mode": "screen" },
|
|
".mix-blend-overlay": { "mix-blend-mode": "overlay" },
|
|
".mix-blend-darken": { "mix-blend-mode": "darken" },
|
|
".mix-blend-lighten": { "mix-blend-mode": "lighten" },
|
|
".mix-blend-color-dodge": { "mix-blend-mode": "color-dodge" },
|
|
".mix-blend-color-burn": { "mix-blend-mode": "color-burn" },
|
|
".mix-blend-hard-light": { "mix-blend-mode": "hard-light" },
|
|
".mix-blend-soft-light": { "mix-blend-mode": "soft-light" },
|
|
".mix-blend-difference": { "mix-blend-mode": "difference" },
|
|
".mix-blend-exclusion": { "mix-blend-mode": "exclusion" },
|
|
".mix-blend-hue": { "mix-blend-mode": "hue" },
|
|
".mix-blend-saturation": { "mix-blend-mode": "saturation" },
|
|
".mix-blend-color": { "mix-blend-mode": "color" },
|
|
".mix-blend-luminosity": { "mix-blend-mode": "luminosity" },
|
|
".mix-blend-plus-lighter": { "mix-blend-mode": "plus-lighter" },
|
|
});
|
|
},
|
|
boxShadow: (() => {
|
|
let i = Ge("boxShadow"),
|
|
e = [
|
|
"var(--tw-ring-offset-shadow, 0 0 #0000)",
|
|
"var(--tw-ring-shadow, 0 0 #0000)",
|
|
"var(--tw-shadow)",
|
|
].join(", ");
|
|
return function ({ matchUtilities: t, addDefaults: r, theme: n }) {
|
|
r(" box-shadow", {
|
|
"--tw-ring-offset-shadow": "0 0 #0000",
|
|
"--tw-ring-shadow": "0 0 #0000",
|
|
"--tw-shadow": "0 0 #0000",
|
|
"--tw-shadow-colored": "0 0 #0000",
|
|
}),
|
|
t(
|
|
{
|
|
shadow: (a) => {
|
|
a = i(a);
|
|
let s = yi(a);
|
|
for (let o of s)
|
|
!o.valid || (o.color = "var(--tw-shadow-color)");
|
|
return {
|
|
"@defaults box-shadow": {},
|
|
"--tw-shadow": a === "none" ? "0 0 #0000" : a,
|
|
"--tw-shadow-colored":
|
|
a === "none" ? "0 0 #0000" : Iu(s),
|
|
"box-shadow": e,
|
|
};
|
|
},
|
|
},
|
|
{ values: n("boxShadow"), type: ["shadow"] },
|
|
);
|
|
};
|
|
})(),
|
|
boxShadowColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
shadow: (t) => ({
|
|
"--tw-shadow-color": L(t),
|
|
"--tw-shadow": "var(--tw-shadow-colored)",
|
|
}),
|
|
},
|
|
{ values: ie(e("boxShadowColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
outlineStyle: ({ addUtilities: i }) => {
|
|
i({
|
|
".outline-none": {
|
|
outline: "2px solid transparent",
|
|
"outline-offset": "2px",
|
|
},
|
|
".outline": { "outline-style": "solid" },
|
|
".outline-dashed": { "outline-style": "dashed" },
|
|
".outline-dotted": { "outline-style": "dotted" },
|
|
".outline-double": { "outline-style": "double" },
|
|
});
|
|
},
|
|
outlineWidth: P("outlineWidth", [["outline", ["outline-width"]]], {
|
|
type: ["length", "number", "percentage"],
|
|
}),
|
|
outlineOffset: P(
|
|
"outlineOffset",
|
|
[["outline-offset", ["outline-offset"]]],
|
|
{
|
|
type: ["length", "number", "percentage", "any"],
|
|
supportsNegativeValues: !0,
|
|
},
|
|
),
|
|
outlineColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ outline: (t) => ({ "outline-color": L(t) }) },
|
|
{ values: ie(e("outlineColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
ringWidth: ({
|
|
matchUtilities: i,
|
|
addDefaults: e,
|
|
addUtilities: t,
|
|
theme: r,
|
|
config: n,
|
|
}) => {
|
|
let a = (() => {
|
|
if (Z(n(), "respectDefaultRingColorOpacity"))
|
|
return r("ringColor.DEFAULT");
|
|
let s = r("ringOpacity.DEFAULT", "0.5");
|
|
return r("ringColor")?.DEFAULT
|
|
? De(r("ringColor")?.DEFAULT, s, `rgb(147 197 253 / ${s})`)
|
|
: `rgb(147 197 253 / ${s})`;
|
|
})();
|
|
e("ring-width", {
|
|
"--tw-ring-inset": " ",
|
|
"--tw-ring-offset-width": r("ringOffsetWidth.DEFAULT", "0px"),
|
|
"--tw-ring-offset-color": r("ringOffsetColor.DEFAULT", "#fff"),
|
|
"--tw-ring-color": a,
|
|
"--tw-ring-offset-shadow": "0 0 #0000",
|
|
"--tw-ring-shadow": "0 0 #0000",
|
|
"--tw-shadow": "0 0 #0000",
|
|
"--tw-shadow-colored": "0 0 #0000",
|
|
}),
|
|
i(
|
|
{
|
|
ring: (s) => ({
|
|
"@defaults ring-width": {},
|
|
"--tw-ring-offset-shadow":
|
|
"var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)",
|
|
"--tw-ring-shadow": `var(--tw-ring-inset) 0 0 0 calc(${s} + var(--tw-ring-offset-width)) var(--tw-ring-color)`,
|
|
"box-shadow": [
|
|
"var(--tw-ring-offset-shadow)",
|
|
"var(--tw-ring-shadow)",
|
|
"var(--tw-shadow, 0 0 #0000)",
|
|
].join(", "),
|
|
}),
|
|
},
|
|
{ values: r("ringWidth"), type: "length" },
|
|
),
|
|
t({
|
|
".ring-inset": {
|
|
"@defaults ring-width": {},
|
|
"--tw-ring-inset": "inset",
|
|
},
|
|
});
|
|
},
|
|
ringColor: ({ matchUtilities: i, theme: e, corePlugins: t }) => {
|
|
i(
|
|
{
|
|
ring: (r) =>
|
|
t("ringOpacity")
|
|
? ae({
|
|
color: r,
|
|
property: "--tw-ring-color",
|
|
variable: "--tw-ring-opacity",
|
|
})
|
|
: { "--tw-ring-color": L(r) },
|
|
},
|
|
{
|
|
values: Object.fromEntries(
|
|
Object.entries(ie(e("ringColor"))).filter(
|
|
([r]) => r !== "DEFAULT",
|
|
),
|
|
),
|
|
type: ["color", "any"],
|
|
},
|
|
);
|
|
},
|
|
ringOpacity: (i) => {
|
|
let { config: e } = i;
|
|
return P("ringOpacity", [["ring-opacity", ["--tw-ring-opacity"]]], {
|
|
filterDefault: !Z(e(), "respectDefaultRingColorOpacity"),
|
|
})(i);
|
|
},
|
|
ringOffsetWidth: P(
|
|
"ringOffsetWidth",
|
|
[["ring-offset", ["--tw-ring-offset-width"]]],
|
|
{ type: "length" },
|
|
),
|
|
ringOffsetColor: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{ "ring-offset": (t) => ({ "--tw-ring-offset-color": L(t) }) },
|
|
{ values: ie(e("ringOffsetColor")), type: ["color", "any"] },
|
|
);
|
|
},
|
|
blur: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
blur: (t) => ({
|
|
"--tw-blur": `blur(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("blur") },
|
|
);
|
|
},
|
|
brightness: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
brightness: (t) => ({
|
|
"--tw-brightness": `brightness(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("brightness") },
|
|
);
|
|
},
|
|
contrast: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
contrast: (t) => ({
|
|
"--tw-contrast": `contrast(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("contrast") },
|
|
);
|
|
},
|
|
dropShadow: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"drop-shadow": (t) => ({
|
|
"--tw-drop-shadow": Array.isArray(t)
|
|
? t.map((r) => `drop-shadow(${r})`).join(" ")
|
|
: `drop-shadow(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("dropShadow") },
|
|
);
|
|
},
|
|
grayscale: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
grayscale: (t) => ({
|
|
"--tw-grayscale": `grayscale(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("grayscale") },
|
|
);
|
|
},
|
|
hueRotate: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"hue-rotate": (t) => ({
|
|
"--tw-hue-rotate": `hue-rotate(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("hueRotate"), supportsNegativeValues: !0 },
|
|
);
|
|
},
|
|
invert: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
invert: (t) => ({
|
|
"--tw-invert": `invert(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("invert") },
|
|
);
|
|
},
|
|
saturate: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
saturate: (t) => ({
|
|
"--tw-saturate": `saturate(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("saturate") },
|
|
);
|
|
},
|
|
sepia: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
sepia: (t) => ({
|
|
"--tw-sepia": `sepia(${t})`,
|
|
"@defaults filter": {},
|
|
filter: Me,
|
|
}),
|
|
},
|
|
{ values: e("sepia") },
|
|
);
|
|
},
|
|
filter: ({ addDefaults: i, addUtilities: e }) => {
|
|
i("filter", {
|
|
"--tw-blur": " ",
|
|
"--tw-brightness": " ",
|
|
"--tw-contrast": " ",
|
|
"--tw-grayscale": " ",
|
|
"--tw-hue-rotate": " ",
|
|
"--tw-invert": " ",
|
|
"--tw-saturate": " ",
|
|
"--tw-sepia": " ",
|
|
"--tw-drop-shadow": " ",
|
|
}),
|
|
e({
|
|
".filter": { "@defaults filter": {}, filter: Me },
|
|
".filter-none": { filter: "none" },
|
|
});
|
|
},
|
|
backdropBlur: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-blur": (t) => ({
|
|
"--tw-backdrop-blur": `blur(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropBlur") },
|
|
);
|
|
},
|
|
backdropBrightness: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-brightness": (t) => ({
|
|
"--tw-backdrop-brightness": `brightness(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropBrightness") },
|
|
);
|
|
},
|
|
backdropContrast: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-contrast": (t) => ({
|
|
"--tw-backdrop-contrast": `contrast(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropContrast") },
|
|
);
|
|
},
|
|
backdropGrayscale: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-grayscale": (t) => ({
|
|
"--tw-backdrop-grayscale": `grayscale(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropGrayscale") },
|
|
);
|
|
},
|
|
backdropHueRotate: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-hue-rotate": (t) => ({
|
|
"--tw-backdrop-hue-rotate": `hue-rotate(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropHueRotate"), supportsNegativeValues: !0 },
|
|
);
|
|
},
|
|
backdropInvert: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-invert": (t) => ({
|
|
"--tw-backdrop-invert": `invert(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropInvert") },
|
|
);
|
|
},
|
|
backdropOpacity: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-opacity": (t) => ({
|
|
"--tw-backdrop-opacity": `opacity(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropOpacity") },
|
|
);
|
|
},
|
|
backdropSaturate: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-saturate": (t) => ({
|
|
"--tw-backdrop-saturate": `saturate(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropSaturate") },
|
|
);
|
|
},
|
|
backdropSepia: ({ matchUtilities: i, theme: e }) => {
|
|
i(
|
|
{
|
|
"backdrop-sepia": (t) => ({
|
|
"--tw-backdrop-sepia": `sepia(${t})`,
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
}),
|
|
},
|
|
{ values: e("backdropSepia") },
|
|
);
|
|
},
|
|
backdropFilter: ({ addDefaults: i, addUtilities: e }) => {
|
|
i("backdrop-filter", {
|
|
"--tw-backdrop-blur": " ",
|
|
"--tw-backdrop-brightness": " ",
|
|
"--tw-backdrop-contrast": " ",
|
|
"--tw-backdrop-grayscale": " ",
|
|
"--tw-backdrop-hue-rotate": " ",
|
|
"--tw-backdrop-invert": " ",
|
|
"--tw-backdrop-opacity": " ",
|
|
"--tw-backdrop-saturate": " ",
|
|
"--tw-backdrop-sepia": " ",
|
|
}),
|
|
e({
|
|
".backdrop-filter": {
|
|
"@defaults backdrop-filter": {},
|
|
"backdrop-filter": Be,
|
|
},
|
|
".backdrop-filter-none": { "backdrop-filter": "none" },
|
|
});
|
|
},
|
|
transitionProperty: ({ matchUtilities: i, theme: e }) => {
|
|
let t = e("transitionTimingFunction.DEFAULT"),
|
|
r = e("transitionDuration.DEFAULT");
|
|
i(
|
|
{
|
|
transition: (n) => ({
|
|
"transition-property": n,
|
|
...(n === "none"
|
|
? {}
|
|
: {
|
|
"transition-timing-function": t,
|
|
"transition-duration": r,
|
|
}),
|
|
}),
|
|
},
|
|
{ values: e("transitionProperty") },
|
|
);
|
|
},
|
|
transitionDelay: P("transitionDelay", [
|
|
["delay", ["transitionDelay"]],
|
|
]),
|
|
transitionDuration: P(
|
|
"transitionDuration",
|
|
[["duration", ["transitionDuration"]]],
|
|
{ filterDefault: !0 },
|
|
),
|
|
transitionTimingFunction: P(
|
|
"transitionTimingFunction",
|
|
[["ease", ["transitionTimingFunction"]]],
|
|
{ filterDefault: !0 },
|
|
),
|
|
willChange: P("willChange", [["will-change", ["will-change"]]]),
|
|
content: P("content", [
|
|
["content", ["--tw-content", ["content", "var(--tw-content)"]]],
|
|
]),
|
|
forcedColorAdjust: ({ addUtilities: i }) => {
|
|
i({
|
|
".forced-color-adjust-auto": { "forced-color-adjust": "auto" },
|
|
".forced-color-adjust-none": { "forced-color-adjust": "none" },
|
|
});
|
|
},
|
|
});
|
|
});
|
|
function yC(i) {
|
|
if (i === void 0) return !1;
|
|
if (i === "true" || i === "1") return !0;
|
|
if (i === "false" || i === "0") return !1;
|
|
if (i === "*") return !0;
|
|
let e = i.split(",").map((t) => t.split(":")[0]);
|
|
return e.includes("-tailwindcss") ? !1 : !!e.includes("tailwindcss");
|
|
}
|
|
var Pe,
|
|
yd,
|
|
wd,
|
|
gn,
|
|
Qa,
|
|
He,
|
|
Kr,
|
|
ot = C(() => {
|
|
l();
|
|
Ga();
|
|
(Pe =
|
|
typeof h != "undefined"
|
|
? {
|
|
NODE_ENV: "production",
|
|
DEBUG: yC(h.env.DEBUG),
|
|
ENGINE: Ya.tailwindcss.engine,
|
|
}
|
|
: {
|
|
NODE_ENV: "production",
|
|
DEBUG: !1,
|
|
ENGINE: Ya.tailwindcss.engine,
|
|
}),
|
|
(yd = new Map()),
|
|
(wd = new Map()),
|
|
(gn = new Map()),
|
|
(Qa = new Map()),
|
|
(He = new String("*")),
|
|
(Kr = Symbol("__NONE__"));
|
|
});
|
|
function Nt(i) {
|
|
let e = [],
|
|
t = !1;
|
|
for (let r = 0; r < i.length; r++) {
|
|
let n = i[r];
|
|
if (n === ":" && !t && e.length === 0) return !1;
|
|
if (
|
|
(wC.has(n) && i[r - 1] !== "\\" && (t = !t), !t && i[r - 1] !== "\\")
|
|
) {
|
|
if (bd.has(n)) e.push(n);
|
|
else if (vd.has(n)) {
|
|
let a = vd.get(n);
|
|
if (e.length <= 0 || e.pop() !== a) return !1;
|
|
}
|
|
}
|
|
}
|
|
return !(e.length > 0);
|
|
}
|
|
var bd,
|
|
vd,
|
|
wC,
|
|
Ja = C(() => {
|
|
l();
|
|
(bd = new Map([
|
|
["{", "}"],
|
|
["[", "]"],
|
|
["(", ")"],
|
|
])),
|
|
(vd = new Map(Array.from(bd.entries()).map(([i, e]) => [e, i]))),
|
|
(wC = new Set(['"', "'", "`"]));
|
|
});
|
|
function Lt(i) {
|
|
let [e] = xd(i);
|
|
return (
|
|
e.forEach(([t, r]) => t.removeChild(r)),
|
|
i.nodes.push(...e.map(([, t]) => t)),
|
|
i
|
|
);
|
|
}
|
|
function xd(i) {
|
|
let e = [],
|
|
t = null;
|
|
for (let r of i.nodes)
|
|
if (r.type === "combinator")
|
|
(e = e.filter(([, n]) => Ka(n).includes("jumpable"))), (t = null);
|
|
else if (r.type === "pseudo") {
|
|
bC(r)
|
|
? ((t = r), e.push([i, r, null]))
|
|
: t && vC(r, t)
|
|
? e.push([i, r, t])
|
|
: (t = null);
|
|
for (let n of r.nodes ?? []) {
|
|
let [a, s] = xd(n);
|
|
(t = s || t), e.push(...a);
|
|
}
|
|
}
|
|
return [e, t];
|
|
}
|
|
function kd(i) {
|
|
return i.value.startsWith("::") || Xa[i.value] !== void 0;
|
|
}
|
|
function bC(i) {
|
|
return kd(i) && Ka(i).includes("terminal");
|
|
}
|
|
function vC(i, e) {
|
|
return i.type !== "pseudo" || kd(i) ? !1 : Ka(e).includes("actionable");
|
|
}
|
|
function Ka(i) {
|
|
return Xa[i.value] ?? Xa.__default__;
|
|
}
|
|
var Xa,
|
|
yn = C(() => {
|
|
l();
|
|
Xa = {
|
|
"::after": ["terminal", "jumpable"],
|
|
"::backdrop": ["terminal", "jumpable"],
|
|
"::before": ["terminal", "jumpable"],
|
|
"::cue": ["terminal"],
|
|
"::cue-region": ["terminal"],
|
|
"::first-letter": ["terminal", "jumpable"],
|
|
"::first-line": ["terminal", "jumpable"],
|
|
"::grammar-error": ["terminal"],
|
|
"::marker": ["terminal", "jumpable"],
|
|
"::part": ["terminal", "actionable"],
|
|
"::placeholder": ["terminal", "jumpable"],
|
|
"::selection": ["terminal", "jumpable"],
|
|
"::slotted": ["terminal"],
|
|
"::spelling-error": ["terminal"],
|
|
"::target-text": ["terminal"],
|
|
"::file-selector-button": ["terminal", "actionable"],
|
|
"::deep": ["actionable"],
|
|
"::v-deep": ["actionable"],
|
|
"::ng-deep": ["actionable"],
|
|
":after": ["terminal", "jumpable"],
|
|
":before": ["terminal", "jumpable"],
|
|
":first-letter": ["terminal", "jumpable"],
|
|
":first-line": ["terminal", "jumpable"],
|
|
":where": [],
|
|
":is": [],
|
|
":has": [],
|
|
__default__: ["terminal", "actionable"],
|
|
};
|
|
});
|
|
function $t(i, { context: e, candidate: t }) {
|
|
let r = e?.tailwindConfig.prefix ?? "",
|
|
n = i.map((s) => {
|
|
let o = (0, Fe.default)().astSync(s.format);
|
|
return { ...s, ast: s.respectPrefix ? Bt(r, o) : o };
|
|
}),
|
|
a = Fe.default.root({
|
|
nodes: [
|
|
Fe.default.selector({
|
|
nodes: [Fe.default.className({ value: de(t) })],
|
|
}),
|
|
],
|
|
});
|
|
for (let { ast: s } of n)
|
|
([a, s] = kC(a, s)),
|
|
s.walkNesting((o) => o.replaceWith(...a.nodes[0].nodes)),
|
|
(a = s);
|
|
return a;
|
|
}
|
|
function Cd(i) {
|
|
let e = [];
|
|
for (; i.prev() && i.prev().type !== "combinator"; ) i = i.prev();
|
|
for (; i && i.type !== "combinator"; ) e.push(i), (i = i.next());
|
|
return e;
|
|
}
|
|
function xC(i) {
|
|
return (
|
|
i.sort((e, t) =>
|
|
e.type === "tag" && t.type === "class"
|
|
? -1
|
|
: e.type === "class" && t.type === "tag"
|
|
? 1
|
|
: e.type === "class" &&
|
|
t.type === "pseudo" &&
|
|
t.value.startsWith("::")
|
|
? -1
|
|
: e.type === "pseudo" &&
|
|
e.value.startsWith("::") &&
|
|
t.type === "class"
|
|
? 1
|
|
: i.index(e) - i.index(t),
|
|
),
|
|
i
|
|
);
|
|
}
|
|
function eo(i, e) {
|
|
let t = !1;
|
|
i.walk((r) => {
|
|
if (r.type === "class" && r.value === e) return (t = !0), !1;
|
|
}),
|
|
t || i.remove();
|
|
}
|
|
function wn(i, e, { context: t, candidate: r, base: n }) {
|
|
let a = t?.tailwindConfig?.separator ?? ":";
|
|
n = n ?? oe(r, a).pop();
|
|
let s = (0, Fe.default)().astSync(i);
|
|
if (
|
|
(s.walkClasses((f) => {
|
|
f.raws &&
|
|
f.value.includes(n) &&
|
|
(f.raws.value = de((0, Sd.default)(f.raws.value)));
|
|
}),
|
|
s.each((f) => eo(f, n)),
|
|
s.length === 0)
|
|
)
|
|
return null;
|
|
let o = Array.isArray(e) ? $t(e, { context: t, candidate: r }) : e;
|
|
if (o === null) return s.toString();
|
|
let u = Fe.default.comment({ value: "/*__simple__*/" }),
|
|
c = Fe.default.comment({ value: "/*__simple__*/" });
|
|
return (
|
|
s.walkClasses((f) => {
|
|
if (f.value !== n) return;
|
|
let d = f.parent,
|
|
p = o.nodes[0].nodes;
|
|
if (d.nodes.length === 1) {
|
|
f.replaceWith(...p);
|
|
return;
|
|
}
|
|
let m = Cd(f);
|
|
d.insertBefore(m[0], u), d.insertAfter(m[m.length - 1], c);
|
|
for (let x of p) d.insertBefore(m[0], x.clone());
|
|
f.remove(), (m = Cd(u));
|
|
let w = d.index(u);
|
|
d.nodes.splice(
|
|
w,
|
|
m.length,
|
|
...xC(Fe.default.selector({ nodes: m })).nodes,
|
|
),
|
|
u.remove(),
|
|
c.remove();
|
|
}),
|
|
s.walkPseudos((f) => {
|
|
f.value === Za && f.replaceWith(f.nodes);
|
|
}),
|
|
s.each((f) => Lt(f)),
|
|
s.toString()
|
|
);
|
|
}
|
|
function kC(i, e) {
|
|
let t = [];
|
|
return (
|
|
i.walkPseudos((r) => {
|
|
r.value === Za && t.push({ pseudo: r, value: r.nodes[0].toString() });
|
|
}),
|
|
e.walkPseudos((r) => {
|
|
if (r.value !== Za) return;
|
|
let n = r.nodes[0].toString(),
|
|
a = t.find((c) => c.value === n);
|
|
if (!a) return;
|
|
let s = [],
|
|
o = r.next();
|
|
for (; o && o.type !== "combinator"; ) s.push(o), (o = o.next());
|
|
let u = o;
|
|
a.pseudo.parent.insertAfter(
|
|
a.pseudo,
|
|
Fe.default.selector({ nodes: s.map((c) => c.clone()) }),
|
|
),
|
|
r.remove(),
|
|
s.forEach((c) => c.remove()),
|
|
u && u.type === "combinator" && u.remove();
|
|
}),
|
|
[i, e]
|
|
);
|
|
}
|
|
var Fe,
|
|
Sd,
|
|
Za,
|
|
to = C(() => {
|
|
l();
|
|
(Fe = K(Re())), (Sd = K(Yi()));
|
|
Ft();
|
|
un();
|
|
yn();
|
|
St();
|
|
Za = ":merge";
|
|
});
|
|
function bn(i, e) {
|
|
let t = (0, ro.default)().astSync(i);
|
|
return (
|
|
t.each((r) => {
|
|
(r.nodes[0].type === "pseudo" &&
|
|
r.nodes[0].value === ":is" &&
|
|
r.nodes.every((a) => a.type !== "combinator")) ||
|
|
(r.nodes = [ro.default.pseudo({ value: ":is", nodes: [r.clone()] })]),
|
|
Lt(r);
|
|
}),
|
|
`${e} ${t.toString()}`
|
|
);
|
|
}
|
|
var ro,
|
|
io = C(() => {
|
|
l();
|
|
ro = K(Re());
|
|
yn();
|
|
});
|
|
function no(i) {
|
|
return SC.transformSync(i);
|
|
}
|
|
function* CC(i) {
|
|
let e = 1 / 0;
|
|
for (; e >= 0; ) {
|
|
let t,
|
|
r = !1;
|
|
if (e === 1 / 0 && i.endsWith("]")) {
|
|
let s = i.indexOf("[");
|
|
i[s - 1] === "-"
|
|
? (t = s - 1)
|
|
: i[s - 1] === "/"
|
|
? ((t = s - 1), (r = !0))
|
|
: (t = -1);
|
|
} else
|
|
e === 1 / 0 && i.includes("/")
|
|
? ((t = i.lastIndexOf("/")), (r = !0))
|
|
: (t = i.lastIndexOf("-", e));
|
|
if (t < 0) break;
|
|
let n = i.slice(0, t),
|
|
a = i.slice(r ? t : t + 1);
|
|
(e = t - 1), !(n === "" || a === "/") && (yield [n, a]);
|
|
}
|
|
}
|
|
function AC(i, e) {
|
|
if (i.length === 0 || e.tailwindConfig.prefix === "") return i;
|
|
for (let t of i) {
|
|
let [r] = t;
|
|
if (r.options.respectPrefix) {
|
|
let n = V.root({ nodes: [t[1].clone()] }),
|
|
a = t[1].raws.tailwind.classCandidate;
|
|
n.walkRules((s) => {
|
|
let o = a.startsWith("-");
|
|
s.selector = Bt(e.tailwindConfig.prefix, s.selector, o);
|
|
}),
|
|
(t[1] = n.nodes[0]);
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
function _C(i, e) {
|
|
if (i.length === 0) return i;
|
|
let t = [];
|
|
function r(n) {
|
|
return (
|
|
n.parent && n.parent.type === "atrule" && n.parent.name === "keyframes"
|
|
);
|
|
}
|
|
for (let [n, a] of i) {
|
|
let s = V.root({ nodes: [a.clone()] });
|
|
s.walkRules((o) => {
|
|
if (r(o)) return;
|
|
let u = (0, vn.default)().astSync(o.selector);
|
|
u.each((c) => eo(c, e)),
|
|
Uu(u, (c) => (c === e ? `!${c}` : c)),
|
|
(o.selector = u.toString()),
|
|
o.walkDecls((c) => (c.important = !0));
|
|
}),
|
|
t.push([{ ...n, important: !0 }, s.nodes[0]]);
|
|
}
|
|
return t;
|
|
}
|
|
function OC(i, e, t) {
|
|
if (e.length === 0) return e;
|
|
let r = { modifier: null, value: Kr };
|
|
{
|
|
let [n, ...a] = oe(i, "/");
|
|
if (
|
|
(a.length > 1 &&
|
|
((n = n + "/" + a.slice(0, -1).join("/")), (a = a.slice(-1))),
|
|
a.length &&
|
|
!t.variantMap.has(i) &&
|
|
((i = n),
|
|
(r.modifier = a[0]),
|
|
!Z(t.tailwindConfig, "generalizedModifiers")))
|
|
)
|
|
return [];
|
|
}
|
|
if (i.endsWith("]") && !i.startsWith("[")) {
|
|
let n = /(.)(-?)\[(.*)\]/g.exec(i);
|
|
if (n) {
|
|
let [, a, s, o] = n;
|
|
if (a === "@" && s === "-") return [];
|
|
if (a !== "@" && s === "") return [];
|
|
(i = i.replace(`${s}[${o}]`, "")), (r.value = o);
|
|
}
|
|
}
|
|
if (oo(i) && !t.variantMap.has(i)) {
|
|
let n = t.offsets.recordVariant(i),
|
|
a = N(i.slice(1, -1)),
|
|
s = oe(a, ",");
|
|
if (s.length > 1) return [];
|
|
if (!s.every(Cn)) return [];
|
|
let o = s.map((u, c) => [
|
|
t.offsets.applyParallelOffset(n, c),
|
|
Zr(u.trim()),
|
|
]);
|
|
t.variantMap.set(i, o);
|
|
}
|
|
if (t.variantMap.has(i)) {
|
|
let n = oo(i),
|
|
a = t.variantOptions.get(i)?.[Jr] ?? {},
|
|
s = t.variantMap.get(i).slice(),
|
|
o = [],
|
|
u = (() => !(n || a.respectPrefix === !1))();
|
|
for (let [c, f] of e) {
|
|
if (c.layer === "user") continue;
|
|
let d = V.root({ nodes: [f.clone()] });
|
|
for (let [p, m, w] of s) {
|
|
let b = function () {
|
|
x.raws.neededBackup ||
|
|
((x.raws.neededBackup = !0),
|
|
x.walkRules((O) => (O.raws.originalSelector = O.selector)));
|
|
},
|
|
k = function (O) {
|
|
return (
|
|
b(),
|
|
x.each((I) => {
|
|
I.type === "rule" &&
|
|
(I.selectors = I.selectors.map((B) =>
|
|
O({
|
|
get className() {
|
|
return no(B);
|
|
},
|
|
selector: B,
|
|
}),
|
|
));
|
|
}),
|
|
x
|
|
);
|
|
},
|
|
x = (w ?? d).clone(),
|
|
y = [],
|
|
S = m({
|
|
get container() {
|
|
return b(), x;
|
|
},
|
|
separator: t.tailwindConfig.separator,
|
|
modifySelectors: k,
|
|
wrap(O) {
|
|
let I = x.nodes;
|
|
x.removeAll(), O.append(I), x.append(O);
|
|
},
|
|
format(O) {
|
|
y.push({ format: O, respectPrefix: u });
|
|
},
|
|
args: r,
|
|
});
|
|
if (Array.isArray(S)) {
|
|
for (let [O, I] of S.entries())
|
|
s.push([t.offsets.applyParallelOffset(p, O), I, x.clone()]);
|
|
continue;
|
|
}
|
|
if (
|
|
(typeof S == "string" && y.push({ format: S, respectPrefix: u }),
|
|
S === null)
|
|
)
|
|
continue;
|
|
x.raws.neededBackup &&
|
|
(delete x.raws.neededBackup,
|
|
x.walkRules((O) => {
|
|
let I = O.raws.originalSelector;
|
|
if (!I || (delete O.raws.originalSelector, I === O.selector))
|
|
return;
|
|
let B = O.selector,
|
|
q = (0, vn.default)((X) => {
|
|
X.walkClasses((le) => {
|
|
le.value = `${i}${t.tailwindConfig.separator}${le.value}`;
|
|
});
|
|
}).processSync(I);
|
|
y.push({ format: B.replace(q, "&"), respectPrefix: u }),
|
|
(O.selector = I);
|
|
})),
|
|
(x.nodes[0].raws.tailwind = {
|
|
...x.nodes[0].raws.tailwind,
|
|
parentLayer: c.layer,
|
|
});
|
|
let _ = [
|
|
{
|
|
...c,
|
|
sort: t.offsets.applyVariantOffset(
|
|
c.sort,
|
|
p,
|
|
Object.assign(r, t.variantOptions.get(i)),
|
|
),
|
|
collectedFormats: (c.collectedFormats ?? []).concat(y),
|
|
},
|
|
x.nodes[0],
|
|
];
|
|
o.push(_);
|
|
}
|
|
}
|
|
return o;
|
|
}
|
|
return [];
|
|
}
|
|
function so(i, e, t = {}) {
|
|
return !ne(i) && !Array.isArray(i)
|
|
? [[i], t]
|
|
: Array.isArray(i)
|
|
? so(i[0], e, i[1])
|
|
: (e.has(i) || e.set(i, Mt(i)), [e.get(i), t]);
|
|
}
|
|
function TC(i) {
|
|
return EC.test(i);
|
|
}
|
|
function PC(i) {
|
|
if (!i.includes("://")) return !1;
|
|
try {
|
|
let e = new URL(i);
|
|
return e.scheme !== "" && e.host !== "";
|
|
} catch (e) {
|
|
return !1;
|
|
}
|
|
}
|
|
function Ad(i) {
|
|
let e = !0;
|
|
return (
|
|
i.walkDecls((t) => {
|
|
if (!_d(t.prop, t.value)) return (e = !1), !1;
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function _d(i, e) {
|
|
if (PC(`${i}:${e}`)) return !1;
|
|
try {
|
|
return V.parse(`a{${i}:${e}}`).toResult(), !0;
|
|
} catch (t) {
|
|
return !1;
|
|
}
|
|
}
|
|
function DC(i, e) {
|
|
let [, t, r] = i.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/) ?? [];
|
|
if (r === void 0 || !TC(t) || !Nt(r)) return null;
|
|
let n = N(r, { property: t });
|
|
return _d(t, n)
|
|
? [
|
|
[
|
|
{ sort: e.offsets.arbitraryProperty(), layer: "utilities" },
|
|
() => ({ [Va(i)]: { [t]: n } }),
|
|
],
|
|
]
|
|
: null;
|
|
}
|
|
function* IC(i, e) {
|
|
e.candidateRuleMap.has(i) && (yield [e.candidateRuleMap.get(i), "DEFAULT"]),
|
|
yield* (function* (o) {
|
|
o !== null && (yield [o, "DEFAULT"]);
|
|
})(DC(i, e));
|
|
let t = i,
|
|
r = !1,
|
|
n = e.tailwindConfig.prefix,
|
|
a = n.length,
|
|
s = t.startsWith(n) || t.startsWith(`-${n}`);
|
|
t[a] === "-" && s && ((r = !0), (t = n + t.slice(a + 1))),
|
|
r &&
|
|
e.candidateRuleMap.has(t) &&
|
|
(yield [e.candidateRuleMap.get(t), "-DEFAULT"]);
|
|
for (let [o, u] of CC(t))
|
|
e.candidateRuleMap.has(o) &&
|
|
(yield [e.candidateRuleMap.get(o), r ? `-${u}` : u]);
|
|
}
|
|
function qC(i, e) {
|
|
return i === He ? [He] : oe(i, e);
|
|
}
|
|
function* RC(i, e) {
|
|
for (let t of i)
|
|
(t[1].raws.tailwind = {
|
|
...t[1].raws.tailwind,
|
|
classCandidate: e,
|
|
preserveSource: t[0].options?.preserveSource ?? !1,
|
|
}),
|
|
yield t;
|
|
}
|
|
function* ao(i, e) {
|
|
let t = e.tailwindConfig.separator,
|
|
[r, ...n] = qC(i, t).reverse(),
|
|
a = !1;
|
|
r.startsWith("!") && ((a = !0), (r = r.slice(1)));
|
|
for (let s of IC(r, e)) {
|
|
let o = [],
|
|
u = new Map(),
|
|
[c, f] = s,
|
|
d = c.length === 1;
|
|
for (let [p, m] of c) {
|
|
let w = [];
|
|
if (typeof m == "function")
|
|
for (let x of [].concat(m(f, { isOnlyPlugin: d }))) {
|
|
let [y, b] = so(x, e.postCssNodeCache);
|
|
for (let k of y)
|
|
w.push([{ ...p, options: { ...p.options, ...b } }, k]);
|
|
}
|
|
else if (f === "DEFAULT" || f === "-DEFAULT") {
|
|
let x = m,
|
|
[y, b] = so(x, e.postCssNodeCache);
|
|
for (let k of y)
|
|
w.push([{ ...p, options: { ...p.options, ...b } }, k]);
|
|
}
|
|
if (w.length > 0) {
|
|
let x = Array.from(
|
|
fs(p.options?.types ?? [], f, p.options ?? {}, e.tailwindConfig),
|
|
).map(([y, b]) => b);
|
|
x.length > 0 && u.set(w, x), o.push(w);
|
|
}
|
|
}
|
|
if (oo(f)) {
|
|
if (o.length > 1) {
|
|
let w = function (y) {
|
|
return y.length === 1
|
|
? y[0]
|
|
: y.find((b) => {
|
|
let k = u.get(b);
|
|
return b.some(([{ options: S }, _]) =>
|
|
Ad(_)
|
|
? S.types.some(
|
|
({ type: O, preferOnConflict: I }) =>
|
|
k.includes(O) && I,
|
|
)
|
|
: !1,
|
|
);
|
|
});
|
|
},
|
|
[p, m] = o.reduce(
|
|
(y, b) => (
|
|
b.some(([{ options: S }]) =>
|
|
S.types.some(({ type: _ }) => _ === "any"),
|
|
)
|
|
? y[0].push(b)
|
|
: y[1].push(b),
|
|
y
|
|
),
|
|
[[], []],
|
|
),
|
|
x = w(m) ?? w(p);
|
|
if (x) o = [x];
|
|
else {
|
|
let y = o.map((k) => new Set([...(u.get(k) ?? [])]));
|
|
for (let k of y)
|
|
for (let S of k) {
|
|
let _ = !1;
|
|
for (let O of y) k !== O && O.has(S) && (O.delete(S), (_ = !0));
|
|
_ && k.delete(S);
|
|
}
|
|
let b = [];
|
|
for (let [k, S] of y.entries())
|
|
for (let _ of S) {
|
|
let O = o[k]
|
|
.map(([, I]) => I)
|
|
.flat()
|
|
.map((I) =>
|
|
I.toString()
|
|
.split(
|
|
`
|
|
`,
|
|
)
|
|
.slice(1, -1)
|
|
.map((B) => B.trim())
|
|
.map((B) => ` ${B}`).join(`
|
|
`),
|
|
).join(`
|
|
|
|
`);
|
|
b.push(
|
|
` Use \`${i.replace("[", `[${_}:`)}\` for \`${O.trim()}\``,
|
|
);
|
|
break;
|
|
}
|
|
F.warn([
|
|
`The class \`${i}\` is ambiguous and matches multiple utilities.`,
|
|
...b,
|
|
`If this is content and not a class, replace it with \`${i.replace("[", "[").replace("]", "]")}\` to silence this warning.`,
|
|
]);
|
|
continue;
|
|
}
|
|
}
|
|
o = o.map((p) => p.filter((m) => Ad(m[1])));
|
|
}
|
|
(o = o.flat()),
|
|
(o = Array.from(RC(o, r))),
|
|
(o = AC(o, e)),
|
|
a && (o = _C(o, r));
|
|
for (let p of n) o = OC(p, o, e);
|
|
for (let p of o)
|
|
(p[1].raws.tailwind = { ...p[1].raws.tailwind, candidate: i }),
|
|
(p = MC(p, { context: e, candidate: i })),
|
|
p !== null && (yield p);
|
|
}
|
|
}
|
|
function MC(i, { context: e, candidate: t }) {
|
|
if (!i[0].collectedFormats) return i;
|
|
let r = !0,
|
|
n;
|
|
try {
|
|
n = $t(i[0].collectedFormats, { context: e, candidate: t });
|
|
} catch {
|
|
return null;
|
|
}
|
|
let a = V.root({ nodes: [i[1].clone()] });
|
|
return (
|
|
a.walkRules((s) => {
|
|
if (!xn(s))
|
|
try {
|
|
let o = wn(s.selector, n, { candidate: t, context: e });
|
|
if (o === null) {
|
|
s.remove();
|
|
return;
|
|
}
|
|
s.selector = o;
|
|
} catch {
|
|
return (r = !1), !1;
|
|
}
|
|
}),
|
|
!r || a.nodes.length === 0 ? null : ((i[1] = a.nodes[0]), i)
|
|
);
|
|
}
|
|
function xn(i) {
|
|
return (
|
|
i.parent && i.parent.type === "atrule" && i.parent.name === "keyframes"
|
|
);
|
|
}
|
|
function BC(i) {
|
|
if (i === !0)
|
|
return (e) => {
|
|
xn(e) ||
|
|
e.walkDecls((t) => {
|
|
t.parent.type === "rule" && !xn(t.parent) && (t.important = !0);
|
|
});
|
|
};
|
|
if (typeof i == "string")
|
|
return (e) => {
|
|
xn(e) || (e.selectors = e.selectors.map((t) => bn(t, i)));
|
|
};
|
|
}
|
|
function kn(i, e, t = !1) {
|
|
let r = [],
|
|
n = BC(e.tailwindConfig.important);
|
|
for (let a of i) {
|
|
if (e.notClassCache.has(a)) continue;
|
|
if (e.candidateRuleCache.has(a)) {
|
|
r = r.concat(Array.from(e.candidateRuleCache.get(a)));
|
|
continue;
|
|
}
|
|
let s = Array.from(ao(a, e));
|
|
if (s.length === 0) {
|
|
e.notClassCache.add(a);
|
|
continue;
|
|
}
|
|
e.classCache.set(a, s);
|
|
let o = e.candidateRuleCache.get(a) ?? new Set();
|
|
e.candidateRuleCache.set(a, o);
|
|
for (let u of s) {
|
|
let [{ sort: c, options: f }, d] = u;
|
|
if (f.respectImportant && n) {
|
|
let m = V.root({ nodes: [d.clone()] });
|
|
m.walkRules(n), (d = m.nodes[0]);
|
|
}
|
|
let p = [c, t ? d.clone() : d];
|
|
o.add(p), e.ruleCache.add(p), r.push(p);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
function oo(i) {
|
|
return i.startsWith("[") && i.endsWith("]");
|
|
}
|
|
var vn,
|
|
SC,
|
|
EC,
|
|
Sn = C(() => {
|
|
l();
|
|
nt();
|
|
vn = K(Re());
|
|
za();
|
|
kt();
|
|
un();
|
|
cr();
|
|
Oe();
|
|
ot();
|
|
to();
|
|
Ua();
|
|
fr();
|
|
Xr();
|
|
Ja();
|
|
St();
|
|
ze();
|
|
io();
|
|
SC = (0, vn.default)(
|
|
(i) => i.first.filter(({ type: e }) => e === "class").pop().value,
|
|
);
|
|
EC = /^[a-z_-]/;
|
|
});
|
|
var Od,
|
|
Ed = C(() => {
|
|
l();
|
|
Od = {};
|
|
});
|
|
function FC(i) {
|
|
try {
|
|
return Od.createHash("md5").update(i, "utf-8").digest("binary");
|
|
} catch (e) {
|
|
return "";
|
|
}
|
|
}
|
|
function Td(i, e) {
|
|
let t = e.toString();
|
|
if (!t.includes("@tailwind")) return !1;
|
|
let r = Qa.get(i),
|
|
n = FC(t),
|
|
a = r !== n;
|
|
return Qa.set(i, n), a;
|
|
}
|
|
var Pd = C(() => {
|
|
l();
|
|
Ed();
|
|
ot();
|
|
});
|
|
function An(i) {
|
|
return (i > 0n) - (i < 0n);
|
|
}
|
|
var Dd = C(() => {
|
|
l();
|
|
});
|
|
function Id(i, e) {
|
|
let t = 0n,
|
|
r = 0n;
|
|
for (let [n, a] of e) i & n && ((t = t | n), (r = r | a));
|
|
return (i & ~t) | r;
|
|
}
|
|
var qd = C(() => {
|
|
l();
|
|
});
|
|
function Rd(i) {
|
|
let e = null;
|
|
for (let t of i) (e = e ?? t), (e = e > t ? e : t);
|
|
return e;
|
|
}
|
|
function NC(i, e) {
|
|
let t = i.length,
|
|
r = e.length,
|
|
n = t < r ? t : r;
|
|
for (let a = 0; a < n; a++) {
|
|
let s = i.charCodeAt(a) - e.charCodeAt(a);
|
|
if (s !== 0) return s;
|
|
}
|
|
return t - r;
|
|
}
|
|
var lo,
|
|
Md = C(() => {
|
|
l();
|
|
Dd();
|
|
qd();
|
|
lo = class {
|
|
constructor() {
|
|
(this.offsets = {
|
|
defaults: 0n,
|
|
base: 0n,
|
|
components: 0n,
|
|
utilities: 0n,
|
|
variants: 0n,
|
|
user: 0n,
|
|
}),
|
|
(this.layerPositions = {
|
|
defaults: 0n,
|
|
base: 1n,
|
|
components: 2n,
|
|
utilities: 3n,
|
|
user: 4n,
|
|
variants: 5n,
|
|
}),
|
|
(this.reservedVariantBits = 0n),
|
|
(this.variantOffsets = new Map());
|
|
}
|
|
create(e) {
|
|
return {
|
|
layer: e,
|
|
parentLayer: e,
|
|
arbitrary: 0n,
|
|
variants: 0n,
|
|
parallelIndex: 0n,
|
|
index: this.offsets[e]++,
|
|
options: [],
|
|
};
|
|
}
|
|
arbitraryProperty() {
|
|
return { ...this.create("utilities"), arbitrary: 1n };
|
|
}
|
|
forVariant(e, t = 0) {
|
|
let r = this.variantOffsets.get(e);
|
|
if (r === void 0)
|
|
throw new Error(`Cannot find offset for unknown variant ${e}`);
|
|
return { ...this.create("variants"), variants: r << BigInt(t) };
|
|
}
|
|
applyVariantOffset(e, t, r) {
|
|
return (
|
|
(r.variant = t.variants),
|
|
{
|
|
...e,
|
|
layer: "variants",
|
|
parentLayer: e.layer === "variants" ? e.parentLayer : e.layer,
|
|
variants: e.variants | t.variants,
|
|
options: r.sort ? [].concat(r, e.options) : e.options,
|
|
parallelIndex: Rd([e.parallelIndex, t.parallelIndex]),
|
|
}
|
|
);
|
|
}
|
|
applyParallelOffset(e, t) {
|
|
return { ...e, parallelIndex: BigInt(t) };
|
|
}
|
|
recordVariants(e, t) {
|
|
for (let r of e) this.recordVariant(r, t(r));
|
|
}
|
|
recordVariant(e, t = 1) {
|
|
return (
|
|
this.variantOffsets.set(e, 1n << this.reservedVariantBits),
|
|
(this.reservedVariantBits += BigInt(t)),
|
|
{ ...this.create("variants"), variants: this.variantOffsets.get(e) }
|
|
);
|
|
}
|
|
compare(e, t) {
|
|
if (e.layer !== t.layer)
|
|
return this.layerPositions[e.layer] - this.layerPositions[t.layer];
|
|
if (e.parentLayer !== t.parentLayer)
|
|
return (
|
|
this.layerPositions[e.parentLayer] -
|
|
this.layerPositions[t.parentLayer]
|
|
);
|
|
for (let r of e.options)
|
|
for (let n of t.options) {
|
|
if (r.id !== n.id || !r.sort || !n.sort) continue;
|
|
let a = Rd([r.variant, n.variant]) ?? 0n,
|
|
s = ~(a | (a - 1n)),
|
|
o = e.variants & s,
|
|
u = t.variants & s;
|
|
if (o !== u) continue;
|
|
let c = r.sort(
|
|
{ value: r.value, modifier: r.modifier },
|
|
{ value: n.value, modifier: n.modifier },
|
|
);
|
|
if (c !== 0) return c;
|
|
}
|
|
return e.variants !== t.variants
|
|
? e.variants - t.variants
|
|
: e.parallelIndex !== t.parallelIndex
|
|
? e.parallelIndex - t.parallelIndex
|
|
: e.arbitrary !== t.arbitrary
|
|
? e.arbitrary - t.arbitrary
|
|
: e.index - t.index;
|
|
}
|
|
recalculateVariantOffsets() {
|
|
let e = Array.from(this.variantOffsets.entries())
|
|
.filter(([n]) => n.startsWith("["))
|
|
.sort(([n], [a]) => NC(n, a)),
|
|
t = e.map(([, n]) => n).sort((n, a) => An(n - a));
|
|
return e.map(([, n], a) => [n, t[a]]).filter(([n, a]) => n !== a);
|
|
}
|
|
remapArbitraryVariantOffsets(e) {
|
|
let t = this.recalculateVariantOffsets();
|
|
return t.length === 0
|
|
? e
|
|
: e.map((r) => {
|
|
let [n, a] = r;
|
|
return (n = { ...n, variants: Id(n.variants, t) }), [n, a];
|
|
});
|
|
}
|
|
sort(e) {
|
|
return (
|
|
(e = this.remapArbitraryVariantOffsets(e)),
|
|
e.sort(([t], [r]) => An(this.compare(t, r)))
|
|
);
|
|
}
|
|
};
|
|
});
|
|
function po(i, e) {
|
|
let t = i.tailwindConfig.prefix;
|
|
return typeof t == "function" ? t(e) : t + e;
|
|
}
|
|
function Fd({ type: i = "any", ...e }) {
|
|
let t = [].concat(i);
|
|
return {
|
|
...e,
|
|
types: t.map((r) =>
|
|
Array.isArray(r)
|
|
? { type: r[0], ...r[1] }
|
|
: { type: r, preferOnConflict: !1 },
|
|
),
|
|
};
|
|
}
|
|
function LC(i) {
|
|
let e = [],
|
|
t = "",
|
|
r = 0;
|
|
for (let n = 0; n < i.length; n++) {
|
|
let a = i[n];
|
|
if (a === "\\") t += "\\" + i[++n];
|
|
else if (a === "{") ++r, e.push(t.trim()), (t = "");
|
|
else if (a === "}") {
|
|
if (--r < 0) throw new Error("Your { and } are unbalanced.");
|
|
e.push(t.trim()), (t = "");
|
|
} else t += a;
|
|
}
|
|
return t.length > 0 && e.push(t.trim()), (e = e.filter((n) => n !== "")), e;
|
|
}
|
|
function $C(i, e, { before: t = [] } = {}) {
|
|
if (((t = [].concat(t)), t.length <= 0)) {
|
|
i.push(e);
|
|
return;
|
|
}
|
|
let r = i.length - 1;
|
|
for (let n of t) {
|
|
let a = i.indexOf(n);
|
|
a !== -1 && (r = Math.min(r, a));
|
|
}
|
|
i.splice(r, 0, e);
|
|
}
|
|
function Nd(i) {
|
|
return Array.isArray(i)
|
|
? i.flatMap((e) => (!Array.isArray(e) && !ne(e) ? e : Mt(e)))
|
|
: Nd([i]);
|
|
}
|
|
function jC(i, e) {
|
|
return (0, uo.default)((r) => {
|
|
let n = [];
|
|
return (
|
|
e && e(r),
|
|
r.walkClasses((a) => {
|
|
n.push(a.value);
|
|
}),
|
|
n
|
|
);
|
|
}).transformSync(i);
|
|
}
|
|
function zC(i) {
|
|
i.walkPseudos((e) => {
|
|
e.value === ":not" && e.remove();
|
|
});
|
|
}
|
|
function VC(i, e = { containsNonOnDemandable: !1 }, t = 0) {
|
|
let r = [],
|
|
n = [];
|
|
i.type === "rule"
|
|
? n.push(...i.selectors)
|
|
: i.type === "atrule" && i.walkRules((a) => n.push(...a.selectors));
|
|
for (let a of n) {
|
|
let s = jC(a, zC);
|
|
s.length === 0 && (e.containsNonOnDemandable = !0);
|
|
for (let o of s) r.push(o);
|
|
}
|
|
return t === 0 ? [e.containsNonOnDemandable || r.length === 0, r] : r;
|
|
}
|
|
function _n(i) {
|
|
return Nd(i).flatMap((e) => {
|
|
let t = new Map(),
|
|
[r, n] = VC(e);
|
|
return (
|
|
r && n.unshift(He),
|
|
n.map((a) => (t.has(e) || t.set(e, e), [a, t.get(e)]))
|
|
);
|
|
});
|
|
}
|
|
function Cn(i) {
|
|
return i.startsWith("@") || i.includes("&");
|
|
}
|
|
function Zr(i) {
|
|
i = i
|
|
.replace(/\n+/g, "")
|
|
.replace(/\s{1,}/g, " ")
|
|
.trim();
|
|
let e = LC(i)
|
|
.map((t) => {
|
|
if (!t.startsWith("@")) return ({ format: a }) => a(t);
|
|
let [, r, n] = /@(\S*)( .+|[({].*)?/g.exec(t);
|
|
return ({ wrap: a }) =>
|
|
a(V.atRule({ name: r, params: n?.trim() ?? "" }));
|
|
})
|
|
.reverse();
|
|
return (t) => {
|
|
for (let r of e) r(t);
|
|
};
|
|
}
|
|
function UC(
|
|
i,
|
|
e,
|
|
{ variantList: t, variantMap: r, offsets: n, classList: a },
|
|
) {
|
|
function s(p, m) {
|
|
return p ? (0, Bd.default)(i, p, m) : i;
|
|
}
|
|
function o(p) {
|
|
return Bt(i.prefix, p);
|
|
}
|
|
function u(p, m) {
|
|
return p === He ? He : m.respectPrefix ? e.tailwindConfig.prefix + p : p;
|
|
}
|
|
function c(p, m, w = {}) {
|
|
let x = Ke(p),
|
|
y = s(["theme", ...x], m);
|
|
return Ge(x[0])(y, w);
|
|
}
|
|
let f = 0,
|
|
d = {
|
|
postcss: V,
|
|
prefix: o,
|
|
e: de,
|
|
config: s,
|
|
theme: c,
|
|
corePlugins: (p) =>
|
|
Array.isArray(i.corePlugins)
|
|
? i.corePlugins.includes(p)
|
|
: s(["corePlugins", p], !0),
|
|
variants: () => [],
|
|
addBase(p) {
|
|
for (let [m, w] of _n(p)) {
|
|
let x = u(m, {}),
|
|
y = n.create("base");
|
|
e.candidateRuleMap.has(x) || e.candidateRuleMap.set(x, []),
|
|
e.candidateRuleMap.get(x).push([{ sort: y, layer: "base" }, w]);
|
|
}
|
|
},
|
|
addDefaults(p, m) {
|
|
let w = { [`@defaults ${p}`]: m };
|
|
for (let [x, y] of _n(w)) {
|
|
let b = u(x, {});
|
|
e.candidateRuleMap.has(b) || e.candidateRuleMap.set(b, []),
|
|
e.candidateRuleMap
|
|
.get(b)
|
|
.push([{ sort: n.create("defaults"), layer: "defaults" }, y]);
|
|
}
|
|
},
|
|
addComponents(p, m) {
|
|
m = Object.assign(
|
|
{},
|
|
{ preserveSource: !1, respectPrefix: !0, respectImportant: !1 },
|
|
Array.isArray(m) ? {} : m,
|
|
);
|
|
for (let [x, y] of _n(p)) {
|
|
let b = u(x, m);
|
|
a.add(b),
|
|
e.candidateRuleMap.has(b) || e.candidateRuleMap.set(b, []),
|
|
e.candidateRuleMap
|
|
.get(b)
|
|
.push([
|
|
{
|
|
sort: n.create("components"),
|
|
layer: "components",
|
|
options: m,
|
|
},
|
|
y,
|
|
]);
|
|
}
|
|
},
|
|
addUtilities(p, m) {
|
|
m = Object.assign(
|
|
{},
|
|
{ preserveSource: !1, respectPrefix: !0, respectImportant: !0 },
|
|
Array.isArray(m) ? {} : m,
|
|
);
|
|
for (let [x, y] of _n(p)) {
|
|
let b = u(x, m);
|
|
a.add(b),
|
|
e.candidateRuleMap.has(b) || e.candidateRuleMap.set(b, []),
|
|
e.candidateRuleMap
|
|
.get(b)
|
|
.push([
|
|
{
|
|
sort: n.create("utilities"),
|
|
layer: "utilities",
|
|
options: m,
|
|
},
|
|
y,
|
|
]);
|
|
}
|
|
},
|
|
matchUtilities: function (p, m) {
|
|
m = Fd({
|
|
...{ respectPrefix: !0, respectImportant: !0, modifiers: !1 },
|
|
...m,
|
|
});
|
|
let x = n.create("utilities");
|
|
for (let y in p) {
|
|
let S = function (O, { isOnlyPlugin: I }) {
|
|
let [B, q, X] = us(m.types, O, m, i);
|
|
if (B === void 0) return [];
|
|
if (!m.types.some(({ type: j }) => j === q))
|
|
if (I)
|
|
F.warn([
|
|
`Unnecessary typehint \`${q}\` in \`${y}-${O}\`.`,
|
|
`You can safely update it to \`${y}-${O.replace(q + ":", "")}\`.`,
|
|
]);
|
|
else return [];
|
|
if (!Nt(B)) return [];
|
|
let le = {
|
|
get modifier() {
|
|
return (
|
|
m.modifiers ||
|
|
F.warn(`modifier-used-without-options-for-${y}`, [
|
|
"Your plugin must set `modifiers: true` in its options to support modifiers.",
|
|
]),
|
|
X
|
|
);
|
|
},
|
|
},
|
|
ce = Z(i, "generalizedModifiers");
|
|
return []
|
|
.concat(ce ? k(B, le) : k(B))
|
|
.filter(Boolean)
|
|
.map((j) => ({ [fn(y, O)]: j }));
|
|
},
|
|
b = u(y, m),
|
|
k = p[y];
|
|
a.add([b, m]);
|
|
let _ = [{ sort: x, layer: "utilities", options: m }, S];
|
|
e.candidateRuleMap.has(b) || e.candidateRuleMap.set(b, []),
|
|
e.candidateRuleMap.get(b).push(_);
|
|
}
|
|
},
|
|
matchComponents: function (p, m) {
|
|
m = Fd({
|
|
...{ respectPrefix: !0, respectImportant: !1, modifiers: !1 },
|
|
...m,
|
|
});
|
|
let x = n.create("components");
|
|
for (let y in p) {
|
|
let S = function (O, { isOnlyPlugin: I }) {
|
|
let [B, q, X] = us(m.types, O, m, i);
|
|
if (B === void 0) return [];
|
|
if (!m.types.some(({ type: j }) => j === q))
|
|
if (I)
|
|
F.warn([
|
|
`Unnecessary typehint \`${q}\` in \`${y}-${O}\`.`,
|
|
`You can safely update it to \`${y}-${O.replace(q + ":", "")}\`.`,
|
|
]);
|
|
else return [];
|
|
if (!Nt(B)) return [];
|
|
let le = {
|
|
get modifier() {
|
|
return (
|
|
m.modifiers ||
|
|
F.warn(`modifier-used-without-options-for-${y}`, [
|
|
"Your plugin must set `modifiers: true` in its options to support modifiers.",
|
|
]),
|
|
X
|
|
);
|
|
},
|
|
},
|
|
ce = Z(i, "generalizedModifiers");
|
|
return []
|
|
.concat(ce ? k(B, le) : k(B))
|
|
.filter(Boolean)
|
|
.map((j) => ({ [fn(y, O)]: j }));
|
|
},
|
|
b = u(y, m),
|
|
k = p[y];
|
|
a.add([b, m]);
|
|
let _ = [{ sort: x, layer: "components", options: m }, S];
|
|
e.candidateRuleMap.has(b) || e.candidateRuleMap.set(b, []),
|
|
e.candidateRuleMap.get(b).push(_);
|
|
}
|
|
},
|
|
addVariant(p, m, w = {}) {
|
|
(m = [].concat(m).map((x) => {
|
|
if (typeof x != "string")
|
|
return (y = {}) => {
|
|
let {
|
|
args: b,
|
|
modifySelectors: k,
|
|
container: S,
|
|
separator: _,
|
|
wrap: O,
|
|
format: I,
|
|
} = y,
|
|
B = x(
|
|
Object.assign(
|
|
{ modifySelectors: k, container: S, separator: _ },
|
|
w.type === fo.MatchVariant && {
|
|
args: b,
|
|
wrap: O,
|
|
format: I,
|
|
},
|
|
),
|
|
);
|
|
if (typeof B == "string" && !Cn(B))
|
|
throw new Error(
|
|
`Your custom variant \`${p}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`,
|
|
);
|
|
return Array.isArray(B)
|
|
? B.filter((q) => typeof q == "string").map((q) => Zr(q))
|
|
: B && typeof B == "string" && Zr(B)(y);
|
|
};
|
|
if (!Cn(x))
|
|
throw new Error(
|
|
`Your custom variant \`${p}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`,
|
|
);
|
|
return Zr(x);
|
|
})),
|
|
$C(t, p, w),
|
|
r.set(p, m),
|
|
e.variantOptions.set(p, w);
|
|
},
|
|
matchVariant(p, m, w) {
|
|
let x = w?.id ?? ++f,
|
|
y = p === "@",
|
|
b = Z(i, "generalizedModifiers");
|
|
for (let [S, _] of Object.entries(w?.values ?? {}))
|
|
S !== "DEFAULT" &&
|
|
d.addVariant(
|
|
y ? `${p}${S}` : `${p}-${S}`,
|
|
({ args: O, container: I }) =>
|
|
m(
|
|
_,
|
|
b
|
|
? { modifier: O?.modifier, container: I }
|
|
: { container: I },
|
|
),
|
|
{
|
|
...w,
|
|
value: _,
|
|
id: x,
|
|
type: fo.MatchVariant,
|
|
variantInfo: co.Base,
|
|
},
|
|
);
|
|
let k = "DEFAULT" in (w?.values ?? {});
|
|
d.addVariant(
|
|
p,
|
|
({ args: S, container: _ }) =>
|
|
S?.value === Kr && !k
|
|
? null
|
|
: m(
|
|
S?.value === Kr
|
|
? w.values.DEFAULT
|
|
: S?.value ?? (typeof S == "string" ? S : ""),
|
|
b
|
|
? { modifier: S?.modifier, container: _ }
|
|
: { container: _ },
|
|
),
|
|
{ ...w, id: x, type: fo.MatchVariant, variantInfo: co.Dynamic },
|
|
);
|
|
},
|
|
};
|
|
return d;
|
|
}
|
|
function On(i) {
|
|
return ho.has(i) || ho.set(i, new Map()), ho.get(i);
|
|
}
|
|
function Ld(i, e) {
|
|
let t = !1,
|
|
r = new Map();
|
|
for (let n of i) {
|
|
if (!n) continue;
|
|
let a = gs.parse(n),
|
|
s = a.hash ? a.href.replace(a.hash, "") : a.href;
|
|
s = a.search ? s.replace(a.search, "") : s;
|
|
let o = re.statSync(decodeURIComponent(s), {
|
|
throwIfNoEntry: !1,
|
|
})?.mtimeMs;
|
|
!o || ((!e.has(n) || o > e.get(n)) && (t = !0), r.set(n, o));
|
|
}
|
|
return [t, r];
|
|
}
|
|
function $d(i) {
|
|
i.walkAtRules((e) => {
|
|
["responsive", "variants"].includes(e.name) &&
|
|
($d(e), e.before(e.nodes), e.remove());
|
|
});
|
|
}
|
|
function WC(i) {
|
|
let e = [];
|
|
return (
|
|
i.each((t) => {
|
|
t.type === "atrule" &&
|
|
["responsive", "variants"].includes(t.name) &&
|
|
((t.name = "layer"), (t.params = "utilities"));
|
|
}),
|
|
i.walkAtRules("layer", (t) => {
|
|
if (($d(t), t.params === "base")) {
|
|
for (let r of t.nodes)
|
|
e.push(function ({ addBase: n }) {
|
|
n(r, { respectPrefix: !1 });
|
|
});
|
|
t.remove();
|
|
} else if (t.params === "components") {
|
|
for (let r of t.nodes)
|
|
e.push(function ({ addComponents: n }) {
|
|
n(r, { respectPrefix: !1, preserveSource: !0 });
|
|
});
|
|
t.remove();
|
|
} else if (t.params === "utilities") {
|
|
for (let r of t.nodes)
|
|
e.push(function ({ addUtilities: n }) {
|
|
n(r, { respectPrefix: !1, preserveSource: !0 });
|
|
});
|
|
t.remove();
|
|
}
|
|
}),
|
|
e
|
|
);
|
|
}
|
|
function GC(i, e) {
|
|
let t = Object.entries({ ...Y, ...md })
|
|
.map(([u, c]) => (i.tailwindConfig.corePlugins.includes(u) ? c : null))
|
|
.filter(Boolean),
|
|
r = i.tailwindConfig.plugins.map(
|
|
(u) => (
|
|
u.__isOptionsFunction && (u = u()),
|
|
typeof u == "function" ? u : u.handler
|
|
),
|
|
),
|
|
n = WC(e),
|
|
a = [
|
|
Y.childVariant,
|
|
Y.pseudoElementVariants,
|
|
Y.pseudoClassVariants,
|
|
Y.hasVariants,
|
|
Y.ariaVariants,
|
|
Y.dataVariants,
|
|
],
|
|
s = [
|
|
Y.supportsVariants,
|
|
Y.reducedMotionVariants,
|
|
Y.prefersContrastVariants,
|
|
Y.screenVariants,
|
|
Y.orientationVariants,
|
|
Y.directionVariants,
|
|
Y.darkVariants,
|
|
Y.forcedColorsVariants,
|
|
Y.printVariant,
|
|
];
|
|
return (
|
|
(i.tailwindConfig.darkMode === "class" ||
|
|
(Array.isArray(i.tailwindConfig.darkMode) &&
|
|
i.tailwindConfig.darkMode[0] === "class")) &&
|
|
(s = [
|
|
Y.supportsVariants,
|
|
Y.reducedMotionVariants,
|
|
Y.prefersContrastVariants,
|
|
Y.darkVariants,
|
|
Y.screenVariants,
|
|
Y.orientationVariants,
|
|
Y.directionVariants,
|
|
Y.forcedColorsVariants,
|
|
Y.printVariant,
|
|
]),
|
|
[...t, ...a, ...r, ...s, ...n]
|
|
);
|
|
}
|
|
function HC(i, e) {
|
|
let t = [],
|
|
r = new Map();
|
|
e.variantMap = r;
|
|
let n = new lo();
|
|
e.offsets = n;
|
|
let a = new Set(),
|
|
s = UC(e.tailwindConfig, e, {
|
|
variantList: t,
|
|
variantMap: r,
|
|
offsets: n,
|
|
classList: a,
|
|
});
|
|
for (let f of i)
|
|
if (Array.isArray(f)) for (let d of f) d(s);
|
|
else f?.(s);
|
|
n.recordVariants(t, (f) => r.get(f).length);
|
|
for (let [f, d] of r.entries())
|
|
e.variantMap.set(
|
|
f,
|
|
d.map((p, m) => [n.forVariant(f, m), p]),
|
|
);
|
|
let o = (e.tailwindConfig.safelist ?? []).filter(Boolean);
|
|
if (o.length > 0) {
|
|
let f = [];
|
|
for (let d of o) {
|
|
if (typeof d == "string") {
|
|
e.changedContent.push({ content: d, extension: "html" });
|
|
continue;
|
|
}
|
|
if (d instanceof RegExp) {
|
|
F.warn("root-regex", [
|
|
"Regular expressions in `safelist` work differently in Tailwind CSS v3.0.",
|
|
"Update your `safelist` configuration to eliminate this warning.",
|
|
"https://tailwindcss.com/docs/content-configuration#safelisting-classes",
|
|
]);
|
|
continue;
|
|
}
|
|
f.push(d);
|
|
}
|
|
if (f.length > 0) {
|
|
let d = new Map(),
|
|
p = e.tailwindConfig.prefix.length,
|
|
m = f.some((w) => w.pattern.source.includes("!"));
|
|
for (let w of a) {
|
|
let x = Array.isArray(w)
|
|
? (() => {
|
|
let [y, b] = w,
|
|
S = Object.keys(b?.values ?? {}).map((_) => Qr(y, _));
|
|
return (
|
|
b?.supportsNegativeValues &&
|
|
((S = [...S, ...S.map((_) => "-" + _)]),
|
|
(S = [
|
|
...S,
|
|
...S.map((_) => _.slice(0, p) + "-" + _.slice(p)),
|
|
])),
|
|
b.types.some(({ type: _ }) => _ === "color") &&
|
|
(S = [
|
|
...S,
|
|
...S.flatMap((_) =>
|
|
Object.keys(e.tailwindConfig.theme.opacity).map(
|
|
(O) => `${_}/${O}`,
|
|
),
|
|
),
|
|
]),
|
|
m &&
|
|
b?.respectImportant &&
|
|
(S = [...S, ...S.map((_) => "!" + _)]),
|
|
S
|
|
);
|
|
})()
|
|
: [w];
|
|
for (let y of x)
|
|
for (let { pattern: b, variants: k = [] } of f)
|
|
if (((b.lastIndex = 0), d.has(b) || d.set(b, 0), !!b.test(y))) {
|
|
d.set(b, d.get(b) + 1),
|
|
e.changedContent.push({ content: y, extension: "html" });
|
|
for (let S of k)
|
|
e.changedContent.push({
|
|
content: S + e.tailwindConfig.separator + y,
|
|
extension: "html",
|
|
});
|
|
}
|
|
}
|
|
for (let [w, x] of d.entries())
|
|
x === 0 &&
|
|
F.warn([
|
|
`The safelist pattern \`${w}\` doesn't match any Tailwind CSS classes.`,
|
|
"Fix this pattern or remove it from your `safelist` configuration.",
|
|
"https://tailwindcss.com/docs/content-configuration#safelisting-classes",
|
|
]);
|
|
}
|
|
}
|
|
let u = [].concat(e.tailwindConfig.darkMode ?? "media")[1] ?? "dark",
|
|
c = [po(e, u), po(e, "group"), po(e, "peer")];
|
|
(e.getClassOrder = function (d) {
|
|
let p = [...d].sort((y, b) => (y === b ? 0 : y < b ? -1 : 1)),
|
|
m = new Map(p.map((y) => [y, null])),
|
|
w = kn(new Set(p), e, !0);
|
|
w = e.offsets.sort(w);
|
|
let x = BigInt(c.length);
|
|
for (let [, y] of w) {
|
|
let b = y.raws.tailwind.candidate;
|
|
m.set(b, m.get(b) ?? x++);
|
|
}
|
|
return d.map((y) => {
|
|
let b = m.get(y) ?? null,
|
|
k = c.indexOf(y);
|
|
return b === null && k !== -1 && (b = BigInt(k)), [y, b];
|
|
});
|
|
}),
|
|
(e.getClassList = function (d = {}) {
|
|
let p = [];
|
|
for (let m of a)
|
|
if (Array.isArray(m)) {
|
|
let [w, x] = m,
|
|
y = [],
|
|
b = Object.keys(x?.modifiers ?? {});
|
|
x?.types?.some(({ type: _ }) => _ === "color") &&
|
|
b.push(...Object.keys(e.tailwindConfig.theme.opacity ?? {}));
|
|
let k = { modifiers: b },
|
|
S = d.includeMetadata && b.length > 0;
|
|
for (let [_, O] of Object.entries(x?.values ?? {})) {
|
|
if (O == null) continue;
|
|
let I = Qr(w, _);
|
|
if (
|
|
(p.push(S ? [I, k] : I), x?.supportsNegativeValues && Xe(O))
|
|
) {
|
|
let B = Qr(w, `-${_}`);
|
|
y.push(S ? [B, k] : B);
|
|
}
|
|
}
|
|
p.push(...y);
|
|
} else p.push(m);
|
|
return p;
|
|
}),
|
|
(e.getVariants = function () {
|
|
let d = [];
|
|
for (let [p, m] of e.variantOptions.entries())
|
|
m.variantInfo !== co.Base &&
|
|
d.push({
|
|
name: p,
|
|
isArbitrary: m.type === Symbol.for("MATCH_VARIANT"),
|
|
values: Object.keys(m.values ?? {}),
|
|
hasDash: p !== "@",
|
|
selectors({ modifier: w, value: x } = {}) {
|
|
let y = "__TAILWIND_PLACEHOLDER__",
|
|
b = V.rule({ selector: `.${y}` }),
|
|
k = V.root({ nodes: [b.clone()] }),
|
|
S = k.toString(),
|
|
_ = (e.variantMap.get(p) ?? []).flatMap(([j, ue]) => ue),
|
|
O = [];
|
|
for (let j of _) {
|
|
let ue = [],
|
|
ai = {
|
|
args: { modifier: w, value: m.values?.[x] ?? x },
|
|
separator: e.tailwindConfig.separator,
|
|
modifySelectors(Ce) {
|
|
return (
|
|
k.each((Yn) => {
|
|
Yn.type === "rule" &&
|
|
(Yn.selectors = Yn.selectors.map((lu) =>
|
|
Ce({
|
|
get className() {
|
|
return no(lu);
|
|
},
|
|
selector: lu,
|
|
}),
|
|
));
|
|
}),
|
|
k
|
|
);
|
|
},
|
|
format(Ce) {
|
|
ue.push(Ce);
|
|
},
|
|
wrap(Ce) {
|
|
ue.push(`@${Ce.name} ${Ce.params} { & }`);
|
|
},
|
|
container: k,
|
|
},
|
|
oi = j(ai);
|
|
if ((ue.length > 0 && O.push(ue), Array.isArray(oi)))
|
|
for (let Ce of oi) (ue = []), Ce(ai), O.push(ue);
|
|
}
|
|
let I = [],
|
|
B = k.toString();
|
|
S !== B &&
|
|
(k.walkRules((j) => {
|
|
let ue = j.selector,
|
|
ai = (0, uo.default)((oi) => {
|
|
oi.walkClasses((Ce) => {
|
|
Ce.value = `${p}${e.tailwindConfig.separator}${Ce.value}`;
|
|
});
|
|
}).processSync(ue);
|
|
I.push(ue.replace(ai, "&").replace(y, "&"));
|
|
}),
|
|
k.walkAtRules((j) => {
|
|
I.push(`@${j.name} (${j.params}) { & }`);
|
|
}));
|
|
let q = !(x in (m.values ?? {})),
|
|
X = m[Jr] ?? {},
|
|
le = (() => !(q || X.respectPrefix === !1))();
|
|
(O = O.map((j) =>
|
|
j.map((ue) => ({ format: ue, respectPrefix: le })),
|
|
)),
|
|
(I = I.map((j) => ({ format: j, respectPrefix: le })));
|
|
let ce = { candidate: y, context: e },
|
|
$e = O.map((j) =>
|
|
wn(`.${y}`, $t(j, ce), ce)
|
|
.replace(`.${y}`, "&")
|
|
.replace("{ & }", "")
|
|
.trim(),
|
|
);
|
|
return (
|
|
I.length > 0 &&
|
|
$e.push($t(I, ce).toString().replace(`.${y}`, "&")),
|
|
$e
|
|
);
|
|
},
|
|
});
|
|
return d;
|
|
});
|
|
}
|
|
function jd(i, e) {
|
|
!i.classCache.has(e) ||
|
|
(i.notClassCache.add(e),
|
|
i.classCache.delete(e),
|
|
i.applyClassCache.delete(e),
|
|
i.candidateRuleMap.delete(e),
|
|
i.candidateRuleCache.delete(e),
|
|
(i.stylesheetCache = null));
|
|
}
|
|
function YC(i, e) {
|
|
let t = e.raws.tailwind.candidate;
|
|
if (!!t) {
|
|
for (let r of i.ruleCache)
|
|
r[1].raws.tailwind.candidate === t && i.ruleCache.delete(r);
|
|
jd(i, t);
|
|
}
|
|
}
|
|
function mo(i, e = [], t = V.root()) {
|
|
let r = {
|
|
disposables: [],
|
|
ruleCache: new Set(),
|
|
candidateRuleCache: new Map(),
|
|
classCache: new Map(),
|
|
applyClassCache: new Map(),
|
|
notClassCache: new Set(i.blocklist ?? []),
|
|
postCssNodeCache: new Map(),
|
|
candidateRuleMap: new Map(),
|
|
tailwindConfig: i,
|
|
changedContent: e,
|
|
variantMap: new Map(),
|
|
stylesheetCache: null,
|
|
variantOptions: new Map(),
|
|
markInvalidUtilityCandidate: (a) => jd(r, a),
|
|
markInvalidUtilityNode: (a) => YC(r, a),
|
|
},
|
|
n = GC(r, t);
|
|
return HC(n, r), r;
|
|
}
|
|
function zd(i, e, t, r, n, a) {
|
|
let s = e.opts.from,
|
|
o = r !== null;
|
|
Pe.DEBUG && console.log("Source path:", s);
|
|
let u;
|
|
if (o && jt.has(s)) u = jt.get(s);
|
|
else if (ei.has(n)) {
|
|
let p = ei.get(n);
|
|
lt.get(p).add(s), jt.set(s, p), (u = p);
|
|
}
|
|
let c = Td(s, i);
|
|
if (u) {
|
|
let [p, m] = Ld([...a], On(u));
|
|
if (!p && !c) return [u, !1, m];
|
|
}
|
|
if (jt.has(s)) {
|
|
let p = jt.get(s);
|
|
if (lt.has(p) && (lt.get(p).delete(s), lt.get(p).size === 0)) {
|
|
lt.delete(p);
|
|
for (let [m, w] of ei) w === p && ei.delete(m);
|
|
for (let m of p.disposables.splice(0)) m(p);
|
|
}
|
|
}
|
|
Pe.DEBUG && console.log("Setting up new context...");
|
|
let f = mo(t, [], i);
|
|
Object.assign(f, { userConfigPath: r });
|
|
let [, d] = Ld([...a], On(f));
|
|
return (
|
|
ei.set(n, f),
|
|
jt.set(s, f),
|
|
lt.has(f) || lt.set(f, new Set()),
|
|
lt.get(f).add(s),
|
|
[f, !0, d]
|
|
);
|
|
}
|
|
var Bd,
|
|
uo,
|
|
Jr,
|
|
fo,
|
|
co,
|
|
ho,
|
|
jt,
|
|
ei,
|
|
lt,
|
|
Xr = C(() => {
|
|
l();
|
|
je();
|
|
ys();
|
|
nt();
|
|
(Bd = K(Ls())), (uo = K(Re()));
|
|
Hr();
|
|
za();
|
|
un();
|
|
kt();
|
|
Ft();
|
|
Ua();
|
|
cr();
|
|
gd();
|
|
ot();
|
|
ot();
|
|
pi();
|
|
Oe();
|
|
fi();
|
|
Ja();
|
|
Sn();
|
|
Pd();
|
|
Md();
|
|
ze();
|
|
to();
|
|
(Jr = Symbol()),
|
|
(fo = {
|
|
AddVariant: Symbol.for("ADD_VARIANT"),
|
|
MatchVariant: Symbol.for("MATCH_VARIANT"),
|
|
}),
|
|
(co = { Base: 1 << 0, Dynamic: 1 << 1 });
|
|
ho = new WeakMap();
|
|
(jt = yd), (ei = wd), (lt = gn);
|
|
});
|
|
function go(i) {
|
|
return i.ignore
|
|
? []
|
|
: i.glob
|
|
? h.env.ROLLUP_WATCH === "true"
|
|
? [{ type: "dependency", file: i.base }]
|
|
: [{ type: "dir-dependency", dir: i.base, glob: i.glob }]
|
|
: [{ type: "dependency", file: i.base }];
|
|
}
|
|
var Vd = C(() => {
|
|
l();
|
|
});
|
|
function Ud(i, e) {
|
|
return { handler: i, config: e };
|
|
}
|
|
var Wd,
|
|
Gd = C(() => {
|
|
l();
|
|
Ud.withOptions = function (i, e = () => ({})) {
|
|
let t = function (r) {
|
|
return { __options: r, handler: i(r), config: e(r) };
|
|
};
|
|
return (
|
|
(t.__isOptionsFunction = !0),
|
|
(t.__pluginFunction = i),
|
|
(t.__configFunction = e),
|
|
t
|
|
);
|
|
};
|
|
Wd = Ud;
|
|
});
|
|
var yo = {};
|
|
Ae(yo, { default: () => QC });
|
|
var QC,
|
|
wo = C(() => {
|
|
l();
|
|
Gd();
|
|
QC = Wd;
|
|
});
|
|
var Yd = v((qD, Hd) => {
|
|
l();
|
|
var JC = (wo(), yo).default,
|
|
XC = {
|
|
overflow: "hidden",
|
|
display: "-webkit-box",
|
|
"-webkit-box-orient": "vertical",
|
|
},
|
|
KC = JC(
|
|
function ({
|
|
matchUtilities: i,
|
|
addUtilities: e,
|
|
theme: t,
|
|
variants: r,
|
|
}) {
|
|
let n = t("lineClamp");
|
|
i(
|
|
{ "line-clamp": (a) => ({ ...XC, "-webkit-line-clamp": `${a}` }) },
|
|
{ values: n },
|
|
),
|
|
e(
|
|
[{ ".line-clamp-none": { "-webkit-line-clamp": "unset" } }],
|
|
r("lineClamp"),
|
|
);
|
|
},
|
|
{
|
|
theme: {
|
|
lineClamp: { 1: "1", 2: "2", 3: "3", 4: "4", 5: "5", 6: "6" },
|
|
},
|
|
variants: { lineClamp: ["responsive"] },
|
|
},
|
|
);
|
|
Hd.exports = KC;
|
|
});
|
|
function bo(i) {
|
|
i.content.files.length === 0 &&
|
|
F.warn("content-problems", [
|
|
"The `content` option in your Tailwind CSS configuration is missing or empty.",
|
|
"Configure your content sources or your generated CSS will be missing styles.",
|
|
"https://tailwindcss.com/docs/content-configuration",
|
|
]);
|
|
try {
|
|
let e = Yd();
|
|
i.plugins.includes(e) &&
|
|
(F.warn("line-clamp-in-core", [
|
|
"As of Tailwind CSS v3.3, the `@tailwindcss/line-clamp` plugin is now included by default.",
|
|
"Remove it from the `plugins` array in your configuration to eliminate this warning.",
|
|
]),
|
|
(i.plugins = i.plugins.filter((t) => t !== e)));
|
|
} catch {}
|
|
return i;
|
|
}
|
|
var Qd = C(() => {
|
|
l();
|
|
Oe();
|
|
});
|
|
var Jd,
|
|
Xd = C(() => {
|
|
l();
|
|
Jd = () => !1;
|
|
});
|
|
var En,
|
|
Kd = C(() => {
|
|
l();
|
|
En = {
|
|
sync: (i) => [].concat(i),
|
|
generateTasks: (i) => [
|
|
{
|
|
dynamic: !1,
|
|
base: ".",
|
|
negative: [],
|
|
positive: [].concat(i),
|
|
patterns: [].concat(i),
|
|
},
|
|
],
|
|
escapePath: (i) => i,
|
|
};
|
|
});
|
|
var vo,
|
|
Zd = C(() => {
|
|
l();
|
|
vo = (i) => i;
|
|
});
|
|
var eh,
|
|
th = C(() => {
|
|
l();
|
|
eh = () => "";
|
|
});
|
|
function rh(i) {
|
|
let e = i,
|
|
t = eh(i);
|
|
return (
|
|
t !== "." &&
|
|
((e = i.substr(t.length)), e.charAt(0) === "/" && (e = e.substr(1))),
|
|
e.substr(0, 2) === "./" && (e = e.substr(2)),
|
|
e.charAt(0) === "/" && (e = e.substr(1)),
|
|
{ base: t, glob: e }
|
|
);
|
|
}
|
|
var ih = C(() => {
|
|
l();
|
|
th();
|
|
});
|
|
function nh(i, e) {
|
|
let t = e.content.files;
|
|
(t = t.filter((o) => typeof o == "string")), (t = t.map(vo));
|
|
let r = En.generateTasks(t),
|
|
n = [],
|
|
a = [];
|
|
for (let o of r)
|
|
n.push(...o.positive.map((u) => sh(u, !1))),
|
|
a.push(...o.negative.map((u) => sh(u, !0)));
|
|
let s = [...n, ...a];
|
|
return (s = e2(i, s)), (s = s.flatMap(t2)), (s = s.map(ZC)), s;
|
|
}
|
|
function sh(i, e) {
|
|
let t = { original: i, base: i, ignore: e, pattern: i, glob: null };
|
|
return Jd(i) && Object.assign(t, rh(i)), t;
|
|
}
|
|
function ZC(i) {
|
|
let e = vo(i.base);
|
|
return (
|
|
(e = En.escapePath(e)),
|
|
(i.pattern = i.glob ? `${e}/${i.glob}` : e),
|
|
(i.pattern = i.ignore ? `!${i.pattern}` : i.pattern),
|
|
i
|
|
);
|
|
}
|
|
function e2(i, e) {
|
|
let t = [];
|
|
return (
|
|
i.userConfigPath &&
|
|
i.tailwindConfig.content.relative &&
|
|
(t = [ee.dirname(i.userConfigPath)]),
|
|
e.map((r) => ((r.base = ee.resolve(...t, r.base)), r))
|
|
);
|
|
}
|
|
function t2(i) {
|
|
let e = [i];
|
|
try {
|
|
let t = re.realpathSync(i.base);
|
|
t !== i.base && e.push({ ...i, base: t });
|
|
} catch {}
|
|
return e;
|
|
}
|
|
function ah(i, e, t) {
|
|
let r = i.tailwindConfig.content.files
|
|
.filter((s) => typeof s.raw == "string")
|
|
.map(({ raw: s, extension: o = "html" }) => ({
|
|
content: s,
|
|
extension: o,
|
|
})),
|
|
[n, a] = r2(e, t);
|
|
for (let s of n) {
|
|
let o = ee.extname(s).slice(1);
|
|
r.push({ file: s, extension: o });
|
|
}
|
|
return [r, a];
|
|
}
|
|
function r2(i, e) {
|
|
let t = i.map((s) => s.pattern),
|
|
r = new Map(),
|
|
n = new Set();
|
|
Pe.DEBUG && console.time("Finding changed files");
|
|
let a = En.sync(t, { absolute: !0 });
|
|
for (let s of a) {
|
|
let o = e.get(s) || -1 / 0,
|
|
u = re.statSync(s).mtimeMs;
|
|
u > o && (n.add(s), r.set(s, u));
|
|
}
|
|
return Pe.DEBUG && console.timeEnd("Finding changed files"), [n, r];
|
|
}
|
|
var oh = C(() => {
|
|
l();
|
|
je();
|
|
gt();
|
|
Xd();
|
|
Kd();
|
|
Zd();
|
|
ih();
|
|
ot();
|
|
});
|
|
function lh() {}
|
|
var uh = C(() => {
|
|
l();
|
|
});
|
|
function a2(i, e) {
|
|
for (let t of e) {
|
|
let r = `${i}${t}`;
|
|
if (re.existsSync(r) && re.statSync(r).isFile()) return r;
|
|
}
|
|
for (let t of e) {
|
|
let r = `${i}/index${t}`;
|
|
if (re.existsSync(r)) return r;
|
|
}
|
|
return null;
|
|
}
|
|
function* fh(i, e, t, r = ee.extname(i)) {
|
|
let n = a2(ee.resolve(e, i), i2.includes(r) ? n2 : s2);
|
|
if (n === null || t.has(n)) return;
|
|
t.add(n), yield n, (e = ee.dirname(n)), (r = ee.extname(n));
|
|
let a = re.readFileSync(n, "utf-8");
|
|
for (let s of [
|
|
...a.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
|
|
...a.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
|
|
...a.matchAll(/require\(['"`](.+)['"`]\)/gi),
|
|
])
|
|
!s[1].startsWith(".") || (yield* fh(s[1], e, t, r));
|
|
}
|
|
function xo(i) {
|
|
return i === null ? new Set() : new Set(fh(i, ee.dirname(i), new Set()));
|
|
}
|
|
var i2,
|
|
n2,
|
|
s2,
|
|
ch = C(() => {
|
|
l();
|
|
je();
|
|
gt();
|
|
(i2 = [".js", ".cjs", ".mjs"]),
|
|
(n2 = [
|
|
"",
|
|
".js",
|
|
".cjs",
|
|
".mjs",
|
|
".ts",
|
|
".cts",
|
|
".mts",
|
|
".jsx",
|
|
".tsx",
|
|
]),
|
|
(s2 = [
|
|
"",
|
|
".ts",
|
|
".cts",
|
|
".mts",
|
|
".tsx",
|
|
".js",
|
|
".cjs",
|
|
".mjs",
|
|
".jsx",
|
|
]);
|
|
});
|
|
function o2(i, e) {
|
|
if (ko.has(i)) return ko.get(i);
|
|
let t = nh(i, e);
|
|
return ko.set(i, t).get(i);
|
|
}
|
|
function l2(i) {
|
|
let e = ms(i);
|
|
if (e !== null) {
|
|
let [r, n, a, s] = dh.get(e) || [],
|
|
o = xo(e),
|
|
u = !1,
|
|
c = new Map();
|
|
for (let p of o) {
|
|
let m = re.statSync(p).mtimeMs;
|
|
c.set(p, m), (!s || !s.has(p) || m > s.get(p)) && (u = !0);
|
|
}
|
|
if (!u) return [r, e, n, a];
|
|
for (let p of o) delete fu.cache[p];
|
|
let f = bo(dr(lh(e))),
|
|
d = ui(f);
|
|
return dh.set(e, [f, d, o, c]), [f, e, d, o];
|
|
}
|
|
let t = dr(i?.config ?? i ?? {});
|
|
return (t = bo(t)), [t, null, ui(t), []];
|
|
}
|
|
function So(i) {
|
|
return ({ tailwindDirectives: e, registerDependency: t }) =>
|
|
(r, n) => {
|
|
let [a, s, o, u] = l2(i),
|
|
c = new Set(u);
|
|
if (e.size > 0) {
|
|
c.add(n.opts.from);
|
|
for (let w of n.messages) w.type === "dependency" && c.add(w.file);
|
|
}
|
|
let [f, , d] = zd(r, n, a, s, o, c),
|
|
p = On(f),
|
|
m = o2(f, a);
|
|
if (e.size > 0) {
|
|
for (let y of m) for (let b of go(y)) t(b);
|
|
let [w, x] = ah(f, m, p);
|
|
for (let y of w) f.changedContent.push(y);
|
|
for (let [y, b] of x.entries()) d.set(y, b);
|
|
}
|
|
for (let w of u) t({ type: "dependency", file: w });
|
|
for (let [w, x] of d.entries()) p.set(w, x);
|
|
return f;
|
|
};
|
|
}
|
|
var ph,
|
|
dh,
|
|
ko,
|
|
hh = C(() => {
|
|
l();
|
|
je();
|
|
ph = K(Qn());
|
|
mu();
|
|
hs();
|
|
sf();
|
|
Xr();
|
|
Vd();
|
|
Qd();
|
|
oh();
|
|
uh();
|
|
ch();
|
|
(dh = new ph.default({ maxSize: 100 })), (ko = new WeakMap());
|
|
});
|
|
function Co(i) {
|
|
let e = new Set(),
|
|
t = new Set(),
|
|
r = new Set();
|
|
if (
|
|
(i.walkAtRules((n) => {
|
|
n.name === "apply" && r.add(n),
|
|
n.name === "import" &&
|
|
(n.params === '"tailwindcss/base"' ||
|
|
n.params === "'tailwindcss/base'"
|
|
? ((n.name = "tailwind"), (n.params = "base"))
|
|
: n.params === '"tailwindcss/components"' ||
|
|
n.params === "'tailwindcss/components'"
|
|
? ((n.name = "tailwind"), (n.params = "components"))
|
|
: n.params === '"tailwindcss/utilities"' ||
|
|
n.params === "'tailwindcss/utilities'"
|
|
? ((n.name = "tailwind"), (n.params = "utilities"))
|
|
: (n.params === '"tailwindcss/screens"' ||
|
|
n.params === "'tailwindcss/screens'" ||
|
|
n.params === '"tailwindcss/variants"' ||
|
|
n.params === "'tailwindcss/variants'") &&
|
|
((n.name = "tailwind"), (n.params = "variants"))),
|
|
n.name === "tailwind" &&
|
|
(n.params === "screens" && (n.params = "variants"),
|
|
e.add(n.params)),
|
|
["layer", "responsive", "variants"].includes(n.name) &&
|
|
(["responsive", "variants"].includes(n.name) &&
|
|
F.warn(`${n.name}-at-rule-deprecated`, [
|
|
`The \`@${n.name}\` directive has been deprecated in Tailwind CSS v3.0.`,
|
|
"Use `@layer utilities` or `@layer components` instead.",
|
|
"https://tailwindcss.com/docs/upgrade-guide#replace-variants-with-layer",
|
|
]),
|
|
t.add(n));
|
|
}),
|
|
!e.has("base") || !e.has("components") || !e.has("utilities"))
|
|
) {
|
|
for (let n of t)
|
|
if (
|
|
n.name === "layer" &&
|
|
["base", "components", "utilities"].includes(n.params)
|
|
) {
|
|
if (!e.has(n.params))
|
|
throw n.error(
|
|
`\`@layer ${n.params}\` is used but no matching \`@tailwind ${n.params}\` directive is present.`,
|
|
);
|
|
} else if (n.name === "responsive") {
|
|
if (!e.has("utilities"))
|
|
throw n.error(
|
|
"`@responsive` is used but `@tailwind utilities` is missing.",
|
|
);
|
|
} else if (n.name === "variants" && !e.has("utilities"))
|
|
throw n.error(
|
|
"`@variants` is used but `@tailwind utilities` is missing.",
|
|
);
|
|
}
|
|
return { tailwindDirectives: e, applyDirectives: r };
|
|
}
|
|
var mh = C(() => {
|
|
l();
|
|
Oe();
|
|
});
|
|
function vt(i, e = void 0, t = void 0) {
|
|
return i.map((r) => {
|
|
let n = r.clone();
|
|
return (
|
|
t !== void 0 && (n.raws.tailwind = { ...n.raws.tailwind, ...t }),
|
|
e !== void 0 &&
|
|
gh(n, (a) => {
|
|
if (a.raws.tailwind?.preserveSource === !0 && a.source) return !1;
|
|
a.source = e;
|
|
}),
|
|
n
|
|
);
|
|
});
|
|
}
|
|
function gh(i, e) {
|
|
e(i) !== !1 && i.each?.((t) => gh(t, e));
|
|
}
|
|
var yh = C(() => {
|
|
l();
|
|
});
|
|
function Ao(i) {
|
|
return (
|
|
(i = Array.isArray(i) ? i : [i]),
|
|
(i = i.map((e) => (e instanceof RegExp ? e.source : e))),
|
|
i.join("")
|
|
);
|
|
}
|
|
function ye(i) {
|
|
return new RegExp(Ao(i), "g");
|
|
}
|
|
function ut(i) {
|
|
return `(?:${i.map(Ao).join("|")})`;
|
|
}
|
|
function _o(i) {
|
|
return `(?:${Ao(i)})?`;
|
|
}
|
|
function bh(i) {
|
|
return i && u2.test(i) ? i.replace(wh, "\\$&") : i || "";
|
|
}
|
|
var wh,
|
|
u2,
|
|
vh = C(() => {
|
|
l();
|
|
(wh = /[\\^$.*+?()[\]{}|]/g), (u2 = RegExp(wh.source));
|
|
});
|
|
function xh(i) {
|
|
let e = Array.from(f2(i));
|
|
return (t) => {
|
|
let r = [];
|
|
for (let n of e) for (let a of t.match(n) ?? []) r.push(d2(a));
|
|
return r;
|
|
};
|
|
}
|
|
function* f2(i) {
|
|
let e = i.tailwindConfig.separator,
|
|
t =
|
|
i.tailwindConfig.prefix !== ""
|
|
? _o(ye([/-?/, bh(i.tailwindConfig.prefix)]))
|
|
: "",
|
|
r = ut([
|
|
/\[[^\s:'"`]+:[^\s\[\]]+\]/,
|
|
/\[[^\s:'"`\]]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
|
|
ye([
|
|
ut([/-?(?:\w+)/, /@(?:\w+)/]),
|
|
_o(
|
|
ut([
|
|
ye([
|
|
ut([
|
|
/-(?:\w+-)*\['[^\s]+'\]/,
|
|
/-(?:\w+-)*\["[^\s]+"\]/,
|
|
/-(?:\w+-)*\[`[^\s]+`\]/,
|
|
/-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s:\[\]]+\]/,
|
|
]),
|
|
/(?![{([]])/,
|
|
/(?:\/[^\s'"`\\><$]*)?/,
|
|
]),
|
|
ye([
|
|
ut([
|
|
/-(?:\w+-)*\['[^\s]+'\]/,
|
|
/-(?:\w+-)*\["[^\s]+"\]/,
|
|
/-(?:\w+-)*\[`[^\s]+`\]/,
|
|
/-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s\[\]]+\]/,
|
|
]),
|
|
/(?![{([]])/,
|
|
/(?:\/[^\s'"`\\$]*)?/,
|
|
]),
|
|
/[-\/][^\s'"`\\$={><]*/,
|
|
]),
|
|
),
|
|
]),
|
|
]),
|
|
n = [
|
|
ut([
|
|
ye([/@\[[^\s"'`]+\](\/[^\s"'`]+)?/, e]),
|
|
ye([/([^\s"'`\[\\]+-)?\[[^\s"'`]+\]\/\w+/, e]),
|
|
ye([/([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/, e]),
|
|
ye([/[^\s"'`\[\\]+/, e]),
|
|
]),
|
|
ut([
|
|
ye([/([^\s"'`\[\\]+-)?\[[^\s`]+\]\/\w+/, e]),
|
|
ye([/([^\s"'`\[\\]+-)?\[[^\s`]+\]/, e]),
|
|
ye([/[^\s`\[\\]+/, e]),
|
|
]),
|
|
];
|
|
for (let a of n) yield ye(["((?=((", a, ")+))\\2)?", /!?/, t, r]);
|
|
yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
|
|
}
|
|
function d2(i) {
|
|
if (!i.includes("-[")) return i;
|
|
let e = 0,
|
|
t = [],
|
|
r = i.matchAll(c2);
|
|
r = Array.from(r).flatMap((n) => {
|
|
let [, ...a] = n;
|
|
return a.map((s, o) =>
|
|
Object.assign([], n, { index: n.index + o, 0: s }),
|
|
);
|
|
});
|
|
for (let n of r) {
|
|
let a = n[0],
|
|
s = t[t.length - 1];
|
|
if (
|
|
(a === s ? t.pop() : (a === "'" || a === '"' || a === "`") && t.push(a),
|
|
!s)
|
|
) {
|
|
if (a === "[") {
|
|
e++;
|
|
continue;
|
|
} else if (a === "]") {
|
|
e--;
|
|
continue;
|
|
}
|
|
if (e < 0) return i.substring(0, n.index - 1);
|
|
if (e === 0 && !p2.test(a)) return i.substring(0, n.index);
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
var c2,
|
|
p2,
|
|
kh = C(() => {
|
|
l();
|
|
vh();
|
|
(c2 = /([\[\]'"`])([^\[\]'"`])?/g), (p2 = /[^"'`\s<>\]]+/);
|
|
});
|
|
function h2(i, e) {
|
|
let t = i.tailwindConfig.content.extract;
|
|
return t[e] || t.DEFAULT || Ch[e] || Ch.DEFAULT(i);
|
|
}
|
|
function m2(i, e) {
|
|
let t = i.content.transform;
|
|
return t[e] || t.DEFAULT || Ah[e] || Ah.DEFAULT;
|
|
}
|
|
function g2(i, e, t, r) {
|
|
ti.has(e) || ti.set(e, new Sh.default({ maxSize: 25e3 }));
|
|
for (let n of i.split(`
|
|
`))
|
|
if (((n = n.trim()), !r.has(n)))
|
|
if ((r.add(n), ti.get(e).has(n)))
|
|
for (let a of ti.get(e).get(n)) t.add(a);
|
|
else {
|
|
let a = e(n).filter((o) => o !== "!*"),
|
|
s = new Set(a);
|
|
for (let o of s) t.add(o);
|
|
ti.get(e).set(n, s);
|
|
}
|
|
}
|
|
function y2(i, e) {
|
|
let t = e.offsets.sort(i),
|
|
r = {
|
|
base: new Set(),
|
|
defaults: new Set(),
|
|
components: new Set(),
|
|
utilities: new Set(),
|
|
variants: new Set(),
|
|
};
|
|
for (let [n, a] of t) r[n.layer].add(a);
|
|
return r;
|
|
}
|
|
function Oo(i) {
|
|
return async (e) => {
|
|
let t = { base: null, components: null, utilities: null, variants: null };
|
|
if (
|
|
(e.walkAtRules((w) => {
|
|
w.name === "tailwind" &&
|
|
Object.keys(t).includes(w.params) &&
|
|
(t[w.params] = w);
|
|
}),
|
|
Object.values(t).every((w) => w === null))
|
|
)
|
|
return e;
|
|
let r = new Set([...(i.candidates ?? []), He]),
|
|
n = new Set();
|
|
Ye.DEBUG && console.time("Reading changed files");
|
|
{
|
|
let w = [];
|
|
for (let y of i.changedContent) {
|
|
let b = m2(i.tailwindConfig, y.extension),
|
|
k = h2(i, y.extension);
|
|
w.push([y, { transformer: b, extractor: k }]);
|
|
}
|
|
let x = 500;
|
|
for (let y = 0; y < w.length; y += x) {
|
|
let b = w.slice(y, y + x);
|
|
await Promise.all(
|
|
b.map(
|
|
async ([
|
|
{ file: k, content: S },
|
|
{ transformer: _, extractor: O },
|
|
]) => {
|
|
(S = k ? await re.promises.readFile(k, "utf8") : S),
|
|
g2(_(S), O, r, n);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
}
|
|
Ye.DEBUG && console.timeEnd("Reading changed files");
|
|
let a = i.classCache.size;
|
|
Ye.DEBUG && console.time("Generate rules"),
|
|
Ye.DEBUG && console.time("Sorting candidates");
|
|
let s = new Set([...r].sort((w, x) => (w === x ? 0 : w < x ? -1 : 1)));
|
|
Ye.DEBUG && console.timeEnd("Sorting candidates"),
|
|
kn(s, i),
|
|
Ye.DEBUG && console.timeEnd("Generate rules"),
|
|
Ye.DEBUG && console.time("Build stylesheet"),
|
|
(i.stylesheetCache === null || i.classCache.size !== a) &&
|
|
(i.stylesheetCache = y2([...i.ruleCache], i)),
|
|
Ye.DEBUG && console.timeEnd("Build stylesheet");
|
|
let {
|
|
defaults: o,
|
|
base: u,
|
|
components: c,
|
|
utilities: f,
|
|
variants: d,
|
|
} = i.stylesheetCache;
|
|
t.base &&
|
|
(t.base.before(vt([...u, ...o], t.base.source, { layer: "base" })),
|
|
t.base.remove()),
|
|
t.components &&
|
|
(t.components.before(
|
|
vt([...c], t.components.source, { layer: "components" }),
|
|
),
|
|
t.components.remove()),
|
|
t.utilities &&
|
|
(t.utilities.before(
|
|
vt([...f], t.utilities.source, { layer: "utilities" }),
|
|
),
|
|
t.utilities.remove());
|
|
let p = Array.from(d).filter((w) => {
|
|
let x = w.raws.tailwind?.parentLayer;
|
|
return x === "components"
|
|
? t.components !== null
|
|
: x === "utilities"
|
|
? t.utilities !== null
|
|
: !0;
|
|
});
|
|
t.variants
|
|
? (t.variants.before(vt(p, t.variants.source, { layer: "variants" })),
|
|
t.variants.remove())
|
|
: p.length > 0 && e.append(vt(p, e.source, { layer: "variants" })),
|
|
(e.source.end = e.source.end ?? e.source.start);
|
|
let m = p.some((w) => w.raws.tailwind?.parentLayer === "utilities");
|
|
t.utilities &&
|
|
f.size === 0 &&
|
|
!m &&
|
|
F.warn("content-problems", [
|
|
"No utility classes were detected in your source files. If this is unexpected, double-check the `content` option in your Tailwind CSS configuration.",
|
|
"https://tailwindcss.com/docs/content-configuration",
|
|
]),
|
|
Ye.DEBUG &&
|
|
(console.log("Potential classes: ", r.size),
|
|
console.log("Active contexts: ", gn.size)),
|
|
(i.changedContent = []),
|
|
e.walkAtRules("layer", (w) => {
|
|
Object.keys(t).includes(w.params) && w.remove();
|
|
});
|
|
};
|
|
}
|
|
var Sh,
|
|
Ye,
|
|
Ch,
|
|
Ah,
|
|
ti,
|
|
_h = C(() => {
|
|
l();
|
|
je();
|
|
Sh = K(Qn());
|
|
ot();
|
|
Sn();
|
|
Oe();
|
|
yh();
|
|
kh();
|
|
(Ye = Pe),
|
|
(Ch = { DEFAULT: xh }),
|
|
(Ah = {
|
|
DEFAULT: (i) => i,
|
|
svelte: (i) => i.replace(/(?:^|\s)class:/g, " "),
|
|
});
|
|
ti = new WeakMap();
|
|
});
|
|
function Pn(i) {
|
|
let e = new Map();
|
|
V.root({ nodes: [i.clone()] }).walkRules((a) => {
|
|
(0, Tn.default)((s) => {
|
|
s.walkClasses((o) => {
|
|
let u = o.parent.toString(),
|
|
c = e.get(u);
|
|
c || e.set(u, (c = new Set())), c.add(o.value);
|
|
});
|
|
}).processSync(a.selector);
|
|
});
|
|
let r = Array.from(e.values(), (a) => Array.from(a)),
|
|
n = r.flat();
|
|
return Object.assign(n, { groups: r });
|
|
}
|
|
function Eo(i) {
|
|
return w2.astSync(i);
|
|
}
|
|
function Oh(i, e) {
|
|
let t = new Set();
|
|
for (let r of i) t.add(r.split(e).pop());
|
|
return Array.from(t);
|
|
}
|
|
function Eh(i, e) {
|
|
let t = i.tailwindConfig.prefix;
|
|
return typeof t == "function" ? t(e) : t + e;
|
|
}
|
|
function* Th(i) {
|
|
for (yield i; i.parent; ) yield i.parent, (i = i.parent);
|
|
}
|
|
function b2(i, e = {}) {
|
|
let t = i.nodes;
|
|
i.nodes = [];
|
|
let r = i.clone(e);
|
|
return (i.nodes = t), r;
|
|
}
|
|
function v2(i) {
|
|
for (let e of Th(i))
|
|
if (i !== e) {
|
|
if (e.type === "root") break;
|
|
i = b2(e, { nodes: [i] });
|
|
}
|
|
return i;
|
|
}
|
|
function x2(i, e) {
|
|
let t = new Map();
|
|
return (
|
|
i.walkRules((r) => {
|
|
for (let s of Th(r)) if (s.raws.tailwind?.layer !== void 0) return;
|
|
let n = v2(r),
|
|
a = e.offsets.create("user");
|
|
for (let s of Pn(r)) {
|
|
let o = t.get(s) || [];
|
|
t.set(s, o), o.push([{ layer: "user", sort: a, important: !1 }, n]);
|
|
}
|
|
}),
|
|
t
|
|
);
|
|
}
|
|
function k2(i, e) {
|
|
for (let t of i) {
|
|
if (e.notClassCache.has(t) || e.applyClassCache.has(t)) continue;
|
|
if (e.classCache.has(t)) {
|
|
e.applyClassCache.set(
|
|
t,
|
|
e.classCache.get(t).map(([n, a]) => [n, a.clone()]),
|
|
);
|
|
continue;
|
|
}
|
|
let r = Array.from(ao(t, e));
|
|
if (r.length === 0) {
|
|
e.notClassCache.add(t);
|
|
continue;
|
|
}
|
|
e.applyClassCache.set(t, r);
|
|
}
|
|
return e.applyClassCache;
|
|
}
|
|
function S2(i) {
|
|
let e = null;
|
|
return {
|
|
get: (t) => ((e = e || i()), e.get(t)),
|
|
has: (t) => ((e = e || i()), e.has(t)),
|
|
};
|
|
}
|
|
function C2(i) {
|
|
return {
|
|
get: (e) => i.flatMap((t) => t.get(e) || []),
|
|
has: (e) => i.some((t) => t.has(e)),
|
|
};
|
|
}
|
|
function Ph(i) {
|
|
let e = i.split(/[\s\t\n]+/g);
|
|
return e[e.length - 1] === "!important" ? [e.slice(0, -1), !0] : [e, !1];
|
|
}
|
|
function Dh(i, e, t) {
|
|
let r = new Set(),
|
|
n = [];
|
|
if (
|
|
(i.walkAtRules("apply", (u) => {
|
|
let [c] = Ph(u.params);
|
|
for (let f of c) r.add(f);
|
|
n.push(u);
|
|
}),
|
|
n.length === 0)
|
|
)
|
|
return;
|
|
let a = C2([t, k2(r, e)]);
|
|
function s(u, c, f) {
|
|
let d = Eo(u),
|
|
p = Eo(c),
|
|
w = Eo(`.${de(f)}`).nodes[0].nodes[0];
|
|
return (
|
|
d.each((x) => {
|
|
let y = new Set();
|
|
p.each((b) => {
|
|
let k = !1;
|
|
(b = b.clone()),
|
|
b.walkClasses((S) => {
|
|
S.value === w.value &&
|
|
(k ||
|
|
(S.replaceWith(...x.nodes.map((_) => _.clone())),
|
|
y.add(b),
|
|
(k = !0)));
|
|
});
|
|
});
|
|
for (let b of y) {
|
|
let k = [[]];
|
|
for (let S of b.nodes)
|
|
S.type === "combinator"
|
|
? (k.push(S), k.push([]))
|
|
: k[k.length - 1].push(S);
|
|
b.nodes = [];
|
|
for (let S of k)
|
|
Array.isArray(S) &&
|
|
S.sort((_, O) =>
|
|
_.type === "tag" && O.type === "class"
|
|
? -1
|
|
: _.type === "class" && O.type === "tag"
|
|
? 1
|
|
: _.type === "class" &&
|
|
O.type === "pseudo" &&
|
|
O.value.startsWith("::")
|
|
? -1
|
|
: _.type === "pseudo" &&
|
|
_.value.startsWith("::") &&
|
|
O.type === "class"
|
|
? 1
|
|
: 0,
|
|
),
|
|
(b.nodes = b.nodes.concat(S));
|
|
}
|
|
x.replaceWith(...y);
|
|
}),
|
|
d.toString()
|
|
);
|
|
}
|
|
let o = new Map();
|
|
for (let u of n) {
|
|
let [c] = o.get(u.parent) || [[], u.source];
|
|
o.set(u.parent, [c, u.source]);
|
|
let [f, d] = Ph(u.params);
|
|
if (u.parent.type === "atrule") {
|
|
if (u.parent.name === "screen") {
|
|
let p = u.parent.params;
|
|
throw u.error(
|
|
`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${f.map((m) => `${p}:${m}`).join(" ")} instead.`,
|
|
);
|
|
}
|
|
throw u.error(
|
|
`@apply is not supported within nested at-rules like @${u.parent.name}. You can fix this by un-nesting @${u.parent.name}.`,
|
|
);
|
|
}
|
|
for (let p of f) {
|
|
if ([Eh(e, "group"), Eh(e, "peer")].includes(p))
|
|
throw u.error(`@apply should not be used with the '${p}' utility`);
|
|
if (!a.has(p))
|
|
throw u.error(
|
|
`The \`${p}\` class does not exist. If \`${p}\` is a custom class, make sure it is defined within a \`@layer\` directive.`,
|
|
);
|
|
let m = a.get(p);
|
|
c.push([p, d, m]);
|
|
}
|
|
}
|
|
for (let [u, [c, f]] of o) {
|
|
let d = [];
|
|
for (let [m, w, x] of c) {
|
|
let y = [m, ...Oh([m], e.tailwindConfig.separator)];
|
|
for (let [b, k] of x) {
|
|
let S = Pn(u),
|
|
_ = Pn(k);
|
|
if (
|
|
((_ = _.groups.filter((q) => q.some((X) => y.includes(X))).flat()),
|
|
(_ = _.concat(Oh(_, e.tailwindConfig.separator))),
|
|
S.some((q) => _.includes(q)))
|
|
)
|
|
throw k.error(
|
|
`You cannot \`@apply\` the \`${m}\` utility here because it creates a circular dependency.`,
|
|
);
|
|
let I = V.root({ nodes: [k.clone()] });
|
|
I.walk((q) => {
|
|
q.source = f;
|
|
}),
|
|
(k.type !== "atrule" ||
|
|
(k.type === "atrule" && k.name !== "keyframes")) &&
|
|
I.walkRules((q) => {
|
|
if (!Pn(q).some((j) => j === m)) {
|
|
q.remove();
|
|
return;
|
|
}
|
|
let X =
|
|
typeof e.tailwindConfig.important == "string"
|
|
? e.tailwindConfig.important
|
|
: null,
|
|
ce =
|
|
u.raws.tailwind !== void 0 &&
|
|
X &&
|
|
u.selector.indexOf(X) === 0
|
|
? u.selector.slice(X.length)
|
|
: u.selector;
|
|
ce === "" && (ce = u.selector),
|
|
(q.selector = s(ce, q.selector, m)),
|
|
X && ce !== u.selector && (q.selector = bn(q.selector, X)),
|
|
q.walkDecls((j) => {
|
|
j.important = b.important || w;
|
|
});
|
|
let $e = (0, Tn.default)().astSync(q.selector);
|
|
$e.each((j) => Lt(j)), (q.selector = $e.toString());
|
|
}),
|
|
!!I.nodes[0] && d.push([b.sort, I.nodes[0]]);
|
|
}
|
|
}
|
|
let p = e.offsets.sort(d).map((m) => m[1]);
|
|
u.after(p);
|
|
}
|
|
for (let u of n) u.parent.nodes.length > 1 ? u.remove() : u.parent.remove();
|
|
Dh(i, e, t);
|
|
}
|
|
function To(i) {
|
|
return (e) => {
|
|
let t = S2(() => x2(e, i));
|
|
Dh(e, i, t);
|
|
};
|
|
}
|
|
var Tn,
|
|
w2,
|
|
Ih = C(() => {
|
|
l();
|
|
nt();
|
|
Tn = K(Re());
|
|
Sn();
|
|
Ft();
|
|
io();
|
|
yn();
|
|
w2 = (0, Tn.default)();
|
|
});
|
|
var qh = v((P6, Dn) => {
|
|
l();
|
|
(function () {
|
|
"use strict";
|
|
function i(r, n, a) {
|
|
if (!r) return null;
|
|
i.caseSensitive || (r = r.toLowerCase());
|
|
var s = i.threshold === null ? null : i.threshold * r.length,
|
|
o = i.thresholdAbsolute,
|
|
u;
|
|
s !== null && o !== null
|
|
? (u = Math.min(s, o))
|
|
: s !== null
|
|
? (u = s)
|
|
: o !== null
|
|
? (u = o)
|
|
: (u = null);
|
|
var c,
|
|
f,
|
|
d,
|
|
p,
|
|
m,
|
|
w = n.length;
|
|
for (m = 0; m < w; m++)
|
|
if (
|
|
((f = n[m]),
|
|
a && (f = f[a]),
|
|
!!f &&
|
|
(i.caseSensitive ? (d = f) : (d = f.toLowerCase()),
|
|
(p = t(r, d, u)),
|
|
(u === null || p < u) &&
|
|
((u = p),
|
|
a && i.returnWinningObject ? (c = n[m]) : (c = f),
|
|
i.returnFirstMatch)))
|
|
)
|
|
return c;
|
|
return c || i.nullResultValue;
|
|
}
|
|
(i.threshold = 0.4),
|
|
(i.thresholdAbsolute = 20),
|
|
(i.caseSensitive = !1),
|
|
(i.nullResultValue = null),
|
|
(i.returnWinningObject = null),
|
|
(i.returnFirstMatch = !1),
|
|
typeof Dn != "undefined" && Dn.exports
|
|
? (Dn.exports = i)
|
|
: (window.didYouMean = i);
|
|
var e = Math.pow(2, 32) - 1;
|
|
function t(r, n, a) {
|
|
a = a || a === 0 ? a : e;
|
|
var s = r.length,
|
|
o = n.length;
|
|
if (s === 0) return Math.min(a + 1, o);
|
|
if (o === 0) return Math.min(a + 1, s);
|
|
if (Math.abs(s - o) > a) return a + 1;
|
|
var u = [],
|
|
c,
|
|
f,
|
|
d,
|
|
p,
|
|
m;
|
|
for (c = 0; c <= o; c++) u[c] = [c];
|
|
for (f = 0; f <= s; f++) u[0][f] = f;
|
|
for (c = 1; c <= o; c++) {
|
|
for (
|
|
d = e,
|
|
p = 1,
|
|
c > a && (p = c - a),
|
|
m = o + 1,
|
|
m > a + c && (m = a + c),
|
|
f = 1;
|
|
f <= s;
|
|
f++
|
|
)
|
|
f < p || f > m
|
|
? (u[c][f] = a + 1)
|
|
: n.charAt(c - 1) === r.charAt(f - 1)
|
|
? (u[c][f] = u[c - 1][f - 1])
|
|
: (u[c][f] = Math.min(
|
|
u[c - 1][f - 1] + 1,
|
|
Math.min(u[c][f - 1] + 1, u[c - 1][f] + 1),
|
|
)),
|
|
u[c][f] < d && (d = u[c][f]);
|
|
if (d > a) return a + 1;
|
|
}
|
|
return u[o][s];
|
|
}
|
|
})();
|
|
});
|
|
var Mh = v((D6, Rh) => {
|
|
l();
|
|
var Po = "(".charCodeAt(0),
|
|
Do = ")".charCodeAt(0),
|
|
In = "'".charCodeAt(0),
|
|
Io = '"'.charCodeAt(0),
|
|
qo = "\\".charCodeAt(0),
|
|
zt = "/".charCodeAt(0),
|
|
Ro = ",".charCodeAt(0),
|
|
Mo = ":".charCodeAt(0),
|
|
qn = "*".charCodeAt(0),
|
|
A2 = "u".charCodeAt(0),
|
|
_2 = "U".charCodeAt(0),
|
|
O2 = "+".charCodeAt(0),
|
|
E2 = /^[a-f0-9?-]+$/i;
|
|
Rh.exports = function (i) {
|
|
for (
|
|
var e = [],
|
|
t = i,
|
|
r,
|
|
n,
|
|
a,
|
|
s,
|
|
o,
|
|
u,
|
|
c,
|
|
f,
|
|
d = 0,
|
|
p = t.charCodeAt(d),
|
|
m = t.length,
|
|
w = [{ nodes: e }],
|
|
x = 0,
|
|
y,
|
|
b = "",
|
|
k = "",
|
|
S = "";
|
|
d < m;
|
|
|
|
)
|
|
if (p <= 32) {
|
|
r = d;
|
|
do (r += 1), (p = t.charCodeAt(r));
|
|
while (p <= 32);
|
|
(s = t.slice(d, r)),
|
|
(a = e[e.length - 1]),
|
|
p === Do && x
|
|
? (S = s)
|
|
: a && a.type === "div"
|
|
? ((a.after = s), (a.sourceEndIndex += s.length))
|
|
: p === Ro ||
|
|
p === Mo ||
|
|
(p === zt &&
|
|
t.charCodeAt(r + 1) !== qn &&
|
|
(!y || (y && y.type === "function" && !1)))
|
|
? (k = s)
|
|
: e.push({
|
|
type: "space",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
}),
|
|
(d = r);
|
|
} else if (p === In || p === Io) {
|
|
(r = d),
|
|
(n = p === In ? "'" : '"'),
|
|
(s = { type: "string", sourceIndex: d, quote: n });
|
|
do
|
|
if (((o = !1), (r = t.indexOf(n, r + 1)), ~r))
|
|
for (u = r; t.charCodeAt(u - 1) === qo; ) (u -= 1), (o = !o);
|
|
else (t += n), (r = t.length - 1), (s.unclosed = !0);
|
|
while (o);
|
|
(s.value = t.slice(d + 1, r)),
|
|
(s.sourceEndIndex = s.unclosed ? r : r + 1),
|
|
e.push(s),
|
|
(d = r + 1),
|
|
(p = t.charCodeAt(d));
|
|
} else if (p === zt && t.charCodeAt(d + 1) === qn)
|
|
(r = t.indexOf("*/", d)),
|
|
(s = { type: "comment", sourceIndex: d, sourceEndIndex: r + 2 }),
|
|
r === -1 &&
|
|
((s.unclosed = !0), (r = t.length), (s.sourceEndIndex = r)),
|
|
(s.value = t.slice(d + 2, r)),
|
|
e.push(s),
|
|
(d = r + 2),
|
|
(p = t.charCodeAt(d));
|
|
else if ((p === zt || p === qn) && y && y.type === "function")
|
|
(s = t[d]),
|
|
e.push({
|
|
type: "word",
|
|
sourceIndex: d - k.length,
|
|
sourceEndIndex: d + s.length,
|
|
value: s,
|
|
}),
|
|
(d += 1),
|
|
(p = t.charCodeAt(d));
|
|
else if (p === zt || p === Ro || p === Mo)
|
|
(s = t[d]),
|
|
e.push({
|
|
type: "div",
|
|
sourceIndex: d - k.length,
|
|
sourceEndIndex: d + s.length,
|
|
value: s,
|
|
before: k,
|
|
after: "",
|
|
}),
|
|
(k = ""),
|
|
(d += 1),
|
|
(p = t.charCodeAt(d));
|
|
else if (Po === p) {
|
|
r = d;
|
|
do (r += 1), (p = t.charCodeAt(r));
|
|
while (p <= 32);
|
|
if (
|
|
((f = d),
|
|
(s = {
|
|
type: "function",
|
|
sourceIndex: d - b.length,
|
|
value: b,
|
|
before: t.slice(f + 1, r),
|
|
}),
|
|
(d = r),
|
|
b === "url" && p !== In && p !== Io)
|
|
) {
|
|
r -= 1;
|
|
do
|
|
if (((o = !1), (r = t.indexOf(")", r + 1)), ~r))
|
|
for (u = r; t.charCodeAt(u - 1) === qo; ) (u -= 1), (o = !o);
|
|
else (t += ")"), (r = t.length - 1), (s.unclosed = !0);
|
|
while (o);
|
|
c = r;
|
|
do (c -= 1), (p = t.charCodeAt(c));
|
|
while (p <= 32);
|
|
f < c
|
|
? (d !== c + 1
|
|
? (s.nodes = [
|
|
{
|
|
type: "word",
|
|
sourceIndex: d,
|
|
sourceEndIndex: c + 1,
|
|
value: t.slice(d, c + 1),
|
|
},
|
|
])
|
|
: (s.nodes = []),
|
|
s.unclosed && c + 1 !== r
|
|
? ((s.after = ""),
|
|
s.nodes.push({
|
|
type: "space",
|
|
sourceIndex: c + 1,
|
|
sourceEndIndex: r,
|
|
value: t.slice(c + 1, r),
|
|
}))
|
|
: ((s.after = t.slice(c + 1, r)), (s.sourceEndIndex = r)))
|
|
: ((s.after = ""), (s.nodes = [])),
|
|
(d = r + 1),
|
|
(s.sourceEndIndex = s.unclosed ? r : d),
|
|
(p = t.charCodeAt(d)),
|
|
e.push(s);
|
|
} else
|
|
(x += 1),
|
|
(s.after = ""),
|
|
(s.sourceEndIndex = d + 1),
|
|
e.push(s),
|
|
w.push(s),
|
|
(e = s.nodes = []),
|
|
(y = s);
|
|
b = "";
|
|
} else if (Do === p && x)
|
|
(d += 1),
|
|
(p = t.charCodeAt(d)),
|
|
(y.after = S),
|
|
(y.sourceEndIndex += S.length),
|
|
(S = ""),
|
|
(x -= 1),
|
|
(w[w.length - 1].sourceEndIndex = d),
|
|
w.pop(),
|
|
(y = w[x]),
|
|
(e = y.nodes);
|
|
else {
|
|
r = d;
|
|
do p === qo && (r += 1), (r += 1), (p = t.charCodeAt(r));
|
|
while (
|
|
r < m &&
|
|
!(
|
|
p <= 32 ||
|
|
p === In ||
|
|
p === Io ||
|
|
p === Ro ||
|
|
p === Mo ||
|
|
p === zt ||
|
|
p === Po ||
|
|
(p === qn && y && y.type === "function" && !0) ||
|
|
(p === zt && y.type === "function" && !0) ||
|
|
(p === Do && x)
|
|
)
|
|
);
|
|
(s = t.slice(d, r)),
|
|
Po === p
|
|
? (b = s)
|
|
: (A2 === s.charCodeAt(0) || _2 === s.charCodeAt(0)) &&
|
|
O2 === s.charCodeAt(1) &&
|
|
E2.test(s.slice(2))
|
|
? e.push({
|
|
type: "unicode-range",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
})
|
|
: e.push({
|
|
type: "word",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
}),
|
|
(d = r);
|
|
}
|
|
for (d = w.length - 1; d; d -= 1)
|
|
(w[d].unclosed = !0), (w[d].sourceEndIndex = t.length);
|
|
return w[0].nodes;
|
|
};
|
|
});
|
|
var Fh = v((I6, Bh) => {
|
|
l();
|
|
Bh.exports = function i(e, t, r) {
|
|
var n, a, s, o;
|
|
for (n = 0, a = e.length; n < a; n += 1)
|
|
(s = e[n]),
|
|
r || (o = t(s, n, e)),
|
|
o !== !1 &&
|
|
s.type === "function" &&
|
|
Array.isArray(s.nodes) &&
|
|
i(s.nodes, t, r),
|
|
r && t(s, n, e);
|
|
};
|
|
});
|
|
var jh = v((q6, $h) => {
|
|
l();
|
|
function Nh(i, e) {
|
|
var t = i.type,
|
|
r = i.value,
|
|
n,
|
|
a;
|
|
return e && (a = e(i)) !== void 0
|
|
? a
|
|
: t === "word" || t === "space"
|
|
? r
|
|
: t === "string"
|
|
? ((n = i.quote || ""), n + r + (i.unclosed ? "" : n))
|
|
: t === "comment"
|
|
? "/*" + r + (i.unclosed ? "" : "*/")
|
|
: t === "div"
|
|
? (i.before || "") + r + (i.after || "")
|
|
: Array.isArray(i.nodes)
|
|
? ((n = Lh(i.nodes, e)),
|
|
t !== "function"
|
|
? n
|
|
: r +
|
|
"(" +
|
|
(i.before || "") +
|
|
n +
|
|
(i.after || "") +
|
|
(i.unclosed ? "" : ")"))
|
|
: r;
|
|
}
|
|
function Lh(i, e) {
|
|
var t, r;
|
|
if (Array.isArray(i)) {
|
|
for (t = "", r = i.length - 1; ~r; r -= 1) t = Nh(i[r], e) + t;
|
|
return t;
|
|
}
|
|
return Nh(i, e);
|
|
}
|
|
$h.exports = Lh;
|
|
});
|
|
var Vh = v((R6, zh) => {
|
|
l();
|
|
var Rn = "-".charCodeAt(0),
|
|
Mn = "+".charCodeAt(0),
|
|
Bo = ".".charCodeAt(0),
|
|
T2 = "e".charCodeAt(0),
|
|
P2 = "E".charCodeAt(0);
|
|
function D2(i) {
|
|
var e = i.charCodeAt(0),
|
|
t;
|
|
if (e === Mn || e === Rn) {
|
|
if (((t = i.charCodeAt(1)), t >= 48 && t <= 57)) return !0;
|
|
var r = i.charCodeAt(2);
|
|
return t === Bo && r >= 48 && r <= 57;
|
|
}
|
|
return e === Bo
|
|
? ((t = i.charCodeAt(1)), t >= 48 && t <= 57)
|
|
: e >= 48 && e <= 57;
|
|
}
|
|
zh.exports = function (i) {
|
|
var e = 0,
|
|
t = i.length,
|
|
r,
|
|
n,
|
|
a;
|
|
if (t === 0 || !D2(i)) return !1;
|
|
for (
|
|
r = i.charCodeAt(e), (r === Mn || r === Rn) && e++;
|
|
e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57));
|
|
|
|
)
|
|
e += 1;
|
|
if (
|
|
((r = i.charCodeAt(e)),
|
|
(n = i.charCodeAt(e + 1)),
|
|
r === Bo && n >= 48 && n <= 57)
|
|
)
|
|
for (e += 2; e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57)); )
|
|
e += 1;
|
|
if (
|
|
((r = i.charCodeAt(e)),
|
|
(n = i.charCodeAt(e + 1)),
|
|
(a = i.charCodeAt(e + 2)),
|
|
(r === T2 || r === P2) &&
|
|
((n >= 48 && n <= 57) ||
|
|
((n === Mn || n === Rn) && a >= 48 && a <= 57)))
|
|
)
|
|
for (
|
|
e += n === Mn || n === Rn ? 3 : 2;
|
|
e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57));
|
|
|
|
)
|
|
e += 1;
|
|
return { number: i.slice(0, e), unit: i.slice(e) };
|
|
};
|
|
});
|
|
var Hh = v((M6, Gh) => {
|
|
l();
|
|
var I2 = Mh(),
|
|
Uh = Fh(),
|
|
Wh = jh();
|
|
function ft(i) {
|
|
return this instanceof ft ? ((this.nodes = I2(i)), this) : new ft(i);
|
|
}
|
|
ft.prototype.toString = function () {
|
|
return Array.isArray(this.nodes) ? Wh(this.nodes) : "";
|
|
};
|
|
ft.prototype.walk = function (i, e) {
|
|
return Uh(this.nodes, i, e), this;
|
|
};
|
|
ft.unit = Vh();
|
|
ft.walk = Uh;
|
|
ft.stringify = Wh;
|
|
Gh.exports = ft;
|
|
});
|
|
function No(i) {
|
|
return typeof i == "object" && i !== null;
|
|
}
|
|
function q2(i, e) {
|
|
let t = Ke(e);
|
|
do if ((t.pop(), (0, ri.default)(i, t) !== void 0)) break;
|
|
while (t.length);
|
|
return t.length ? t : void 0;
|
|
}
|
|
function Vt(i) {
|
|
return typeof i == "string"
|
|
? i
|
|
: i.reduce(
|
|
(e, t, r) =>
|
|
t.includes(".") ? `${e}[${t}]` : r === 0 ? t : `${e}.${t}`,
|
|
"",
|
|
);
|
|
}
|
|
function Qh(i) {
|
|
return i.map((e) => `'${e}'`).join(", ");
|
|
}
|
|
function Jh(i) {
|
|
return Qh(Object.keys(i));
|
|
}
|
|
function Lo(i, e, t, r = {}) {
|
|
let n = Array.isArray(e) ? Vt(e) : e.replace(/^['"]+|['"]+$/g, ""),
|
|
a = Array.isArray(e) ? e : Ke(n),
|
|
s = (0, ri.default)(i.theme, a, t);
|
|
if (s === void 0) {
|
|
let u = `'${n}' does not exist in your theme config.`,
|
|
c = a.slice(0, -1),
|
|
f = (0, ri.default)(i.theme, c);
|
|
if (No(f)) {
|
|
let d = Object.keys(f).filter((m) => Lo(i, [...c, m]).isValid),
|
|
p = (0, Yh.default)(a[a.length - 1], d);
|
|
p
|
|
? (u += ` Did you mean '${Vt([...c, p])}'?`)
|
|
: d.length > 0 &&
|
|
(u += ` '${Vt(c)}' has the following valid keys: ${Qh(d)}`);
|
|
} else {
|
|
let d = q2(i.theme, n);
|
|
if (d) {
|
|
let p = (0, ri.default)(i.theme, d);
|
|
No(p)
|
|
? (u += ` '${Vt(d)}' has the following keys: ${Jh(p)}`)
|
|
: (u += ` '${Vt(d)}' is not an object.`);
|
|
} else
|
|
u += ` Your theme has the following top-level keys: ${Jh(i.theme)}`;
|
|
}
|
|
return { isValid: !1, error: u };
|
|
}
|
|
if (
|
|
!(
|
|
typeof s == "string" ||
|
|
typeof s == "number" ||
|
|
typeof s == "function" ||
|
|
s instanceof String ||
|
|
s instanceof Number ||
|
|
Array.isArray(s)
|
|
)
|
|
) {
|
|
let u = `'${n}' was found but does not resolve to a string.`;
|
|
if (No(s)) {
|
|
let c = Object.keys(s).filter((f) => Lo(i, [...a, f]).isValid);
|
|
c.length &&
|
|
(u += ` Did you mean something like '${Vt([...a, c[0]])}'?`);
|
|
}
|
|
return { isValid: !1, error: u };
|
|
}
|
|
let [o] = a;
|
|
return { isValid: !0, value: Ge(o)(s, r) };
|
|
}
|
|
function R2(i, e, t) {
|
|
e = e.map((n) => Xh(i, n, t));
|
|
let r = [""];
|
|
for (let n of e)
|
|
n.type === "div" && n.value === ","
|
|
? r.push("")
|
|
: (r[r.length - 1] += Fo.default.stringify(n));
|
|
return r;
|
|
}
|
|
function Xh(i, e, t) {
|
|
if (e.type === "function" && t[e.value] !== void 0) {
|
|
let r = R2(i, e.nodes, t);
|
|
(e.type = "word"), (e.value = t[e.value](i, ...r));
|
|
}
|
|
return e;
|
|
}
|
|
function M2(i, e, t) {
|
|
return Object.keys(t).some((n) => e.includes(`${n}(`))
|
|
? (0, Fo.default)(e)
|
|
.walk((n) => {
|
|
Xh(i, n, t);
|
|
})
|
|
.toString()
|
|
: e;
|
|
}
|
|
function* F2(i) {
|
|
i = i.replace(/^['"]+|['"]+$/g, "");
|
|
let e = i.match(/^([^\s]+)(?![^\[]*\])(?:\s*\/\s*([^\/\s]+))$/),
|
|
t;
|
|
yield [i, void 0], e && ((i = e[1]), (t = e[2]), yield [i, t]);
|
|
}
|
|
function N2(i, e, t) {
|
|
let r = Array.from(F2(e)).map(([n, a]) =>
|
|
Object.assign(Lo(i, n, t, { opacityValue: a }), {
|
|
resolvedPath: n,
|
|
alpha: a,
|
|
}),
|
|
);
|
|
return r.find((n) => n.isValid) ?? r[0];
|
|
}
|
|
function Kh(i) {
|
|
let e = i.tailwindConfig,
|
|
t = {
|
|
theme: (r, n, ...a) => {
|
|
let {
|
|
isValid: s,
|
|
value: o,
|
|
error: u,
|
|
alpha: c,
|
|
} = N2(e, n, a.length ? a : void 0);
|
|
if (!s) {
|
|
let p = r.parent,
|
|
m = p?.raws.tailwind?.candidate;
|
|
if (p && m !== void 0) {
|
|
i.markInvalidUtilityNode(p),
|
|
p.remove(),
|
|
F.warn("invalid-theme-key-in-class", [
|
|
`The utility \`${m}\` contains an invalid theme value and was not generated.`,
|
|
]);
|
|
return;
|
|
}
|
|
throw r.error(u);
|
|
}
|
|
let f = Ct(o),
|
|
d = f !== void 0 && typeof f == "function";
|
|
return (
|
|
(c !== void 0 || d) && (c === void 0 && (c = 1), (o = De(f, c, f))),
|
|
o
|
|
);
|
|
},
|
|
screen: (r, n) => {
|
|
n = n.replace(/^['"]+/g, "").replace(/['"]+$/g, "");
|
|
let s = at(e.theme.screens).find(({ name: o }) => o === n);
|
|
if (!s)
|
|
throw r.error(`The '${n}' screen does not exist in your theme.`);
|
|
return st(s);
|
|
},
|
|
};
|
|
return (r) => {
|
|
r.walk((n) => {
|
|
let a = B2[n.type];
|
|
a !== void 0 && (n[a] = M2(n, n[a], t));
|
|
});
|
|
};
|
|
}
|
|
var ri,
|
|
Yh,
|
|
Fo,
|
|
B2,
|
|
Zh = C(() => {
|
|
l();
|
|
(ri = K(Ls())), (Yh = K(qh()));
|
|
Hr();
|
|
Fo = K(Hh());
|
|
hn();
|
|
cn();
|
|
pi();
|
|
or();
|
|
cr();
|
|
Oe();
|
|
B2 = { atrule: "params", decl: "value" };
|
|
});
|
|
function em({ tailwindConfig: { theme: i } }) {
|
|
return function (e) {
|
|
e.walkAtRules("screen", (t) => {
|
|
let r = t.params,
|
|
a = at(i.screens).find(({ name: s }) => s === r);
|
|
if (!a) throw t.error(`No \`${r}\` screen found.`);
|
|
(t.name = "media"), (t.params = st(a));
|
|
});
|
|
};
|
|
}
|
|
var tm = C(() => {
|
|
l();
|
|
hn();
|
|
cn();
|
|
});
|
|
function L2(i) {
|
|
let e = i
|
|
.filter((o) =>
|
|
o.type !== "pseudo" || o.nodes.length > 0
|
|
? !0
|
|
: o.value.startsWith("::") ||
|
|
[":before", ":after", ":first-line", ":first-letter"].includes(
|
|
o.value,
|
|
),
|
|
)
|
|
.reverse(),
|
|
t = new Set(["tag", "class", "id", "attribute"]),
|
|
r = e.findIndex((o) => t.has(o.type));
|
|
if (r === -1) return e.reverse().join("").trim();
|
|
let n = e[r],
|
|
a = rm[n.type] ? rm[n.type](n) : n;
|
|
e = e.slice(0, r);
|
|
let s = e.findIndex((o) => o.type === "combinator" && o.value === ">");
|
|
return (
|
|
s !== -1 && (e.splice(0, s), e.unshift(Bn.default.universal())),
|
|
[a, ...e.reverse()].join("").trim()
|
|
);
|
|
}
|
|
function j2(i) {
|
|
return $o.has(i) || $o.set(i, $2.transformSync(i)), $o.get(i);
|
|
}
|
|
function jo({ tailwindConfig: i }) {
|
|
return (e) => {
|
|
let t = new Map(),
|
|
r = new Set();
|
|
if (
|
|
(e.walkAtRules("defaults", (n) => {
|
|
if (n.nodes && n.nodes.length > 0) {
|
|
r.add(n);
|
|
return;
|
|
}
|
|
let a = n.params;
|
|
t.has(a) || t.set(a, new Set()), t.get(a).add(n.parent), n.remove();
|
|
}),
|
|
Z(i, "optimizeUniversalDefaults"))
|
|
)
|
|
for (let n of r) {
|
|
let a = new Map(),
|
|
s = t.get(n.params) ?? [];
|
|
for (let o of s)
|
|
for (let u of j2(o.selector)) {
|
|
let c = u.includes(":-") || u.includes("::-") ? u : "__DEFAULT__",
|
|
f = a.get(c) ?? new Set();
|
|
a.set(c, f), f.add(u);
|
|
}
|
|
if (Z(i, "optimizeUniversalDefaults")) {
|
|
if (a.size === 0) {
|
|
n.remove();
|
|
continue;
|
|
}
|
|
for (let [, o] of a) {
|
|
let u = V.rule({ source: n.source });
|
|
(u.selectors = [...o]),
|
|
u.append(n.nodes.map((c) => c.clone())),
|
|
n.before(u);
|
|
}
|
|
}
|
|
n.remove();
|
|
}
|
|
else if (r.size) {
|
|
let n = V.rule({ selectors: ["*", "::before", "::after"] });
|
|
for (let s of r)
|
|
n.append(s.nodes),
|
|
n.parent || s.before(n),
|
|
n.source || (n.source = s.source),
|
|
s.remove();
|
|
let a = n.clone({ selectors: ["::backdrop"] });
|
|
n.after(a);
|
|
}
|
|
};
|
|
}
|
|
var Bn,
|
|
rm,
|
|
$2,
|
|
$o,
|
|
im = C(() => {
|
|
l();
|
|
nt();
|
|
Bn = K(Re());
|
|
ze();
|
|
rm = {
|
|
id(i) {
|
|
return Bn.default.attribute({
|
|
attribute: "id",
|
|
operator: "=",
|
|
value: i.value,
|
|
quoteMark: '"',
|
|
});
|
|
},
|
|
};
|
|
($2 = (0, Bn.default)((i) =>
|
|
i.map((e) => {
|
|
let t = e
|
|
.split((r) => r.type === "combinator" && r.value === " ")
|
|
.pop();
|
|
return L2(t);
|
|
}),
|
|
)),
|
|
($o = new Map());
|
|
});
|
|
function zo() {
|
|
function i(e) {
|
|
let t = null;
|
|
e.each((r) => {
|
|
if (!z2.has(r.type)) {
|
|
t = null;
|
|
return;
|
|
}
|
|
if (t === null) {
|
|
t = r;
|
|
return;
|
|
}
|
|
let n = nm[r.type];
|
|
r.type === "atrule" && r.name === "font-face"
|
|
? (t = r)
|
|
: n.every(
|
|
(a) =>
|
|
(r[a] ?? "").replace(/\s+/g, " ") ===
|
|
(t[a] ?? "").replace(/\s+/g, " "),
|
|
)
|
|
? (r.nodes && t.append(r.nodes), r.remove())
|
|
: (t = r);
|
|
}),
|
|
e.each((r) => {
|
|
r.type === "atrule" && i(r);
|
|
});
|
|
}
|
|
return (e) => {
|
|
i(e);
|
|
};
|
|
}
|
|
var nm,
|
|
z2,
|
|
sm = C(() => {
|
|
l();
|
|
(nm = { atrule: ["name", "params"], rule: ["selector"] }),
|
|
(z2 = new Set(Object.keys(nm)));
|
|
});
|
|
function Vo() {
|
|
return (i) => {
|
|
i.walkRules((e) => {
|
|
let t = new Map(),
|
|
r = new Set([]),
|
|
n = new Map();
|
|
e.walkDecls((a) => {
|
|
if (a.parent === e) {
|
|
if (t.has(a.prop)) {
|
|
if (t.get(a.prop).value === a.value) {
|
|
r.add(t.get(a.prop)), t.set(a.prop, a);
|
|
return;
|
|
}
|
|
n.has(a.prop) || n.set(a.prop, new Set()),
|
|
n.get(a.prop).add(t.get(a.prop)),
|
|
n.get(a.prop).add(a);
|
|
}
|
|
t.set(a.prop, a);
|
|
}
|
|
});
|
|
for (let a of r) a.remove();
|
|
for (let a of n.values()) {
|
|
let s = new Map();
|
|
for (let o of a) {
|
|
let u = U2(o.value);
|
|
u !== null && (s.has(u) || s.set(u, new Set()), s.get(u).add(o));
|
|
}
|
|
for (let o of s.values()) {
|
|
let u = Array.from(o).slice(0, -1);
|
|
for (let c of u) c.remove();
|
|
}
|
|
}
|
|
});
|
|
};
|
|
}
|
|
function U2(i) {
|
|
let e = /^-?\d*.?\d+([\w%]+)?$/g.exec(i);
|
|
return e ? e[1] ?? V2 : null;
|
|
}
|
|
var V2,
|
|
am = C(() => {
|
|
l();
|
|
V2 = Symbol("unitless-number");
|
|
});
|
|
function W2(i) {
|
|
if (!i.walkAtRules) return;
|
|
let e = new Set();
|
|
if (
|
|
(i.walkAtRules("apply", (t) => {
|
|
e.add(t.parent);
|
|
}),
|
|
e.size !== 0)
|
|
)
|
|
for (let t of e) {
|
|
let r = [],
|
|
n = [];
|
|
for (let a of t.nodes)
|
|
a.type === "atrule" && a.name === "apply"
|
|
? (n.length > 0 && (r.push(n), (n = [])), r.push([a]))
|
|
: n.push(a);
|
|
if ((n.length > 0 && r.push(n), r.length !== 1)) {
|
|
for (let a of [...r].reverse()) {
|
|
let s = t.clone({ nodes: [] });
|
|
s.append(a), t.after(s);
|
|
}
|
|
t.remove();
|
|
}
|
|
}
|
|
}
|
|
function Fn() {
|
|
return (i) => {
|
|
W2(i);
|
|
};
|
|
}
|
|
var om = C(() => {
|
|
l();
|
|
});
|
|
function G2(i) {
|
|
return i.type === "root";
|
|
}
|
|
function H2(i) {
|
|
return i.type === "atrule" && i.name === "layer";
|
|
}
|
|
function lm(i) {
|
|
return (e, t) => {
|
|
let r = !1;
|
|
e.walkAtRules("tailwind", (n) => {
|
|
if (r) return !1;
|
|
if (n.parent && !(G2(n.parent) || H2(n.parent)))
|
|
return (
|
|
(r = !0),
|
|
n.warn(
|
|
t,
|
|
[
|
|
"Nested @tailwind rules were detected, but are not supported.",
|
|
"Consider using a prefix to scope Tailwind's classes: https://tailwindcss.com/docs/configuration#prefix",
|
|
"Alternatively, use the important selector strategy: https://tailwindcss.com/docs/configuration#selector-strategy",
|
|
].join(`
|
|
`),
|
|
),
|
|
!1
|
|
);
|
|
}),
|
|
e.walkRules((n) => {
|
|
if (r) return !1;
|
|
n.walkRules(
|
|
(a) => (
|
|
(r = !0),
|
|
a.warn(
|
|
t,
|
|
[
|
|
"Nested CSS was detected, but CSS nesting has not been configured correctly.",
|
|
"Please enable a CSS nesting plugin *before* Tailwind in your configuration.",
|
|
"See how here: https://tailwindcss.com/docs/using-with-preprocessors#nesting",
|
|
].join(`
|
|
`),
|
|
),
|
|
!1
|
|
),
|
|
);
|
|
});
|
|
};
|
|
}
|
|
var um = C(() => {
|
|
l();
|
|
});
|
|
function Nn(i) {
|
|
return async function (e, t) {
|
|
let { tailwindDirectives: r, applyDirectives: n } = Co(e);
|
|
lm()(e, t), Fn()(e, t);
|
|
let a = i({
|
|
tailwindDirectives: r,
|
|
applyDirectives: n,
|
|
registerDependency(s) {
|
|
t.messages.push({ plugin: "tailwindcss", parent: t.opts.from, ...s });
|
|
},
|
|
createContext(s, o) {
|
|
return mo(s, o, e);
|
|
},
|
|
})(e, t);
|
|
if (a.tailwindConfig.separator === "-")
|
|
throw new Error(
|
|
"The '-' character cannot be used as a custom separator in JIT mode due to parsing ambiguity. Please use another character like '_' instead.",
|
|
);
|
|
_u(a.tailwindConfig),
|
|
await Oo(a)(e, t),
|
|
Fn()(e, t),
|
|
To(a)(e, t),
|
|
Kh(a)(e, t),
|
|
em(a)(e, t),
|
|
jo(a)(e, t),
|
|
zo(a)(e, t),
|
|
Vo(a)(e, t);
|
|
};
|
|
}
|
|
var fm = C(() => {
|
|
l();
|
|
mh();
|
|
_h();
|
|
Ih();
|
|
Zh();
|
|
tm();
|
|
im();
|
|
sm();
|
|
am();
|
|
om();
|
|
um();
|
|
Xr();
|
|
ze();
|
|
});
|
|
function cm(i, e) {
|
|
let t = null,
|
|
r = null;
|
|
return (
|
|
i.walkAtRules("config", (n) => {
|
|
if (((r = n.source?.input.file ?? e.opts.from ?? null), r === null))
|
|
throw n.error(
|
|
"The `@config` directive cannot be used without setting `from` in your PostCSS config.",
|
|
);
|
|
if (t)
|
|
throw n.error("Only one `@config` directive is allowed per file.");
|
|
let a = n.params.match(/(['"])(.*?)\1/);
|
|
if (!a)
|
|
throw n.error(
|
|
"A path is required when using the `@config` directive.",
|
|
);
|
|
let s = a[2];
|
|
if (ee.isAbsolute(s))
|
|
throw n.error(
|
|
"The `@config` directive cannot be used with an absolute path.",
|
|
);
|
|
if (((t = ee.resolve(ee.dirname(r), s)), !re.existsSync(t)))
|
|
throw n.error(
|
|
`The config file at "${s}" does not exist. Make sure the path is correct and the file exists.`,
|
|
);
|
|
n.remove();
|
|
}),
|
|
t || null
|
|
);
|
|
}
|
|
var pm = C(() => {
|
|
l();
|
|
je();
|
|
gt();
|
|
});
|
|
var dm = v((vI, Uo) => {
|
|
l();
|
|
hh();
|
|
fm();
|
|
ot();
|
|
pm();
|
|
Uo.exports = function (e) {
|
|
return {
|
|
postcssPlugin: "tailwindcss",
|
|
plugins: [
|
|
Pe.DEBUG &&
|
|
function (t) {
|
|
return (
|
|
console.log(`
|
|
`),
|
|
console.time("JIT TOTAL"),
|
|
t
|
|
);
|
|
},
|
|
async function (t, r) {
|
|
e = cm(t, r) ?? e;
|
|
let n = So(e);
|
|
if (t.type === "document") {
|
|
let a = t.nodes.filter((s) => s.type === "root");
|
|
for (let s of a) s.type === "root" && (await Nn(n)(s, r));
|
|
return;
|
|
}
|
|
await Nn(n)(t, r);
|
|
},
|
|
!1,
|
|
Pe.DEBUG &&
|
|
function (t) {
|
|
return (
|
|
console.timeEnd("JIT TOTAL"),
|
|
console.log(`
|
|
`),
|
|
t
|
|
);
|
|
},
|
|
].filter(Boolean),
|
|
};
|
|
};
|
|
Uo.exports.postcss = !0;
|
|
});
|
|
var mm = v((xI, hm) => {
|
|
l();
|
|
hm.exports = dm();
|
|
});
|
|
var Wo = v((kI, gm) => {
|
|
l();
|
|
gm.exports = () => [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 114",
|
|
"chrome 113",
|
|
"chrome 109",
|
|
"edge 114",
|
|
"firefox 114",
|
|
"ios_saf 16.5",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.1",
|
|
"opera 99",
|
|
"safari 16.5",
|
|
"samsung 21",
|
|
];
|
|
});
|
|
var Ln = {};
|
|
Ae(Ln, { agents: () => Y2, feature: () => Q2 });
|
|
function Q2() {
|
|
return {
|
|
status: "cr",
|
|
title: "CSS Feature Queries",
|
|
stats: {
|
|
ie: { 6: "n", 7: "n", 8: "n", 9: "n", 10: "n", 11: "n", 5.5: "n" },
|
|
edge: {
|
|
12: "y",
|
|
13: "y",
|
|
14: "y",
|
|
15: "y",
|
|
16: "y",
|
|
17: "y",
|
|
18: "y",
|
|
79: "y",
|
|
80: "y",
|
|
81: "y",
|
|
83: "y",
|
|
84: "y",
|
|
85: "y",
|
|
86: "y",
|
|
87: "y",
|
|
88: "y",
|
|
89: "y",
|
|
90: "y",
|
|
91: "y",
|
|
92: "y",
|
|
93: "y",
|
|
94: "y",
|
|
95: "y",
|
|
96: "y",
|
|
97: "y",
|
|
98: "y",
|
|
99: "y",
|
|
100: "y",
|
|
101: "y",
|
|
102: "y",
|
|
103: "y",
|
|
104: "y",
|
|
105: "y",
|
|
106: "y",
|
|
107: "y",
|
|
108: "y",
|
|
109: "y",
|
|
110: "y",
|
|
111: "y",
|
|
112: "y",
|
|
113: "y",
|
|
114: "y",
|
|
},
|
|
firefox: {
|
|
2: "n",
|
|
3: "n",
|
|
4: "n",
|
|
5: "n",
|
|
6: "n",
|
|
7: "n",
|
|
8: "n",
|
|
9: "n",
|
|
10: "n",
|
|
11: "n",
|
|
12: "n",
|
|
13: "n",
|
|
14: "n",
|
|
15: "n",
|
|
16: "n",
|
|
17: "n",
|
|
18: "n",
|
|
19: "n",
|
|
20: "n",
|
|
21: "n",
|
|
22: "y",
|
|
23: "y",
|
|
24: "y",
|
|
25: "y",
|
|
26: "y",
|
|
27: "y",
|
|
28: "y",
|
|
29: "y",
|
|
30: "y",
|
|
31: "y",
|
|
32: "y",
|
|
33: "y",
|
|
34: "y",
|
|
35: "y",
|
|
36: "y",
|
|
37: "y",
|
|
38: "y",
|
|
39: "y",
|
|
40: "y",
|
|
41: "y",
|
|
42: "y",
|
|
43: "y",
|
|
44: "y",
|
|
45: "y",
|
|
46: "y",
|
|
47: "y",
|
|
48: "y",
|
|
49: "y",
|
|
50: "y",
|
|
51: "y",
|
|
52: "y",
|
|
53: "y",
|
|
54: "y",
|
|
55: "y",
|
|
56: "y",
|
|
57: "y",
|
|
58: "y",
|
|
59: "y",
|
|
60: "y",
|
|
61: "y",
|
|
62: "y",
|
|
63: "y",
|
|
64: "y",
|
|
65: "y",
|
|
66: "y",
|
|
67: "y",
|
|
68: "y",
|
|
69: "y",
|
|
70: "y",
|
|
71: "y",
|
|
72: "y",
|
|
73: "y",
|
|
74: "y",
|
|
75: "y",
|
|
76: "y",
|
|
77: "y",
|
|
78: "y",
|
|
79: "y",
|
|
80: "y",
|
|
81: "y",
|
|
82: "y",
|
|
83: "y",
|
|
84: "y",
|
|
85: "y",
|
|
86: "y",
|
|
87: "y",
|
|
88: "y",
|
|
89: "y",
|
|
90: "y",
|
|
91: "y",
|
|
92: "y",
|
|
93: "y",
|
|
94: "y",
|
|
95: "y",
|
|
96: "y",
|
|
97: "y",
|
|
98: "y",
|
|
99: "y",
|
|
100: "y",
|
|
101: "y",
|
|
102: "y",
|
|
103: "y",
|
|
104: "y",
|
|
105: "y",
|
|
106: "y",
|
|
107: "y",
|
|
108: "y",
|
|
109: "y",
|
|
110: "y",
|
|
111: "y",
|
|
112: "y",
|
|
113: "y",
|
|
114: "y",
|
|
115: "y",
|
|
116: "y",
|
|
117: "y",
|
|
3.5: "n",
|
|
3.6: "n",
|
|
},
|
|
chrome: {
|
|
4: "n",
|
|
5: "n",
|
|
6: "n",
|
|
7: "n",
|
|
8: "n",
|
|
9: "n",
|
|
10: "n",
|
|
11: "n",
|
|
12: "n",
|
|
13: "n",
|
|
14: "n",
|
|
15: "n",
|
|
16: "n",
|
|
17: "n",
|
|
18: "n",
|
|
19: "n",
|
|
20: "n",
|
|
21: "n",
|
|
22: "n",
|
|
23: "n",
|
|
24: "n",
|
|
25: "n",
|
|
26: "n",
|
|
27: "n",
|
|
28: "y",
|
|
29: "y",
|
|
30: "y",
|
|
31: "y",
|
|
32: "y",
|
|
33: "y",
|
|
34: "y",
|
|
35: "y",
|
|
36: "y",
|
|
37: "y",
|
|
38: "y",
|
|
39: "y",
|
|
40: "y",
|
|
41: "y",
|
|
42: "y",
|
|
43: "y",
|
|
44: "y",
|
|
45: "y",
|
|
46: "y",
|
|
47: "y",
|
|
48: "y",
|
|
49: "y",
|
|
50: "y",
|
|
51: "y",
|
|
52: "y",
|
|
53: "y",
|
|
54: "y",
|
|
55: "y",
|
|
56: "y",
|
|
57: "y",
|
|
58: "y",
|
|
59: "y",
|
|
60: "y",
|
|
61: "y",
|
|
62: "y",
|
|
63: "y",
|
|
64: "y",
|
|
65: "y",
|
|
66: "y",
|
|
67: "y",
|
|
68: "y",
|
|
69: "y",
|
|
70: "y",
|
|
71: "y",
|
|
72: "y",
|
|
73: "y",
|
|
74: "y",
|
|
75: "y",
|
|
76: "y",
|
|
77: "y",
|
|
78: "y",
|
|
79: "y",
|
|
80: "y",
|
|
81: "y",
|
|
83: "y",
|
|
84: "y",
|
|
85: "y",
|
|
86: "y",
|
|
87: "y",
|
|
88: "y",
|
|
89: "y",
|
|
90: "y",
|
|
91: "y",
|
|
92: "y",
|
|
93: "y",
|
|
94: "y",
|
|
95: "y",
|
|
96: "y",
|
|
97: "y",
|
|
98: "y",
|
|
99: "y",
|
|
100: "y",
|
|
101: "y",
|
|
102: "y",
|
|
103: "y",
|
|
104: "y",
|
|
105: "y",
|
|
106: "y",
|
|
107: "y",
|
|
108: "y",
|
|
109: "y",
|
|
110: "y",
|
|
111: "y",
|
|
112: "y",
|
|
113: "y",
|
|
114: "y",
|
|
115: "y",
|
|
116: "y",
|
|
117: "y",
|
|
},
|
|
safari: {
|
|
4: "n",
|
|
5: "n",
|
|
6: "n",
|
|
7: "n",
|
|
8: "n",
|
|
9: "y",
|
|
10: "y",
|
|
11: "y",
|
|
12: "y",
|
|
13: "y",
|
|
14: "y",
|
|
15: "y",
|
|
17: "y",
|
|
9.1: "y",
|
|
10.1: "y",
|
|
11.1: "y",
|
|
12.1: "y",
|
|
13.1: "y",
|
|
14.1: "y",
|
|
15.1: "y",
|
|
"15.2-15.3": "y",
|
|
15.4: "y",
|
|
15.5: "y",
|
|
15.6: "y",
|
|
"16.0": "y",
|
|
16.1: "y",
|
|
16.2: "y",
|
|
16.3: "y",
|
|
16.4: "y",
|
|
16.5: "y",
|
|
16.6: "y",
|
|
TP: "y",
|
|
3.1: "n",
|
|
3.2: "n",
|
|
5.1: "n",
|
|
6.1: "n",
|
|
7.1: "n",
|
|
},
|
|
opera: {
|
|
9: "n",
|
|
11: "n",
|
|
12: "n",
|
|
15: "y",
|
|
16: "y",
|
|
17: "y",
|
|
18: "y",
|
|
19: "y",
|
|
20: "y",
|
|
21: "y",
|
|
22: "y",
|
|
23: "y",
|
|
24: "y",
|
|
25: "y",
|
|
26: "y",
|
|
27: "y",
|
|
28: "y",
|
|
29: "y",
|
|
30: "y",
|
|
31: "y",
|
|
32: "y",
|
|
33: "y",
|
|
34: "y",
|
|
35: "y",
|
|
36: "y",
|
|
37: "y",
|
|
38: "y",
|
|
39: "y",
|
|
40: "y",
|
|
41: "y",
|
|
42: "y",
|
|
43: "y",
|
|
44: "y",
|
|
45: "y",
|
|
46: "y",
|
|
47: "y",
|
|
48: "y",
|
|
49: "y",
|
|
50: "y",
|
|
51: "y",
|
|
52: "y",
|
|
53: "y",
|
|
54: "y",
|
|
55: "y",
|
|
56: "y",
|
|
57: "y",
|
|
58: "y",
|
|
60: "y",
|
|
62: "y",
|
|
63: "y",
|
|
64: "y",
|
|
65: "y",
|
|
66: "y",
|
|
67: "y",
|
|
68: "y",
|
|
69: "y",
|
|
70: "y",
|
|
71: "y",
|
|
72: "y",
|
|
73: "y",
|
|
74: "y",
|
|
75: "y",
|
|
76: "y",
|
|
77: "y",
|
|
78: "y",
|
|
79: "y",
|
|
80: "y",
|
|
81: "y",
|
|
82: "y",
|
|
83: "y",
|
|
84: "y",
|
|
85: "y",
|
|
86: "y",
|
|
87: "y",
|
|
88: "y",
|
|
89: "y",
|
|
90: "y",
|
|
91: "y",
|
|
92: "y",
|
|
93: "y",
|
|
94: "y",
|
|
95: "y",
|
|
96: "y",
|
|
97: "y",
|
|
98: "y",
|
|
99: "y",
|
|
100: "y",
|
|
12.1: "y",
|
|
"9.5-9.6": "n",
|
|
"10.0-10.1": "n",
|
|
10.5: "n",
|
|
10.6: "n",
|
|
11.1: "n",
|
|
11.5: "n",
|
|
11.6: "n",
|
|
},
|
|
ios_saf: {
|
|
8: "n",
|
|
17: "y",
|
|
"9.0-9.2": "y",
|
|
9.3: "y",
|
|
"10.0-10.2": "y",
|
|
10.3: "y",
|
|
"11.0-11.2": "y",
|
|
"11.3-11.4": "y",
|
|
"12.0-12.1": "y",
|
|
"12.2-12.5": "y",
|
|
"13.0-13.1": "y",
|
|
13.2: "y",
|
|
13.3: "y",
|
|
"13.4-13.7": "y",
|
|
"14.0-14.4": "y",
|
|
"14.5-14.8": "y",
|
|
"15.0-15.1": "y",
|
|
"15.2-15.3": "y",
|
|
15.4: "y",
|
|
15.5: "y",
|
|
15.6: "y",
|
|
"16.0": "y",
|
|
16.1: "y",
|
|
16.2: "y",
|
|
16.3: "y",
|
|
16.4: "y",
|
|
16.5: "y",
|
|
16.6: "y",
|
|
3.2: "n",
|
|
"4.0-4.1": "n",
|
|
"4.2-4.3": "n",
|
|
"5.0-5.1": "n",
|
|
"6.0-6.1": "n",
|
|
"7.0-7.1": "n",
|
|
"8.1-8.4": "n",
|
|
},
|
|
op_mini: { all: "y" },
|
|
android: {
|
|
3: "n",
|
|
4: "n",
|
|
114: "y",
|
|
4.4: "y",
|
|
"4.4.3-4.4.4": "y",
|
|
2.1: "n",
|
|
2.2: "n",
|
|
2.3: "n",
|
|
4.1: "n",
|
|
"4.2-4.3": "n",
|
|
},
|
|
bb: { 7: "n", 10: "n" },
|
|
op_mob: {
|
|
10: "n",
|
|
11: "n",
|
|
12: "n",
|
|
73: "y",
|
|
11.1: "n",
|
|
11.5: "n",
|
|
12.1: "n",
|
|
},
|
|
and_chr: { 114: "y" },
|
|
and_ff: { 115: "y" },
|
|
ie_mob: { 10: "n", 11: "n" },
|
|
and_uc: { 15.5: "y" },
|
|
samsung: {
|
|
4: "y",
|
|
20: "y",
|
|
21: "y",
|
|
"5.0-5.4": "y",
|
|
"6.2-6.4": "y",
|
|
"7.2-7.4": "y",
|
|
8.2: "y",
|
|
9.2: "y",
|
|
10.1: "y",
|
|
"11.1-11.2": "y",
|
|
"12.0": "y",
|
|
"13.0": "y",
|
|
"14.0": "y",
|
|
"15.0": "y",
|
|
"16.0": "y",
|
|
"17.0": "y",
|
|
"18.0": "y",
|
|
"19.0": "y",
|
|
},
|
|
and_qq: { 13.1: "y" },
|
|
baidu: { 13.18: "y" },
|
|
kaios: { 2.5: "y", "3.0-3.1": "y" },
|
|
},
|
|
};
|
|
}
|
|
var Y2,
|
|
$n = C(() => {
|
|
l();
|
|
Y2 = {
|
|
ie: { prefix: "ms" },
|
|
edge: {
|
|
prefix: "webkit",
|
|
prefix_exceptions: {
|
|
12: "ms",
|
|
13: "ms",
|
|
14: "ms",
|
|
15: "ms",
|
|
16: "ms",
|
|
17: "ms",
|
|
18: "ms",
|
|
},
|
|
},
|
|
firefox: { prefix: "moz" },
|
|
chrome: { prefix: "webkit" },
|
|
safari: { prefix: "webkit" },
|
|
opera: {
|
|
prefix: "webkit",
|
|
prefix_exceptions: {
|
|
9: "o",
|
|
11: "o",
|
|
12: "o",
|
|
"9.5-9.6": "o",
|
|
"10.0-10.1": "o",
|
|
10.5: "o",
|
|
10.6: "o",
|
|
11.1: "o",
|
|
11.5: "o",
|
|
11.6: "o",
|
|
12.1: "o",
|
|
},
|
|
},
|
|
ios_saf: { prefix: "webkit" },
|
|
op_mini: { prefix: "o" },
|
|
android: { prefix: "webkit" },
|
|
bb: { prefix: "webkit" },
|
|
op_mob: { prefix: "o", prefix_exceptions: { 73: "webkit" } },
|
|
and_chr: { prefix: "webkit" },
|
|
and_ff: { prefix: "moz" },
|
|
ie_mob: { prefix: "ms" },
|
|
and_uc: { prefix: "webkit", prefix_exceptions: { 15.5: "webkit" } },
|
|
samsung: { prefix: "webkit" },
|
|
and_qq: { prefix: "webkit" },
|
|
baidu: { prefix: "webkit" },
|
|
kaios: { prefix: "moz" },
|
|
};
|
|
});
|
|
var ym = v(() => {
|
|
l();
|
|
});
|
|
var fe = v((AI, ct) => {
|
|
l();
|
|
var { list: Go } = ge();
|
|
ct.exports.error = function (i) {
|
|
let e = new Error(i);
|
|
throw ((e.autoprefixer = !0), e);
|
|
};
|
|
ct.exports.uniq = function (i) {
|
|
return [...new Set(i)];
|
|
};
|
|
ct.exports.removeNote = function (i) {
|
|
return i.includes(" ") ? i.split(" ")[0] : i;
|
|
};
|
|
ct.exports.escapeRegexp = function (i) {
|
|
return i.replace(/[$()*+-.?[\\\]^{|}]/g, "\\$&");
|
|
};
|
|
ct.exports.regexp = function (i, e = !0) {
|
|
return (
|
|
e && (i = this.escapeRegexp(i)),
|
|
new RegExp(`(^|[\\s,(])(${i}($|[\\s(,]))`, "gi")
|
|
);
|
|
};
|
|
ct.exports.editList = function (i, e) {
|
|
let t = Go.comma(i),
|
|
r = e(t, []);
|
|
if (t === r) return i;
|
|
let n = i.match(/,\s*/);
|
|
return (n = n ? n[0] : ", "), r.join(n);
|
|
};
|
|
ct.exports.splitSelector = function (i) {
|
|
return Go.comma(i).map((e) =>
|
|
Go.space(e).map((t) => t.split(/(?=\.|#)/g)),
|
|
);
|
|
};
|
|
});
|
|
var pt = v((_I, vm) => {
|
|
l();
|
|
var J2 = Wo(),
|
|
wm = ($n(), Ln).agents,
|
|
X2 = fe(),
|
|
bm = class {
|
|
static prefixes() {
|
|
if (this.prefixesCache) return this.prefixesCache;
|
|
this.prefixesCache = [];
|
|
for (let e in wm) this.prefixesCache.push(`-${wm[e].prefix}-`);
|
|
return (
|
|
(this.prefixesCache = X2.uniq(this.prefixesCache).sort(
|
|
(e, t) => t.length - e.length,
|
|
)),
|
|
this.prefixesCache
|
|
);
|
|
}
|
|
static withPrefix(e) {
|
|
return (
|
|
this.prefixesRegexp ||
|
|
(this.prefixesRegexp = new RegExp(this.prefixes().join("|"))),
|
|
this.prefixesRegexp.test(e)
|
|
);
|
|
}
|
|
constructor(e, t, r, n) {
|
|
(this.data = e),
|
|
(this.options = r || {}),
|
|
(this.browserslistOpts = n || {}),
|
|
(this.selected = this.parse(t));
|
|
}
|
|
parse(e) {
|
|
let t = {};
|
|
for (let r in this.browserslistOpts) t[r] = this.browserslistOpts[r];
|
|
return (t.path = this.options.from), J2(e, t);
|
|
}
|
|
prefix(e) {
|
|
let [t, r] = e.split(" "),
|
|
n = this.data[t],
|
|
a = n.prefix_exceptions && n.prefix_exceptions[r];
|
|
return a || (a = n.prefix), `-${a}-`;
|
|
}
|
|
isSelected(e) {
|
|
return this.selected.includes(e);
|
|
}
|
|
};
|
|
vm.exports = bm;
|
|
});
|
|
var ii = v((OI, xm) => {
|
|
l();
|
|
xm.exports = {
|
|
prefix(i) {
|
|
let e = i.match(/^(-\w+-)/);
|
|
return e ? e[0] : "";
|
|
},
|
|
unprefixed(i) {
|
|
return i.replace(/^-\w+-/, "");
|
|
},
|
|
};
|
|
});
|
|
var Ut = v((EI, Sm) => {
|
|
l();
|
|
var K2 = pt(),
|
|
km = ii(),
|
|
Z2 = fe();
|
|
function Ho(i, e) {
|
|
let t = new i.constructor();
|
|
for (let r of Object.keys(i || {})) {
|
|
let n = i[r];
|
|
r === "parent" && typeof n == "object"
|
|
? e && (t[r] = e)
|
|
: r === "source" || r === null
|
|
? (t[r] = n)
|
|
: Array.isArray(n)
|
|
? (t[r] = n.map((a) => Ho(a, t)))
|
|
: r !== "_autoprefixerPrefix" &&
|
|
r !== "_autoprefixerValues" &&
|
|
r !== "proxyCache" &&
|
|
(typeof n == "object" && n !== null && (n = Ho(n, t)),
|
|
(t[r] = n));
|
|
}
|
|
return t;
|
|
}
|
|
var jn = class {
|
|
static hack(e) {
|
|
return (
|
|
this.hacks || (this.hacks = {}),
|
|
e.names.map((t) => ((this.hacks[t] = e), this.hacks[t]))
|
|
);
|
|
}
|
|
static load(e, t, r) {
|
|
let n = this.hacks && this.hacks[e];
|
|
return n ? new n(e, t, r) : new this(e, t, r);
|
|
}
|
|
static clone(e, t) {
|
|
let r = Ho(e);
|
|
for (let n in t) r[n] = t[n];
|
|
return r;
|
|
}
|
|
constructor(e, t, r) {
|
|
(this.prefixes = t), (this.name = e), (this.all = r);
|
|
}
|
|
parentPrefix(e) {
|
|
let t;
|
|
return (
|
|
typeof e._autoprefixerPrefix != "undefined"
|
|
? (t = e._autoprefixerPrefix)
|
|
: e.type === "decl" && e.prop[0] === "-"
|
|
? (t = km.prefix(e.prop))
|
|
: e.type === "root"
|
|
? (t = !1)
|
|
: e.type === "rule" &&
|
|
e.selector.includes(":-") &&
|
|
/:(-\w+-)/.test(e.selector)
|
|
? (t = e.selector.match(/:(-\w+-)/)[1])
|
|
: e.type === "atrule" && e.name[0] === "-"
|
|
? (t = km.prefix(e.name))
|
|
: (t = this.parentPrefix(e.parent)),
|
|
K2.prefixes().includes(t) || (t = !1),
|
|
(e._autoprefixerPrefix = t),
|
|
e._autoprefixerPrefix
|
|
);
|
|
}
|
|
process(e, t) {
|
|
if (!this.check(e)) return;
|
|
let r = this.parentPrefix(e),
|
|
n = this.prefixes.filter((s) => !r || r === Z2.removeNote(s)),
|
|
a = [];
|
|
for (let s of n) this.add(e, s, a.concat([s]), t) && a.push(s);
|
|
return a;
|
|
}
|
|
clone(e, t) {
|
|
return jn.clone(e, t);
|
|
}
|
|
};
|
|
Sm.exports = jn;
|
|
});
|
|
var R = v((TI, _m) => {
|
|
l();
|
|
var eA = Ut(),
|
|
tA = pt(),
|
|
Cm = fe(),
|
|
Am = class extends eA {
|
|
check() {
|
|
return !0;
|
|
}
|
|
prefixed(e, t) {
|
|
return t + e;
|
|
}
|
|
normalize(e) {
|
|
return e;
|
|
}
|
|
otherPrefixes(e, t) {
|
|
for (let r of tA.prefixes()) if (r !== t && e.includes(r)) return !0;
|
|
return !1;
|
|
}
|
|
set(e, t) {
|
|
return (e.prop = this.prefixed(e.prop, t)), e;
|
|
}
|
|
needCascade(e) {
|
|
return (
|
|
e._autoprefixerCascade ||
|
|
(e._autoprefixerCascade =
|
|
this.all.options.cascade !== !1 &&
|
|
e.raw("before").includes(`
|
|
`)),
|
|
e._autoprefixerCascade
|
|
);
|
|
}
|
|
maxPrefixed(e, t) {
|
|
if (t._autoprefixerMax) return t._autoprefixerMax;
|
|
let r = 0;
|
|
for (let n of e)
|
|
(n = Cm.removeNote(n)), n.length > r && (r = n.length);
|
|
return (t._autoprefixerMax = r), t._autoprefixerMax;
|
|
}
|
|
calcBefore(e, t, r = "") {
|
|
let a = this.maxPrefixed(e, t) - Cm.removeNote(r).length,
|
|
s = t.raw("before");
|
|
return a > 0 && (s += Array(a).fill(" ").join("")), s;
|
|
}
|
|
restoreBefore(e) {
|
|
let t = e.raw("before").split(`
|
|
`),
|
|
r = t[t.length - 1];
|
|
this.all.group(e).up((n) => {
|
|
let a = n.raw("before").split(`
|
|
`),
|
|
s = a[a.length - 1];
|
|
s.length < r.length && (r = s);
|
|
}),
|
|
(t[t.length - 1] = r),
|
|
(e.raws.before = t.join(`
|
|
`));
|
|
}
|
|
insert(e, t, r) {
|
|
let n = this.set(this.clone(e), t);
|
|
if (
|
|
!(
|
|
!n ||
|
|
e.parent.some((s) => s.prop === n.prop && s.value === n.value)
|
|
)
|
|
)
|
|
return (
|
|
this.needCascade(e) && (n.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, n)
|
|
);
|
|
}
|
|
isAlready(e, t) {
|
|
let r = this.all.group(e).up((n) => n.prop === t);
|
|
return r || (r = this.all.group(e).down((n) => n.prop === t)), r;
|
|
}
|
|
add(e, t, r, n) {
|
|
let a = this.prefixed(e.prop, t);
|
|
if (!(this.isAlready(e, a) || this.otherPrefixes(e.value, t)))
|
|
return this.insert(e, t, r, n);
|
|
}
|
|
process(e, t) {
|
|
if (!this.needCascade(e)) {
|
|
super.process(e, t);
|
|
return;
|
|
}
|
|
let r = super.process(e, t);
|
|
!r ||
|
|
!r.length ||
|
|
(this.restoreBefore(e), (e.raws.before = this.calcBefore(r, e)));
|
|
}
|
|
old(e, t) {
|
|
return [this.prefixed(e, t)];
|
|
}
|
|
};
|
|
_m.exports = Am;
|
|
});
|
|
var Em = v((PI, Om) => {
|
|
l();
|
|
Om.exports = function i(e) {
|
|
return {
|
|
mul: (t) => new i(e * t),
|
|
div: (t) => new i(e / t),
|
|
simplify: () => new i(e),
|
|
toString: () => e.toString(),
|
|
};
|
|
};
|
|
});
|
|
var Dm = v((DI, Pm) => {
|
|
l();
|
|
var rA = Em(),
|
|
iA = Ut(),
|
|
Yo = fe(),
|
|
nA = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpcm|dpi|x)/gi,
|
|
sA = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpcm|dpi|x)/i,
|
|
Tm = class extends iA {
|
|
prefixName(e, t) {
|
|
return e === "-moz-"
|
|
? t + "--moz-device-pixel-ratio"
|
|
: e + t + "-device-pixel-ratio";
|
|
}
|
|
prefixQuery(e, t, r, n, a) {
|
|
return (
|
|
(n = new rA(n)),
|
|
a === "dpi"
|
|
? (n = n.div(96))
|
|
: a === "dpcm" && (n = n.mul(2.54).div(96)),
|
|
(n = n.simplify()),
|
|
e === "-o-" && (n = n.n + "/" + n.d),
|
|
this.prefixName(e, t) + r + n
|
|
);
|
|
}
|
|
clean(e) {
|
|
if (!this.bad) {
|
|
this.bad = [];
|
|
for (let t of this.prefixes)
|
|
this.bad.push(this.prefixName(t, "min")),
|
|
this.bad.push(this.prefixName(t, "max"));
|
|
}
|
|
e.params = Yo.editList(e.params, (t) =>
|
|
t.filter((r) => this.bad.every((n) => !r.includes(n))),
|
|
);
|
|
}
|
|
process(e) {
|
|
let t = this.parentPrefix(e),
|
|
r = t ? [t] : this.prefixes;
|
|
e.params = Yo.editList(e.params, (n, a) => {
|
|
for (let s of n) {
|
|
if (
|
|
!s.includes("min-resolution") &&
|
|
!s.includes("max-resolution")
|
|
) {
|
|
a.push(s);
|
|
continue;
|
|
}
|
|
for (let o of r) {
|
|
let u = s.replace(nA, (c) => {
|
|
let f = c.match(sA);
|
|
return this.prefixQuery(o, f[1], f[2], f[3], f[4]);
|
|
});
|
|
a.push(u);
|
|
}
|
|
a.push(s);
|
|
}
|
|
return Yo.uniq(a);
|
|
});
|
|
}
|
|
};
|
|
Pm.exports = Tm;
|
|
});
|
|
var qm = v((II, Im) => {
|
|
l();
|
|
var Qo = "(".charCodeAt(0),
|
|
Jo = ")".charCodeAt(0),
|
|
zn = "'".charCodeAt(0),
|
|
Xo = '"'.charCodeAt(0),
|
|
Ko = "\\".charCodeAt(0),
|
|
Wt = "/".charCodeAt(0),
|
|
Zo = ",".charCodeAt(0),
|
|
el = ":".charCodeAt(0),
|
|
Vn = "*".charCodeAt(0),
|
|
aA = "u".charCodeAt(0),
|
|
oA = "U".charCodeAt(0),
|
|
lA = "+".charCodeAt(0),
|
|
uA = /^[a-f0-9?-]+$/i;
|
|
Im.exports = function (i) {
|
|
for (
|
|
var e = [],
|
|
t = i,
|
|
r,
|
|
n,
|
|
a,
|
|
s,
|
|
o,
|
|
u,
|
|
c,
|
|
f,
|
|
d = 0,
|
|
p = t.charCodeAt(d),
|
|
m = t.length,
|
|
w = [{ nodes: e }],
|
|
x = 0,
|
|
y,
|
|
b = "",
|
|
k = "",
|
|
S = "";
|
|
d < m;
|
|
|
|
)
|
|
if (p <= 32) {
|
|
r = d;
|
|
do (r += 1), (p = t.charCodeAt(r));
|
|
while (p <= 32);
|
|
(s = t.slice(d, r)),
|
|
(a = e[e.length - 1]),
|
|
p === Jo && x
|
|
? (S = s)
|
|
: a && a.type === "div"
|
|
? ((a.after = s), (a.sourceEndIndex += s.length))
|
|
: p === Zo ||
|
|
p === el ||
|
|
(p === Wt &&
|
|
t.charCodeAt(r + 1) !== Vn &&
|
|
(!y ||
|
|
(y && y.type === "function" && y.value !== "calc")))
|
|
? (k = s)
|
|
: e.push({
|
|
type: "space",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
}),
|
|
(d = r);
|
|
} else if (p === zn || p === Xo) {
|
|
(r = d),
|
|
(n = p === zn ? "'" : '"'),
|
|
(s = { type: "string", sourceIndex: d, quote: n });
|
|
do
|
|
if (((o = !1), (r = t.indexOf(n, r + 1)), ~r))
|
|
for (u = r; t.charCodeAt(u - 1) === Ko; ) (u -= 1), (o = !o);
|
|
else (t += n), (r = t.length - 1), (s.unclosed = !0);
|
|
while (o);
|
|
(s.value = t.slice(d + 1, r)),
|
|
(s.sourceEndIndex = s.unclosed ? r : r + 1),
|
|
e.push(s),
|
|
(d = r + 1),
|
|
(p = t.charCodeAt(d));
|
|
} else if (p === Wt && t.charCodeAt(d + 1) === Vn)
|
|
(r = t.indexOf("*/", d)),
|
|
(s = { type: "comment", sourceIndex: d, sourceEndIndex: r + 2 }),
|
|
r === -1 &&
|
|
((s.unclosed = !0), (r = t.length), (s.sourceEndIndex = r)),
|
|
(s.value = t.slice(d + 2, r)),
|
|
e.push(s),
|
|
(d = r + 2),
|
|
(p = t.charCodeAt(d));
|
|
else if (
|
|
(p === Wt || p === Vn) &&
|
|
y &&
|
|
y.type === "function" &&
|
|
y.value === "calc"
|
|
)
|
|
(s = t[d]),
|
|
e.push({
|
|
type: "word",
|
|
sourceIndex: d - k.length,
|
|
sourceEndIndex: d + s.length,
|
|
value: s,
|
|
}),
|
|
(d += 1),
|
|
(p = t.charCodeAt(d));
|
|
else if (p === Wt || p === Zo || p === el)
|
|
(s = t[d]),
|
|
e.push({
|
|
type: "div",
|
|
sourceIndex: d - k.length,
|
|
sourceEndIndex: d + s.length,
|
|
value: s,
|
|
before: k,
|
|
after: "",
|
|
}),
|
|
(k = ""),
|
|
(d += 1),
|
|
(p = t.charCodeAt(d));
|
|
else if (Qo === p) {
|
|
r = d;
|
|
do (r += 1), (p = t.charCodeAt(r));
|
|
while (p <= 32);
|
|
if (
|
|
((f = d),
|
|
(s = {
|
|
type: "function",
|
|
sourceIndex: d - b.length,
|
|
value: b,
|
|
before: t.slice(f + 1, r),
|
|
}),
|
|
(d = r),
|
|
b === "url" && p !== zn && p !== Xo)
|
|
) {
|
|
r -= 1;
|
|
do
|
|
if (((o = !1), (r = t.indexOf(")", r + 1)), ~r))
|
|
for (u = r; t.charCodeAt(u - 1) === Ko; ) (u -= 1), (o = !o);
|
|
else (t += ")"), (r = t.length - 1), (s.unclosed = !0);
|
|
while (o);
|
|
c = r;
|
|
do (c -= 1), (p = t.charCodeAt(c));
|
|
while (p <= 32);
|
|
f < c
|
|
? (d !== c + 1
|
|
? (s.nodes = [
|
|
{
|
|
type: "word",
|
|
sourceIndex: d,
|
|
sourceEndIndex: c + 1,
|
|
value: t.slice(d, c + 1),
|
|
},
|
|
])
|
|
: (s.nodes = []),
|
|
s.unclosed && c + 1 !== r
|
|
? ((s.after = ""),
|
|
s.nodes.push({
|
|
type: "space",
|
|
sourceIndex: c + 1,
|
|
sourceEndIndex: r,
|
|
value: t.slice(c + 1, r),
|
|
}))
|
|
: ((s.after = t.slice(c + 1, r)), (s.sourceEndIndex = r)))
|
|
: ((s.after = ""), (s.nodes = [])),
|
|
(d = r + 1),
|
|
(s.sourceEndIndex = s.unclosed ? r : d),
|
|
(p = t.charCodeAt(d)),
|
|
e.push(s);
|
|
} else
|
|
(x += 1),
|
|
(s.after = ""),
|
|
(s.sourceEndIndex = d + 1),
|
|
e.push(s),
|
|
w.push(s),
|
|
(e = s.nodes = []),
|
|
(y = s);
|
|
b = "";
|
|
} else if (Jo === p && x)
|
|
(d += 1),
|
|
(p = t.charCodeAt(d)),
|
|
(y.after = S),
|
|
(y.sourceEndIndex += S.length),
|
|
(S = ""),
|
|
(x -= 1),
|
|
(w[w.length - 1].sourceEndIndex = d),
|
|
w.pop(),
|
|
(y = w[x]),
|
|
(e = y.nodes);
|
|
else {
|
|
r = d;
|
|
do p === Ko && (r += 1), (r += 1), (p = t.charCodeAt(r));
|
|
while (
|
|
r < m &&
|
|
!(
|
|
p <= 32 ||
|
|
p === zn ||
|
|
p === Xo ||
|
|
p === Zo ||
|
|
p === el ||
|
|
p === Wt ||
|
|
p === Qo ||
|
|
(p === Vn && y && y.type === "function" && y.value === "calc") ||
|
|
(p === Wt && y.type === "function" && y.value === "calc") ||
|
|
(p === Jo && x)
|
|
)
|
|
);
|
|
(s = t.slice(d, r)),
|
|
Qo === p
|
|
? (b = s)
|
|
: (aA === s.charCodeAt(0) || oA === s.charCodeAt(0)) &&
|
|
lA === s.charCodeAt(1) &&
|
|
uA.test(s.slice(2))
|
|
? e.push({
|
|
type: "unicode-range",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
})
|
|
: e.push({
|
|
type: "word",
|
|
sourceIndex: d,
|
|
sourceEndIndex: r,
|
|
value: s,
|
|
}),
|
|
(d = r);
|
|
}
|
|
for (d = w.length - 1; d; d -= 1)
|
|
(w[d].unclosed = !0), (w[d].sourceEndIndex = t.length);
|
|
return w[0].nodes;
|
|
};
|
|
});
|
|
var Mm = v((qI, Rm) => {
|
|
l();
|
|
Rm.exports = function i(e, t, r) {
|
|
var n, a, s, o;
|
|
for (n = 0, a = e.length; n < a; n += 1)
|
|
(s = e[n]),
|
|
r || (o = t(s, n, e)),
|
|
o !== !1 &&
|
|
s.type === "function" &&
|
|
Array.isArray(s.nodes) &&
|
|
i(s.nodes, t, r),
|
|
r && t(s, n, e);
|
|
};
|
|
});
|
|
var Lm = v((RI, Nm) => {
|
|
l();
|
|
function Bm(i, e) {
|
|
var t = i.type,
|
|
r = i.value,
|
|
n,
|
|
a;
|
|
return e && (a = e(i)) !== void 0
|
|
? a
|
|
: t === "word" || t === "space"
|
|
? r
|
|
: t === "string"
|
|
? ((n = i.quote || ""), n + r + (i.unclosed ? "" : n))
|
|
: t === "comment"
|
|
? "/*" + r + (i.unclosed ? "" : "*/")
|
|
: t === "div"
|
|
? (i.before || "") + r + (i.after || "")
|
|
: Array.isArray(i.nodes)
|
|
? ((n = Fm(i.nodes, e)),
|
|
t !== "function"
|
|
? n
|
|
: r +
|
|
"(" +
|
|
(i.before || "") +
|
|
n +
|
|
(i.after || "") +
|
|
(i.unclosed ? "" : ")"))
|
|
: r;
|
|
}
|
|
function Fm(i, e) {
|
|
var t, r;
|
|
if (Array.isArray(i)) {
|
|
for (t = "", r = i.length - 1; ~r; r -= 1) t = Bm(i[r], e) + t;
|
|
return t;
|
|
}
|
|
return Bm(i, e);
|
|
}
|
|
Nm.exports = Fm;
|
|
});
|
|
var jm = v((MI, $m) => {
|
|
l();
|
|
var Un = "-".charCodeAt(0),
|
|
Wn = "+".charCodeAt(0),
|
|
tl = ".".charCodeAt(0),
|
|
fA = "e".charCodeAt(0),
|
|
cA = "E".charCodeAt(0);
|
|
function pA(i) {
|
|
var e = i.charCodeAt(0),
|
|
t;
|
|
if (e === Wn || e === Un) {
|
|
if (((t = i.charCodeAt(1)), t >= 48 && t <= 57)) return !0;
|
|
var r = i.charCodeAt(2);
|
|
return t === tl && r >= 48 && r <= 57;
|
|
}
|
|
return e === tl
|
|
? ((t = i.charCodeAt(1)), t >= 48 && t <= 57)
|
|
: e >= 48 && e <= 57;
|
|
}
|
|
$m.exports = function (i) {
|
|
var e = 0,
|
|
t = i.length,
|
|
r,
|
|
n,
|
|
a;
|
|
if (t === 0 || !pA(i)) return !1;
|
|
for (
|
|
r = i.charCodeAt(e), (r === Wn || r === Un) && e++;
|
|
e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57));
|
|
|
|
)
|
|
e += 1;
|
|
if (
|
|
((r = i.charCodeAt(e)),
|
|
(n = i.charCodeAt(e + 1)),
|
|
r === tl && n >= 48 && n <= 57)
|
|
)
|
|
for (e += 2; e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57)); )
|
|
e += 1;
|
|
if (
|
|
((r = i.charCodeAt(e)),
|
|
(n = i.charCodeAt(e + 1)),
|
|
(a = i.charCodeAt(e + 2)),
|
|
(r === fA || r === cA) &&
|
|
((n >= 48 && n <= 57) ||
|
|
((n === Wn || n === Un) && a >= 48 && a <= 57)))
|
|
)
|
|
for (
|
|
e += n === Wn || n === Un ? 3 : 2;
|
|
e < t && ((r = i.charCodeAt(e)), !(r < 48 || r > 57));
|
|
|
|
)
|
|
e += 1;
|
|
return { number: i.slice(0, e), unit: i.slice(e) };
|
|
};
|
|
});
|
|
var Gn = v((BI, Um) => {
|
|
l();
|
|
var dA = qm(),
|
|
zm = Mm(),
|
|
Vm = Lm();
|
|
function dt(i) {
|
|
return this instanceof dt ? ((this.nodes = dA(i)), this) : new dt(i);
|
|
}
|
|
dt.prototype.toString = function () {
|
|
return Array.isArray(this.nodes) ? Vm(this.nodes) : "";
|
|
};
|
|
dt.prototype.walk = function (i, e) {
|
|
return zm(this.nodes, i, e), this;
|
|
};
|
|
dt.unit = jm();
|
|
dt.walk = zm;
|
|
dt.stringify = Vm;
|
|
Um.exports = dt;
|
|
});
|
|
var Qm = v((FI, Ym) => {
|
|
l();
|
|
var { list: hA } = ge(),
|
|
Wm = Gn(),
|
|
mA = pt(),
|
|
Gm = ii(),
|
|
Hm = class {
|
|
constructor(e) {
|
|
(this.props = ["transition", "transition-property"]),
|
|
(this.prefixes = e);
|
|
}
|
|
add(e, t) {
|
|
let r,
|
|
n,
|
|
a = this.prefixes.add[e.prop],
|
|
s = this.ruleVendorPrefixes(e),
|
|
o = s || (a && a.prefixes) || [],
|
|
u = this.parse(e.value),
|
|
c = u.map((m) => this.findProp(m)),
|
|
f = [];
|
|
if (c.some((m) => m[0] === "-")) return;
|
|
for (let m of u) {
|
|
if (((n = this.findProp(m)), n[0] === "-")) continue;
|
|
let w = this.prefixes.add[n];
|
|
if (!(!w || !w.prefixes))
|
|
for (r of w.prefixes) {
|
|
if (s && !s.some((y) => r.includes(y))) continue;
|
|
let x = this.prefixes.prefixed(n, r);
|
|
x !== "-ms-transform" &&
|
|
!c.includes(x) &&
|
|
(this.disabled(n, r) || f.push(this.clone(n, x, m)));
|
|
}
|
|
}
|
|
u = u.concat(f);
|
|
let d = this.stringify(u),
|
|
p = this.stringify(this.cleanFromUnprefixed(u, "-webkit-"));
|
|
if (
|
|
(o.includes("-webkit-") &&
|
|
this.cloneBefore(e, `-webkit-${e.prop}`, p),
|
|
this.cloneBefore(e, e.prop, p),
|
|
o.includes("-o-"))
|
|
) {
|
|
let m = this.stringify(this.cleanFromUnprefixed(u, "-o-"));
|
|
this.cloneBefore(e, `-o-${e.prop}`, m);
|
|
}
|
|
for (r of o)
|
|
if (r !== "-webkit-" && r !== "-o-") {
|
|
let m = this.stringify(this.cleanOtherPrefixes(u, r));
|
|
this.cloneBefore(e, r + e.prop, m);
|
|
}
|
|
d !== e.value &&
|
|
!this.already(e, e.prop, d) &&
|
|
(this.checkForWarning(t, e), e.cloneBefore(), (e.value = d));
|
|
}
|
|
findProp(e) {
|
|
let t = e[0].value;
|
|
if (/^\d/.test(t)) {
|
|
for (let [r, n] of e.entries())
|
|
if (r !== 0 && n.type === "word") return n.value;
|
|
}
|
|
return t;
|
|
}
|
|
already(e, t, r) {
|
|
return e.parent.some((n) => n.prop === t && n.value === r);
|
|
}
|
|
cloneBefore(e, t, r) {
|
|
this.already(e, t, r) || e.cloneBefore({ prop: t, value: r });
|
|
}
|
|
checkForWarning(e, t) {
|
|
if (t.prop !== "transition-property") return;
|
|
let r = !1,
|
|
n = !1;
|
|
t.parent.each((a) => {
|
|
if (a.type !== "decl" || a.prop.indexOf("transition-") !== 0)
|
|
return;
|
|
let s = hA.comma(a.value);
|
|
if (a.prop === "transition-property") {
|
|
s.forEach((o) => {
|
|
let u = this.prefixes.add[o];
|
|
u && u.prefixes && u.prefixes.length > 0 && (r = !0);
|
|
});
|
|
return;
|
|
}
|
|
return (n = n || s.length > 1), !1;
|
|
}),
|
|
r &&
|
|
n &&
|
|
t.warn(
|
|
e,
|
|
"Replace transition-property to transition, because Autoprefixer could not support any cases of transition-property and other transition-*",
|
|
);
|
|
}
|
|
remove(e) {
|
|
let t = this.parse(e.value);
|
|
t = t.filter((s) => {
|
|
let o = this.prefixes.remove[this.findProp(s)];
|
|
return !o || !o.remove;
|
|
});
|
|
let r = this.stringify(t);
|
|
if (e.value === r) return;
|
|
if (t.length === 0) {
|
|
e.remove();
|
|
return;
|
|
}
|
|
let n = e.parent.some((s) => s.prop === e.prop && s.value === r),
|
|
a = e.parent.some(
|
|
(s) => s !== e && s.prop === e.prop && s.value.length > r.length,
|
|
);
|
|
if (n || a) {
|
|
e.remove();
|
|
return;
|
|
}
|
|
e.value = r;
|
|
}
|
|
parse(e) {
|
|
let t = Wm(e),
|
|
r = [],
|
|
n = [];
|
|
for (let a of t.nodes)
|
|
n.push(a),
|
|
a.type === "div" && a.value === "," && (r.push(n), (n = []));
|
|
return r.push(n), r.filter((a) => a.length > 0);
|
|
}
|
|
stringify(e) {
|
|
if (e.length === 0) return "";
|
|
let t = [];
|
|
for (let r of e)
|
|
r[r.length - 1].type !== "div" && r.push(this.div(e)),
|
|
(t = t.concat(r));
|
|
return (
|
|
t[0].type === "div" && (t = t.slice(1)),
|
|
t[t.length - 1].type === "div" &&
|
|
(t = t.slice(0, -2 + 1 || void 0)),
|
|
Wm.stringify({ nodes: t })
|
|
);
|
|
}
|
|
clone(e, t, r) {
|
|
let n = [],
|
|
a = !1;
|
|
for (let s of r)
|
|
!a && s.type === "word" && s.value === e
|
|
? (n.push({ type: "word", value: t }), (a = !0))
|
|
: n.push(s);
|
|
return n;
|
|
}
|
|
div(e) {
|
|
for (let t of e)
|
|
for (let r of t) if (r.type === "div" && r.value === ",") return r;
|
|
return { type: "div", value: ",", after: " " };
|
|
}
|
|
cleanOtherPrefixes(e, t) {
|
|
return e.filter((r) => {
|
|
let n = Gm.prefix(this.findProp(r));
|
|
return n === "" || n === t;
|
|
});
|
|
}
|
|
cleanFromUnprefixed(e, t) {
|
|
let r = e
|
|
.map((a) => this.findProp(a))
|
|
.filter((a) => a.slice(0, t.length) === t)
|
|
.map((a) => this.prefixes.unprefixed(a)),
|
|
n = [];
|
|
for (let a of e) {
|
|
let s = this.findProp(a),
|
|
o = Gm.prefix(s);
|
|
!r.includes(s) && (o === t || o === "") && n.push(a);
|
|
}
|
|
return n;
|
|
}
|
|
disabled(e, t) {
|
|
let r = ["order", "justify-content", "align-self", "align-content"];
|
|
if (e.includes("flex") || r.includes(e)) {
|
|
if (this.prefixes.options.flexbox === !1) return !0;
|
|
if (this.prefixes.options.flexbox === "no-2009")
|
|
return t.includes("2009");
|
|
}
|
|
}
|
|
ruleVendorPrefixes(e) {
|
|
let { parent: t } = e;
|
|
if (t.type !== "rule") return !1;
|
|
if (!t.selector.includes(":-")) return !1;
|
|
let r = mA.prefixes().filter((n) => t.selector.includes(":" + n));
|
|
return r.length > 0 ? r : !1;
|
|
}
|
|
};
|
|
Ym.exports = Hm;
|
|
});
|
|
var Gt = v((NI, Xm) => {
|
|
l();
|
|
var gA = fe(),
|
|
Jm = class {
|
|
constructor(e, t, r, n) {
|
|
(this.unprefixed = e),
|
|
(this.prefixed = t),
|
|
(this.string = r || t),
|
|
(this.regexp = n || gA.regexp(t));
|
|
}
|
|
check(e) {
|
|
return e.includes(this.string) ? !!e.match(this.regexp) : !1;
|
|
}
|
|
};
|
|
Xm.exports = Jm;
|
|
});
|
|
var ke = v((LI, Zm) => {
|
|
l();
|
|
var yA = Ut(),
|
|
wA = Gt(),
|
|
bA = ii(),
|
|
vA = fe(),
|
|
Km = class extends yA {
|
|
static save(e, t) {
|
|
let r = t.prop,
|
|
n = [];
|
|
for (let a in t._autoprefixerValues) {
|
|
let s = t._autoprefixerValues[a];
|
|
if (s === t.value) continue;
|
|
let o,
|
|
u = bA.prefix(r);
|
|
if (u === "-pie-") continue;
|
|
if (u === a) {
|
|
(o = t.value = s), n.push(o);
|
|
continue;
|
|
}
|
|
let c = e.prefixed(r, a),
|
|
f = t.parent;
|
|
if (!f.every((w) => w.prop !== c)) {
|
|
n.push(o);
|
|
continue;
|
|
}
|
|
let d = s.replace(/\s+/, " ");
|
|
if (
|
|
f.some(
|
|
(w) => w.prop === t.prop && w.value.replace(/\s+/, " ") === d,
|
|
)
|
|
) {
|
|
n.push(o);
|
|
continue;
|
|
}
|
|
let m = this.clone(t, { value: s });
|
|
(o = t.parent.insertBefore(t, m)), n.push(o);
|
|
}
|
|
return n;
|
|
}
|
|
check(e) {
|
|
let t = e.value;
|
|
return t.includes(this.name) ? !!t.match(this.regexp()) : !1;
|
|
}
|
|
regexp() {
|
|
return this.regexpCache || (this.regexpCache = vA.regexp(this.name));
|
|
}
|
|
replace(e, t) {
|
|
return e.replace(this.regexp(), `$1${t}$2`);
|
|
}
|
|
value(e) {
|
|
return e.raws.value && e.raws.value.value === e.value
|
|
? e.raws.value.raw
|
|
: e.value;
|
|
}
|
|
add(e, t) {
|
|
e._autoprefixerValues || (e._autoprefixerValues = {});
|
|
let r = e._autoprefixerValues[t] || this.value(e),
|
|
n;
|
|
do if (((n = r), (r = this.replace(r, t)), r === !1)) return;
|
|
while (r !== n);
|
|
e._autoprefixerValues[t] = r;
|
|
}
|
|
old(e) {
|
|
return new wA(this.name, e + this.name);
|
|
}
|
|
};
|
|
Zm.exports = Km;
|
|
});
|
|
var ht = v(($I, eg) => {
|
|
l();
|
|
eg.exports = {};
|
|
});
|
|
var il = v((jI, ig) => {
|
|
l();
|
|
var tg = Gn(),
|
|
xA = ke(),
|
|
kA = ht().insertAreas,
|
|
SA = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i,
|
|
CA = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i,
|
|
AA = /(!\s*)?autoprefixer:\s*ignore\s+next/i,
|
|
_A = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i,
|
|
OA = [
|
|
"width",
|
|
"height",
|
|
"min-width",
|
|
"max-width",
|
|
"min-height",
|
|
"max-height",
|
|
"inline-size",
|
|
"min-inline-size",
|
|
"max-inline-size",
|
|
"block-size",
|
|
"min-block-size",
|
|
"max-block-size",
|
|
];
|
|
function rl(i) {
|
|
return i.parent.some(
|
|
(e) => e.prop === "grid-template" || e.prop === "grid-template-areas",
|
|
);
|
|
}
|
|
function EA(i) {
|
|
let e = i.parent.some((r) => r.prop === "grid-template-rows"),
|
|
t = i.parent.some((r) => r.prop === "grid-template-columns");
|
|
return e && t;
|
|
}
|
|
var rg = class {
|
|
constructor(e) {
|
|
this.prefixes = e;
|
|
}
|
|
add(e, t) {
|
|
let r = this.prefixes.add["@resolution"],
|
|
n = this.prefixes.add["@keyframes"],
|
|
a = this.prefixes.add["@viewport"],
|
|
s = this.prefixes.add["@supports"];
|
|
e.walkAtRules((f) => {
|
|
if (f.name === "keyframes") {
|
|
if (!this.disabled(f, t)) return n && n.process(f);
|
|
} else if (f.name === "viewport") {
|
|
if (!this.disabled(f, t)) return a && a.process(f);
|
|
} else if (f.name === "supports") {
|
|
if (this.prefixes.options.supports !== !1 && !this.disabled(f, t))
|
|
return s.process(f);
|
|
} else if (
|
|
f.name === "media" &&
|
|
f.params.includes("-resolution") &&
|
|
!this.disabled(f, t)
|
|
)
|
|
return r && r.process(f);
|
|
}),
|
|
e.walkRules((f) => {
|
|
if (!this.disabled(f, t))
|
|
return this.prefixes.add.selectors.map((d) => d.process(f, t));
|
|
});
|
|
function o(f) {
|
|
return f.parent.nodes.some((d) => {
|
|
if (d.type !== "decl") return !1;
|
|
let p = d.prop === "display" && /(inline-)?grid/.test(d.value),
|
|
m = d.prop.startsWith("grid-template"),
|
|
w = /^grid-([A-z]+-)?gap/.test(d.prop);
|
|
return p || m || w;
|
|
});
|
|
}
|
|
function u(f) {
|
|
return f.parent.some(
|
|
(d) => d.prop === "display" && /(inline-)?flex/.test(d.value),
|
|
);
|
|
}
|
|
let c =
|
|
this.gridStatus(e, t) &&
|
|
this.prefixes.add["grid-area"] &&
|
|
this.prefixes.add["grid-area"].prefixes;
|
|
return (
|
|
e.walkDecls((f) => {
|
|
if (this.disabledDecl(f, t)) return;
|
|
let d = f.parent,
|
|
p = f.prop,
|
|
m = f.value;
|
|
if (p === "grid-row-span") {
|
|
t.warn(
|
|
"grid-row-span is not part of final Grid Layout. Use grid-row.",
|
|
{ node: f },
|
|
);
|
|
return;
|
|
} else if (p === "grid-column-span") {
|
|
t.warn(
|
|
"grid-column-span is not part of final Grid Layout. Use grid-column.",
|
|
{ node: f },
|
|
);
|
|
return;
|
|
} else if (p === "display" && m === "box") {
|
|
t.warn(
|
|
"You should write display: flex by final spec instead of display: box",
|
|
{ node: f },
|
|
);
|
|
return;
|
|
} else if (p === "text-emphasis-position")
|
|
(m === "under" || m === "over") &&
|
|
t.warn(
|
|
"You should use 2 values for text-emphasis-position For example, `under left` instead of just `under`.",
|
|
{ node: f },
|
|
);
|
|
else if (/^(align|justify|place)-(items|content)$/.test(p) && u(f))
|
|
(m === "start" || m === "end") &&
|
|
t.warn(
|
|
`${m} value has mixed support, consider using flex-${m} instead`,
|
|
{ node: f },
|
|
);
|
|
else if (p === "text-decoration-skip" && m === "ink")
|
|
t.warn(
|
|
"Replace text-decoration-skip: ink to text-decoration-skip-ink: auto, because spec had been changed",
|
|
{ node: f },
|
|
);
|
|
else {
|
|
if (c && this.gridStatus(f, t))
|
|
if (
|
|
(f.value === "subgrid" &&
|
|
t.warn("IE does not support subgrid", { node: f }),
|
|
/^(align|justify|place)-items$/.test(p) && o(f))
|
|
) {
|
|
let x = p.replace("-items", "-self");
|
|
t.warn(
|
|
`IE does not support ${p} on grid containers. Try using ${x} on child elements instead: ${f.parent.selector} > * { ${x}: ${f.value} }`,
|
|
{ node: f },
|
|
);
|
|
} else if (/^(align|justify|place)-content$/.test(p) && o(f))
|
|
t.warn(`IE does not support ${f.prop} on grid containers`, {
|
|
node: f,
|
|
});
|
|
else if (p === "display" && f.value === "contents") {
|
|
t.warn(
|
|
"Please do not use display: contents; if you have grid setting enabled",
|
|
{ node: f },
|
|
);
|
|
return;
|
|
} else if (f.prop === "grid-gap") {
|
|
let x = this.gridStatus(f, t);
|
|
x === "autoplace" && !EA(f) && !rl(f)
|
|
? t.warn(
|
|
"grid-gap only works if grid-template(-areas) is being used or both rows and columns have been declared and cells have not been manually placed inside the explicit grid",
|
|
{ node: f },
|
|
)
|
|
: (x === !0 || x === "no-autoplace") &&
|
|
!rl(f) &&
|
|
t.warn(
|
|
"grid-gap only works if grid-template(-areas) is being used",
|
|
{ node: f },
|
|
);
|
|
} else if (p === "grid-auto-columns") {
|
|
t.warn("grid-auto-columns is not supported by IE", {
|
|
node: f,
|
|
});
|
|
return;
|
|
} else if (p === "grid-auto-rows") {
|
|
t.warn("grid-auto-rows is not supported by IE", { node: f });
|
|
return;
|
|
} else if (p === "grid-auto-flow") {
|
|
let x = d.some((b) => b.prop === "grid-template-rows"),
|
|
y = d.some((b) => b.prop === "grid-template-columns");
|
|
rl(f)
|
|
? t.warn("grid-auto-flow is not supported by IE", {
|
|
node: f,
|
|
})
|
|
: m.includes("dense")
|
|
? t.warn("grid-auto-flow: dense is not supported by IE", {
|
|
node: f,
|
|
})
|
|
: !x &&
|
|
!y &&
|
|
t.warn(
|
|
"grid-auto-flow works only if grid-template-rows and grid-template-columns are present in the same rule",
|
|
{ node: f },
|
|
);
|
|
return;
|
|
} else if (m.includes("auto-fit")) {
|
|
t.warn("auto-fit value is not supported by IE", {
|
|
node: f,
|
|
word: "auto-fit",
|
|
});
|
|
return;
|
|
} else if (m.includes("auto-fill")) {
|
|
t.warn("auto-fill value is not supported by IE", {
|
|
node: f,
|
|
word: "auto-fill",
|
|
});
|
|
return;
|
|
} else
|
|
p.startsWith("grid-template") &&
|
|
m.includes("[") &&
|
|
t.warn(
|
|
"Autoprefixer currently does not support line names. Try using grid-template-areas instead.",
|
|
{ node: f, word: "[" },
|
|
);
|
|
if (m.includes("radial-gradient"))
|
|
if (CA.test(f.value))
|
|
t.warn(
|
|
"Gradient has outdated direction syntax. New syntax is like `closest-side at 0 0` instead of `0 0, closest-side`.",
|
|
{ node: f },
|
|
);
|
|
else {
|
|
let x = tg(m);
|
|
for (let y of x.nodes)
|
|
if (y.type === "function" && y.value === "radial-gradient")
|
|
for (let b of y.nodes)
|
|
b.type === "word" &&
|
|
(b.value === "cover"
|
|
? t.warn(
|
|
"Gradient has outdated direction syntax. Replace `cover` to `farthest-corner`.",
|
|
{ node: f },
|
|
)
|
|
: b.value === "contain" &&
|
|
t.warn(
|
|
"Gradient has outdated direction syntax. Replace `contain` to `closest-side`.",
|
|
{ node: f },
|
|
));
|
|
}
|
|
m.includes("linear-gradient") &&
|
|
SA.test(m) &&
|
|
t.warn(
|
|
"Gradient has outdated direction syntax. New syntax is like `to left` instead of `right`.",
|
|
{ node: f },
|
|
);
|
|
}
|
|
OA.includes(f.prop) &&
|
|
(f.value.includes("-fill-available") ||
|
|
(f.value.includes("fill-available")
|
|
? t.warn(
|
|
"Replace fill-available to stretch, because spec had been changed",
|
|
{ node: f },
|
|
)
|
|
: f.value.includes("fill") &&
|
|
tg(m).nodes.some(
|
|
(y) => y.type === "word" && y.value === "fill",
|
|
) &&
|
|
t.warn(
|
|
"Replace fill to stretch, because spec had been changed",
|
|
{ node: f },
|
|
)));
|
|
let w;
|
|
if (f.prop === "transition" || f.prop === "transition-property")
|
|
return this.prefixes.transition.add(f, t);
|
|
if (f.prop === "align-self") {
|
|
if (
|
|
(this.displayType(f) !== "grid" &&
|
|
this.prefixes.options.flexbox !== !1 &&
|
|
((w = this.prefixes.add["align-self"]),
|
|
w && w.prefixes && w.process(f)),
|
|
this.gridStatus(f, t) !== !1 &&
|
|
((w = this.prefixes.add["grid-row-align"]), w && w.prefixes))
|
|
)
|
|
return w.process(f, t);
|
|
} else if (f.prop === "justify-self") {
|
|
if (
|
|
this.gridStatus(f, t) !== !1 &&
|
|
((w = this.prefixes.add["grid-column-align"]), w && w.prefixes)
|
|
)
|
|
return w.process(f, t);
|
|
} else if (f.prop === "place-self") {
|
|
if (
|
|
((w = this.prefixes.add["place-self"]),
|
|
w && w.prefixes && this.gridStatus(f, t) !== !1)
|
|
)
|
|
return w.process(f, t);
|
|
} else if (((w = this.prefixes.add[f.prop]), w && w.prefixes))
|
|
return w.process(f, t);
|
|
}),
|
|
this.gridStatus(e, t) && kA(e, this.disabled),
|
|
e.walkDecls((f) => {
|
|
if (this.disabledValue(f, t)) return;
|
|
let d = this.prefixes.unprefixed(f.prop),
|
|
p = this.prefixes.values("add", d);
|
|
if (Array.isArray(p)) for (let m of p) m.process && m.process(f, t);
|
|
xA.save(this.prefixes, f);
|
|
})
|
|
);
|
|
}
|
|
remove(e, t) {
|
|
let r = this.prefixes.remove["@resolution"];
|
|
e.walkAtRules((n, a) => {
|
|
this.prefixes.remove[`@${n.name}`]
|
|
? this.disabled(n, t) || n.parent.removeChild(a)
|
|
: n.name === "media" &&
|
|
n.params.includes("-resolution") &&
|
|
r &&
|
|
r.clean(n);
|
|
});
|
|
for (let n of this.prefixes.remove.selectors)
|
|
e.walkRules((a, s) => {
|
|
n.check(a) && (this.disabled(a, t) || a.parent.removeChild(s));
|
|
});
|
|
return e.walkDecls((n, a) => {
|
|
if (this.disabled(n, t)) return;
|
|
let s = n.parent,
|
|
o = this.prefixes.unprefixed(n.prop);
|
|
if (
|
|
((n.prop === "transition" || n.prop === "transition-property") &&
|
|
this.prefixes.transition.remove(n),
|
|
this.prefixes.remove[n.prop] && this.prefixes.remove[n.prop].remove)
|
|
) {
|
|
let u = this.prefixes
|
|
.group(n)
|
|
.down((c) => this.prefixes.normalize(c.prop) === o);
|
|
if (
|
|
(o === "flex-flow" && (u = !0), n.prop === "-webkit-box-orient")
|
|
) {
|
|
let c = { "flex-direction": !0, "flex-flow": !0 };
|
|
if (!n.parent.some((f) => c[f.prop])) return;
|
|
}
|
|
if (u && !this.withHackValue(n)) {
|
|
n.raw("before").includes(`
|
|
`) && this.reduceSpaces(n),
|
|
s.removeChild(a);
|
|
return;
|
|
}
|
|
}
|
|
for (let u of this.prefixes.values("remove", o)) {
|
|
if (!u.check || !u.check(n.value)) continue;
|
|
if (
|
|
((o = u.unprefixed),
|
|
this.prefixes.group(n).down((f) => f.value.includes(o)))
|
|
) {
|
|
s.removeChild(a);
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
withHackValue(e) {
|
|
return e.prop === "-webkit-background-clip" && e.value === "text";
|
|
}
|
|
disabledValue(e, t) {
|
|
return (this.gridStatus(e, t) === !1 &&
|
|
e.type === "decl" &&
|
|
e.prop === "display" &&
|
|
e.value.includes("grid")) ||
|
|
(this.prefixes.options.flexbox === !1 &&
|
|
e.type === "decl" &&
|
|
e.prop === "display" &&
|
|
e.value.includes("flex")) ||
|
|
(e.type === "decl" && e.prop === "content")
|
|
? !0
|
|
: this.disabled(e, t);
|
|
}
|
|
disabledDecl(e, t) {
|
|
if (
|
|
this.gridStatus(e, t) === !1 &&
|
|
e.type === "decl" &&
|
|
(e.prop.includes("grid") || e.prop === "justify-items")
|
|
)
|
|
return !0;
|
|
if (this.prefixes.options.flexbox === !1 && e.type === "decl") {
|
|
let r = ["order", "justify-content", "align-items", "align-content"];
|
|
if (e.prop.includes("flex") || r.includes(e.prop)) return !0;
|
|
}
|
|
return this.disabled(e, t);
|
|
}
|
|
disabled(e, t) {
|
|
if (!e) return !1;
|
|
if (e._autoprefixerDisabled !== void 0) return e._autoprefixerDisabled;
|
|
if (e.parent) {
|
|
let n = e.prev();
|
|
if (n && n.type === "comment" && AA.test(n.text))
|
|
return (
|
|
(e._autoprefixerDisabled = !0),
|
|
(e._autoprefixerSelfDisabled = !0),
|
|
!0
|
|
);
|
|
}
|
|
let r = null;
|
|
if (e.nodes) {
|
|
let n;
|
|
e.each((a) => {
|
|
a.type === "comment" &&
|
|
/(!\s*)?autoprefixer:\s*(off|on)/i.test(a.text) &&
|
|
(typeof n != "undefined"
|
|
? t.warn(
|
|
"Second Autoprefixer control comment was ignored. Autoprefixer applies control comment to whole block, not to next rules.",
|
|
{ node: a },
|
|
)
|
|
: (n = /on/i.test(a.text)));
|
|
}),
|
|
n !== void 0 && (r = !n);
|
|
}
|
|
if (!e.nodes || r === null)
|
|
if (e.parent) {
|
|
let n = this.disabled(e.parent, t);
|
|
e.parent._autoprefixerSelfDisabled === !0 ? (r = !1) : (r = n);
|
|
} else r = !1;
|
|
return (e._autoprefixerDisabled = r), r;
|
|
}
|
|
reduceSpaces(e) {
|
|
let t = !1;
|
|
if ((this.prefixes.group(e).up(() => ((t = !0), !0)), t)) return;
|
|
let r = e.raw("before").split(`
|
|
`),
|
|
n = r[r.length - 1].length,
|
|
a = !1;
|
|
this.prefixes.group(e).down((s) => {
|
|
r = s.raw("before").split(`
|
|
`);
|
|
let o = r.length - 1;
|
|
r[o].length > n &&
|
|
(a === !1 && (a = r[o].length - n),
|
|
(r[o] = r[o].slice(0, -a)),
|
|
(s.raws.before = r.join(`
|
|
`)));
|
|
});
|
|
}
|
|
displayType(e) {
|
|
for (let t of e.parent.nodes)
|
|
if (t.prop === "display") {
|
|
if (t.value.includes("flex")) return "flex";
|
|
if (t.value.includes("grid")) return "grid";
|
|
}
|
|
return !1;
|
|
}
|
|
gridStatus(e, t) {
|
|
if (!e) return !1;
|
|
if (e._autoprefixerGridStatus !== void 0)
|
|
return e._autoprefixerGridStatus;
|
|
let r = null;
|
|
if (e.nodes) {
|
|
let n;
|
|
e.each((a) => {
|
|
if (a.type === "comment" && _A.test(a.text)) {
|
|
let s = /:\s*autoplace/i.test(a.text),
|
|
o = /no-autoplace/i.test(a.text);
|
|
typeof n != "undefined"
|
|
? t.warn(
|
|
"Second Autoprefixer grid control comment was ignored. Autoprefixer applies control comments to the whole block, not to the next rules.",
|
|
{ node: a },
|
|
)
|
|
: s
|
|
? (n = "autoplace")
|
|
: o
|
|
? (n = !0)
|
|
: (n = /on/i.test(a.text));
|
|
}
|
|
}),
|
|
n !== void 0 && (r = n);
|
|
}
|
|
if (e.type === "atrule" && e.name === "supports") {
|
|
let n = e.params;
|
|
n.includes("grid") && n.includes("auto") && (r = !1);
|
|
}
|
|
if (!e.nodes || r === null)
|
|
if (e.parent) {
|
|
let n = this.gridStatus(e.parent, t);
|
|
e.parent._autoprefixerSelfDisabled === !0 ? (r = !1) : (r = n);
|
|
} else
|
|
typeof this.prefixes.options.grid != "undefined"
|
|
? (r = this.prefixes.options.grid)
|
|
: typeof h.env.AUTOPREFIXER_GRID != "undefined"
|
|
? h.env.AUTOPREFIXER_GRID === "autoplace"
|
|
? (r = "autoplace")
|
|
: (r = !0)
|
|
: (r = !1);
|
|
return (e._autoprefixerGridStatus = r), r;
|
|
}
|
|
};
|
|
ig.exports = rg;
|
|
});
|
|
var sg = v((zI, ng) => {
|
|
l();
|
|
ng.exports = {
|
|
A: {
|
|
A: { 2: "K E F G A B JC" },
|
|
B: {
|
|
1: "C L M H N D O P Q R S T U V W X Y Z a b c d e f g h i j n o p q r s t u v w x y z I",
|
|
},
|
|
C: {
|
|
1: "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB 0B dB 1B eB fB gB hB iB jB kB lB mB nB oB m pB qB rB sB tB P Q R 2B S T U V W X Y Z a b c d e f g h i j n o p q r s t u v w x y z I uB 3B 4B",
|
|
2: "0 1 KC zB J K E F G A B C L M H N D O k l LC MC",
|
|
},
|
|
D: {
|
|
1: "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB 0B dB 1B eB fB gB hB iB jB kB lB mB nB oB m pB qB rB sB tB P Q R S T U V W X Y Z a b c d e f g h i j n o p q r s t u v w x y z I uB 3B 4B",
|
|
2: "0 1 2 3 4 5 6 7 J K E F G A B C L M H N D O k l",
|
|
},
|
|
E: {
|
|
1: "G A B C L M H D RC 6B vB wB 7B SC TC 8B 9B xB AC yB BC CC DC EC FC GC UC",
|
|
2: "0 J K E F NC 5B OC PC QC",
|
|
},
|
|
F: {
|
|
1: "1 2 3 4 5 6 7 8 9 H N D O k l AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB m pB qB rB sB tB P Q R 2B S T U V W X Y Z a b c d e f g h i j wB",
|
|
2: "G B C VC WC XC YC vB HC ZC",
|
|
},
|
|
G: {
|
|
1: "D fC gC hC iC jC kC lC mC nC oC pC qC rC sC tC 8B 9B xB AC yB BC CC DC EC FC GC",
|
|
2: "F 5B aC IC bC cC dC eC",
|
|
},
|
|
H: { 1: "uC" },
|
|
I: { 1: "I zC 0C", 2: "zB J vC wC xC yC IC" },
|
|
J: { 2: "E A" },
|
|
K: { 1: "m", 2: "A B C vB HC wB" },
|
|
L: { 1: "I" },
|
|
M: { 1: "uB" },
|
|
N: { 2: "A B" },
|
|
O: { 1: "xB" },
|
|
P: { 1: "J k l 1C 2C 3C 4C 5C 6B 6C 7C 8C 9C AD yB BD CD DD" },
|
|
Q: { 1: "7B" },
|
|
R: { 1: "ED" },
|
|
S: { 1: "FD GD" },
|
|
},
|
|
B: 4,
|
|
C: "CSS Feature Queries",
|
|
};
|
|
});
|
|
var ug = v((VI, lg) => {
|
|
l();
|
|
function ag(i) {
|
|
return i[i.length - 1];
|
|
}
|
|
var og = {
|
|
parse(i) {
|
|
let e = [""],
|
|
t = [e];
|
|
for (let r of i) {
|
|
if (r === "(") {
|
|
(e = [""]), ag(t).push(e), t.push(e);
|
|
continue;
|
|
}
|
|
if (r === ")") {
|
|
t.pop(), (e = ag(t)), e.push("");
|
|
continue;
|
|
}
|
|
e[e.length - 1] += r;
|
|
}
|
|
return t[0];
|
|
},
|
|
stringify(i) {
|
|
let e = "";
|
|
for (let t of i) {
|
|
if (typeof t == "object") {
|
|
e += `(${og.stringify(t)})`;
|
|
continue;
|
|
}
|
|
e += t;
|
|
}
|
|
return e;
|
|
},
|
|
};
|
|
lg.exports = og;
|
|
});
|
|
var hg = v((UI, dg) => {
|
|
l();
|
|
var TA = sg(),
|
|
{ feature: PA } = ($n(), Ln),
|
|
{ parse: DA } = ge(),
|
|
IA = pt(),
|
|
nl = ug(),
|
|
qA = ke(),
|
|
RA = fe(),
|
|
fg = PA(TA),
|
|
cg = [];
|
|
for (let i in fg.stats) {
|
|
let e = fg.stats[i];
|
|
for (let t in e) {
|
|
let r = e[t];
|
|
/y/.test(r) && cg.push(i + " " + t);
|
|
}
|
|
}
|
|
var pg = class {
|
|
constructor(e, t) {
|
|
(this.Prefixes = e), (this.all = t);
|
|
}
|
|
prefixer() {
|
|
if (this.prefixerCache) return this.prefixerCache;
|
|
let e = this.all.browsers.selected.filter((r) => cg.includes(r)),
|
|
t = new IA(this.all.browsers.data, e, this.all.options);
|
|
return (
|
|
(this.prefixerCache = new this.Prefixes(
|
|
this.all.data,
|
|
t,
|
|
this.all.options,
|
|
)),
|
|
this.prefixerCache
|
|
);
|
|
}
|
|
parse(e) {
|
|
let t = e.split(":"),
|
|
r = t[0],
|
|
n = t[1];
|
|
return n || (n = ""), [r.trim(), n.trim()];
|
|
}
|
|
virtual(e) {
|
|
let [t, r] = this.parse(e),
|
|
n = DA("a{}").first;
|
|
return n.append({ prop: t, value: r, raws: { before: "" } }), n;
|
|
}
|
|
prefixed(e) {
|
|
let t = this.virtual(e);
|
|
if (this.disabled(t.first)) return t.nodes;
|
|
let r = { warn: () => null },
|
|
n = this.prefixer().add[t.first.prop];
|
|
n && n.process && n.process(t.first, r);
|
|
for (let a of t.nodes) {
|
|
for (let s of this.prefixer().values("add", t.first.prop))
|
|
s.process(a);
|
|
qA.save(this.all, a);
|
|
}
|
|
return t.nodes;
|
|
}
|
|
isNot(e) {
|
|
return typeof e == "string" && /not\s*/i.test(e);
|
|
}
|
|
isOr(e) {
|
|
return typeof e == "string" && /\s*or\s*/i.test(e);
|
|
}
|
|
isProp(e) {
|
|
return (
|
|
typeof e == "object" && e.length === 1 && typeof e[0] == "string"
|
|
);
|
|
}
|
|
isHack(e, t) {
|
|
return !new RegExp(`(\\(|\\s)${RA.escapeRegexp(t)}:`).test(e);
|
|
}
|
|
toRemove(e, t) {
|
|
let [r, n] = this.parse(e),
|
|
a = this.all.unprefixed(r),
|
|
s = this.all.cleaner();
|
|
if (s.remove[r] && s.remove[r].remove && !this.isHack(t, a)) return !0;
|
|
for (let o of s.values("remove", a)) if (o.check(n)) return !0;
|
|
return !1;
|
|
}
|
|
remove(e, t) {
|
|
let r = 0;
|
|
for (; r < e.length; ) {
|
|
if (
|
|
!this.isNot(e[r - 1]) &&
|
|
this.isProp(e[r]) &&
|
|
this.isOr(e[r + 1])
|
|
) {
|
|
if (this.toRemove(e[r][0], t)) {
|
|
e.splice(r, 2);
|
|
continue;
|
|
}
|
|
r += 2;
|
|
continue;
|
|
}
|
|
typeof e[r] == "object" && (e[r] = this.remove(e[r], t)), (r += 1);
|
|
}
|
|
return e;
|
|
}
|
|
cleanBrackets(e) {
|
|
return e.map((t) =>
|
|
typeof t != "object"
|
|
? t
|
|
: t.length === 1 && typeof t[0] == "object"
|
|
? this.cleanBrackets(t[0])
|
|
: this.cleanBrackets(t),
|
|
);
|
|
}
|
|
convert(e) {
|
|
let t = [""];
|
|
for (let r of e) t.push([`${r.prop}: ${r.value}`]), t.push(" or ");
|
|
return (t[t.length - 1] = ""), t;
|
|
}
|
|
normalize(e) {
|
|
if (typeof e != "object") return e;
|
|
if (((e = e.filter((t) => t !== "")), typeof e[0] == "string")) {
|
|
let t = e[0].trim();
|
|
if (t.includes(":") || t === "selector" || t === "not selector")
|
|
return [nl.stringify(e)];
|
|
}
|
|
return e.map((t) => this.normalize(t));
|
|
}
|
|
add(e, t) {
|
|
return e.map((r) => {
|
|
if (this.isProp(r)) {
|
|
let n = this.prefixed(r[0]);
|
|
return n.length > 1 ? this.convert(n) : r;
|
|
}
|
|
return typeof r == "object" ? this.add(r, t) : r;
|
|
});
|
|
}
|
|
process(e) {
|
|
let t = nl.parse(e.params);
|
|
(t = this.normalize(t)),
|
|
(t = this.remove(t, e.params)),
|
|
(t = this.add(t, e.params)),
|
|
(t = this.cleanBrackets(t)),
|
|
(e.params = nl.stringify(t));
|
|
}
|
|
disabled(e) {
|
|
if (
|
|
!this.all.options.grid &&
|
|
((e.prop === "display" && e.value.includes("grid")) ||
|
|
e.prop.includes("grid") ||
|
|
e.prop === "justify-items")
|
|
)
|
|
return !0;
|
|
if (this.all.options.flexbox === !1) {
|
|
if (e.prop === "display" && e.value.includes("flex")) return !0;
|
|
let t = ["order", "justify-content", "align-items", "align-content"];
|
|
if (e.prop.includes("flex") || t.includes(e.prop)) return !0;
|
|
}
|
|
return !1;
|
|
}
|
|
};
|
|
dg.exports = pg;
|
|
});
|
|
var yg = v((WI, gg) => {
|
|
l();
|
|
var mg = class {
|
|
constructor(e, t) {
|
|
(this.prefix = t),
|
|
(this.prefixed = e.prefixed(this.prefix)),
|
|
(this.regexp = e.regexp(this.prefix)),
|
|
(this.prefixeds = e
|
|
.possible()
|
|
.map((r) => [e.prefixed(r), e.regexp(r)])),
|
|
(this.unprefixed = e.name),
|
|
(this.nameRegexp = e.regexp());
|
|
}
|
|
isHack(e) {
|
|
let t = e.parent.index(e) + 1,
|
|
r = e.parent.nodes;
|
|
for (; t < r.length; ) {
|
|
let n = r[t].selector;
|
|
if (!n) return !0;
|
|
if (n.includes(this.unprefixed) && n.match(this.nameRegexp))
|
|
return !1;
|
|
let a = !1;
|
|
for (let [s, o] of this.prefixeds)
|
|
if (n.includes(s) && n.match(o)) {
|
|
a = !0;
|
|
break;
|
|
}
|
|
if (!a) return !0;
|
|
t += 1;
|
|
}
|
|
return !0;
|
|
}
|
|
check(e) {
|
|
return !(
|
|
!e.selector.includes(this.prefixed) ||
|
|
!e.selector.match(this.regexp) ||
|
|
this.isHack(e)
|
|
);
|
|
}
|
|
};
|
|
gg.exports = mg;
|
|
});
|
|
var Ht = v((GI, bg) => {
|
|
l();
|
|
var { list: MA } = ge(),
|
|
BA = yg(),
|
|
FA = Ut(),
|
|
NA = pt(),
|
|
LA = fe(),
|
|
wg = class extends FA {
|
|
constructor(e, t, r) {
|
|
super(e, t, r);
|
|
this.regexpCache = new Map();
|
|
}
|
|
check(e) {
|
|
return e.selector.includes(this.name)
|
|
? !!e.selector.match(this.regexp())
|
|
: !1;
|
|
}
|
|
prefixed(e) {
|
|
return this.name.replace(/^(\W*)/, `$1${e}`);
|
|
}
|
|
regexp(e) {
|
|
if (!this.regexpCache.has(e)) {
|
|
let t = e ? this.prefixed(e) : this.name;
|
|
this.regexpCache.set(
|
|
e,
|
|
new RegExp(`(^|[^:"'=])${LA.escapeRegexp(t)}`, "gi"),
|
|
);
|
|
}
|
|
return this.regexpCache.get(e);
|
|
}
|
|
possible() {
|
|
return NA.prefixes();
|
|
}
|
|
prefixeds(e) {
|
|
if (e._autoprefixerPrefixeds) {
|
|
if (e._autoprefixerPrefixeds[this.name])
|
|
return e._autoprefixerPrefixeds;
|
|
} else e._autoprefixerPrefixeds = {};
|
|
let t = {};
|
|
if (e.selector.includes(",")) {
|
|
let n = MA.comma(e.selector).filter((a) => a.includes(this.name));
|
|
for (let a of this.possible())
|
|
t[a] = n.map((s) => this.replace(s, a)).join(", ");
|
|
} else
|
|
for (let r of this.possible()) t[r] = this.replace(e.selector, r);
|
|
return (
|
|
(e._autoprefixerPrefixeds[this.name] = t), e._autoprefixerPrefixeds
|
|
);
|
|
}
|
|
already(e, t, r) {
|
|
let n = e.parent.index(e) - 1;
|
|
for (; n >= 0; ) {
|
|
let a = e.parent.nodes[n];
|
|
if (a.type !== "rule") return !1;
|
|
let s = !1;
|
|
for (let o in t[this.name]) {
|
|
let u = t[this.name][o];
|
|
if (a.selector === u) {
|
|
if (r === o) return !0;
|
|
s = !0;
|
|
break;
|
|
}
|
|
}
|
|
if (!s) return !1;
|
|
n -= 1;
|
|
}
|
|
return !1;
|
|
}
|
|
replace(e, t) {
|
|
return e.replace(this.regexp(), `$1${this.prefixed(t)}`);
|
|
}
|
|
add(e, t) {
|
|
let r = this.prefixeds(e);
|
|
if (this.already(e, r, t)) return;
|
|
let n = this.clone(e, { selector: r[this.name][t] });
|
|
e.parent.insertBefore(e, n);
|
|
}
|
|
old(e) {
|
|
return new BA(this, e);
|
|
}
|
|
};
|
|
bg.exports = wg;
|
|
});
|
|
var kg = v((HI, xg) => {
|
|
l();
|
|
var $A = Ut(),
|
|
vg = class extends $A {
|
|
add(e, t) {
|
|
let r = t + e.name;
|
|
if (e.parent.some((s) => s.name === r && s.params === e.params))
|
|
return;
|
|
let a = this.clone(e, { name: r });
|
|
return e.parent.insertBefore(e, a);
|
|
}
|
|
process(e) {
|
|
let t = this.parentPrefix(e);
|
|
for (let r of this.prefixes) (!t || t === r) && this.add(e, r);
|
|
}
|
|
};
|
|
xg.exports = vg;
|
|
});
|
|
var Cg = v((YI, Sg) => {
|
|
l();
|
|
var jA = Ht(),
|
|
sl = class extends jA {
|
|
prefixed(e) {
|
|
return e === "-webkit-"
|
|
? ":-webkit-full-screen"
|
|
: e === "-moz-"
|
|
? ":-moz-full-screen"
|
|
: `:${e}fullscreen`;
|
|
}
|
|
};
|
|
sl.names = [":fullscreen"];
|
|
Sg.exports = sl;
|
|
});
|
|
var _g = v((QI, Ag) => {
|
|
l();
|
|
var zA = Ht(),
|
|
al = class extends zA {
|
|
possible() {
|
|
return super.possible().concat(["-moz- old", "-ms- old"]);
|
|
}
|
|
prefixed(e) {
|
|
return e === "-webkit-"
|
|
? "::-webkit-input-placeholder"
|
|
: e === "-ms-"
|
|
? "::-ms-input-placeholder"
|
|
: e === "-ms- old"
|
|
? ":-ms-input-placeholder"
|
|
: e === "-moz- old"
|
|
? ":-moz-placeholder"
|
|
: `::${e}placeholder`;
|
|
}
|
|
};
|
|
al.names = ["::placeholder"];
|
|
Ag.exports = al;
|
|
});
|
|
var Eg = v((JI, Og) => {
|
|
l();
|
|
var VA = Ht(),
|
|
ol = class extends VA {
|
|
prefixed(e) {
|
|
return e === "-ms-"
|
|
? ":-ms-input-placeholder"
|
|
: `:${e}placeholder-shown`;
|
|
}
|
|
};
|
|
ol.names = [":placeholder-shown"];
|
|
Og.exports = ol;
|
|
});
|
|
var Pg = v((XI, Tg) => {
|
|
l();
|
|
var UA = Ht(),
|
|
WA = fe(),
|
|
ll = class extends UA {
|
|
constructor(e, t, r) {
|
|
super(e, t, r);
|
|
this.prefixes &&
|
|
(this.prefixes = WA.uniq(this.prefixes.map((n) => "-webkit-")));
|
|
}
|
|
prefixed(e) {
|
|
return e === "-webkit-"
|
|
? "::-webkit-file-upload-button"
|
|
: `::${e}file-selector-button`;
|
|
}
|
|
};
|
|
ll.names = ["::file-selector-button"];
|
|
Tg.exports = ll;
|
|
});
|
|
var he = v((KI, Dg) => {
|
|
l();
|
|
Dg.exports = function (i) {
|
|
let e;
|
|
return (
|
|
i === "-webkit- 2009" || i === "-moz-"
|
|
? (e = 2009)
|
|
: i === "-ms-"
|
|
? (e = 2012)
|
|
: i === "-webkit-" && (e = "final"),
|
|
i === "-webkit- 2009" && (i = "-webkit-"),
|
|
[e, i]
|
|
);
|
|
};
|
|
});
|
|
var Mg = v((ZI, Rg) => {
|
|
l();
|
|
var Ig = ge().list,
|
|
qg = he(),
|
|
GA = R(),
|
|
Yt = class extends GA {
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = qg(t)), r === 2009 ? t + "box-flex" : super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "flex";
|
|
}
|
|
set(e, t) {
|
|
let r = qg(t)[0];
|
|
if (r === 2009)
|
|
return (
|
|
(e.value = Ig.space(e.value)[0]),
|
|
(e.value = Yt.oldValues[e.value] || e.value),
|
|
super.set(e, t)
|
|
);
|
|
if (r === 2012) {
|
|
let n = Ig.space(e.value);
|
|
n.length === 3 &&
|
|
n[2] === "0" &&
|
|
(e.value = n.slice(0, 2).concat("0px").join(" "));
|
|
}
|
|
return super.set(e, t);
|
|
}
|
|
};
|
|
Yt.names = ["flex", "box-flex"];
|
|
Yt.oldValues = { auto: "1", none: "0" };
|
|
Rg.exports = Yt;
|
|
});
|
|
var Ng = v((e4, Fg) => {
|
|
l();
|
|
var Bg = he(),
|
|
HA = R(),
|
|
ul = class extends HA {
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = Bg(t)),
|
|
r === 2009
|
|
? t + "box-ordinal-group"
|
|
: r === 2012
|
|
? t + "flex-order"
|
|
: super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "order";
|
|
}
|
|
set(e, t) {
|
|
return Bg(t)[0] === 2009 && /\d/.test(e.value)
|
|
? ((e.value = (parseInt(e.value) + 1).toString()), super.set(e, t))
|
|
: super.set(e, t);
|
|
}
|
|
};
|
|
ul.names = ["order", "flex-order", "box-ordinal-group"];
|
|
Fg.exports = ul;
|
|
});
|
|
var $g = v((t4, Lg) => {
|
|
l();
|
|
var YA = R(),
|
|
fl = class extends YA {
|
|
check(e) {
|
|
let t = e.value;
|
|
return (
|
|
!t.toLowerCase().includes("alpha(") &&
|
|
!t.includes("DXImageTransform.Microsoft") &&
|
|
!t.includes("data:image/svg+xml")
|
|
);
|
|
}
|
|
};
|
|
fl.names = ["filter"];
|
|
Lg.exports = fl;
|
|
});
|
|
var zg = v((r4, jg) => {
|
|
l();
|
|
var QA = R(),
|
|
cl = class extends QA {
|
|
insert(e, t, r, n) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
let a = this.clone(e),
|
|
s = e.prop.replace(/end$/, "start"),
|
|
o = t + e.prop.replace(/end$/, "span");
|
|
if (!e.parent.some((u) => u.prop === o)) {
|
|
if (((a.prop = o), e.value.includes("span")))
|
|
a.value = e.value.replace(/span\s/i, "");
|
|
else {
|
|
let u;
|
|
if (
|
|
(e.parent.walkDecls(s, (c) => {
|
|
u = c;
|
|
}),
|
|
u)
|
|
) {
|
|
let c = Number(e.value) - Number(u.value) + "";
|
|
a.value = c;
|
|
} else e.warn(n, `Can not prefix ${e.prop} (${s} is not found)`);
|
|
}
|
|
e.cloneBefore(a);
|
|
}
|
|
}
|
|
};
|
|
cl.names = ["grid-row-end", "grid-column-end"];
|
|
jg.exports = cl;
|
|
});
|
|
var Ug = v((i4, Vg) => {
|
|
l();
|
|
var JA = R(),
|
|
pl = class extends JA {
|
|
check(e) {
|
|
return !e.value.split(/\s+/).some((t) => {
|
|
let r = t.toLowerCase();
|
|
return r === "reverse" || r === "alternate-reverse";
|
|
});
|
|
}
|
|
};
|
|
pl.names = ["animation", "animation-direction"];
|
|
Vg.exports = pl;
|
|
});
|
|
var Gg = v((n4, Wg) => {
|
|
l();
|
|
var XA = he(),
|
|
KA = R(),
|
|
dl = class extends KA {
|
|
insert(e, t, r) {
|
|
let n;
|
|
if ((([n, t] = XA(t)), n !== 2009)) return super.insert(e, t, r);
|
|
let a = e.value
|
|
.split(/\s+/)
|
|
.filter((d) => d !== "wrap" && d !== "nowrap" && "wrap-reverse");
|
|
if (
|
|
a.length === 0 ||
|
|
e.parent.some(
|
|
(d) =>
|
|
d.prop === t + "box-orient" || d.prop === t + "box-direction",
|
|
)
|
|
)
|
|
return;
|
|
let o = a[0],
|
|
u = o.includes("row") ? "horizontal" : "vertical",
|
|
c = o.includes("reverse") ? "reverse" : "normal",
|
|
f = this.clone(e);
|
|
return (
|
|
(f.prop = t + "box-orient"),
|
|
(f.value = u),
|
|
this.needCascade(e) && (f.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, f),
|
|
(f = this.clone(e)),
|
|
(f.prop = t + "box-direction"),
|
|
(f.value = c),
|
|
this.needCascade(e) && (f.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, f)
|
|
);
|
|
}
|
|
};
|
|
dl.names = ["flex-flow", "box-direction", "box-orient"];
|
|
Wg.exports = dl;
|
|
});
|
|
var Yg = v((s4, Hg) => {
|
|
l();
|
|
var ZA = he(),
|
|
e_ = R(),
|
|
hl = class extends e_ {
|
|
normalize() {
|
|
return "flex";
|
|
}
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = ZA(t)),
|
|
r === 2009
|
|
? t + "box-flex"
|
|
: r === 2012
|
|
? t + "flex-positive"
|
|
: super.prefixed(e, t)
|
|
);
|
|
}
|
|
};
|
|
hl.names = ["flex-grow", "flex-positive"];
|
|
Hg.exports = hl;
|
|
});
|
|
var Jg = v((a4, Qg) => {
|
|
l();
|
|
var t_ = he(),
|
|
r_ = R(),
|
|
ml = class extends r_ {
|
|
set(e, t) {
|
|
if (t_(t)[0] !== 2009) return super.set(e, t);
|
|
}
|
|
};
|
|
ml.names = ["flex-wrap"];
|
|
Qg.exports = ml;
|
|
});
|
|
var Kg = v((o4, Xg) => {
|
|
l();
|
|
var i_ = R(),
|
|
Qt = ht(),
|
|
gl = class extends i_ {
|
|
insert(e, t, r, n) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
let a = Qt.parse(e),
|
|
[s, o] = Qt.translate(a, 0, 2),
|
|
[u, c] = Qt.translate(a, 1, 3);
|
|
[
|
|
["grid-row", s],
|
|
["grid-row-span", o],
|
|
["grid-column", u],
|
|
["grid-column-span", c],
|
|
].forEach(([f, d]) => {
|
|
Qt.insertDecl(e, f, d);
|
|
}),
|
|
Qt.warnTemplateSelectorNotFound(e, n),
|
|
Qt.warnIfGridRowColumnExists(e, n);
|
|
}
|
|
};
|
|
gl.names = ["grid-area"];
|
|
Xg.exports = gl;
|
|
});
|
|
var ey = v((l4, Zg) => {
|
|
l();
|
|
var n_ = R(),
|
|
ni = ht(),
|
|
yl = class extends n_ {
|
|
insert(e, t, r) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
if (e.parent.some((s) => s.prop === "-ms-grid-row-align")) return;
|
|
let [[n, a]] = ni.parse(e);
|
|
a
|
|
? (ni.insertDecl(e, "grid-row-align", n),
|
|
ni.insertDecl(e, "grid-column-align", a))
|
|
: (ni.insertDecl(e, "grid-row-align", n),
|
|
ni.insertDecl(e, "grid-column-align", n));
|
|
}
|
|
};
|
|
yl.names = ["place-self"];
|
|
Zg.exports = yl;
|
|
});
|
|
var ry = v((u4, ty) => {
|
|
l();
|
|
var s_ = R(),
|
|
wl = class extends s_ {
|
|
check(e) {
|
|
let t = e.value;
|
|
return !t.includes("/") || t.includes("span");
|
|
}
|
|
normalize(e) {
|
|
return e.replace("-start", "");
|
|
}
|
|
prefixed(e, t) {
|
|
let r = super.prefixed(e, t);
|
|
return t === "-ms-" && (r = r.replace("-start", "")), r;
|
|
}
|
|
};
|
|
wl.names = ["grid-row-start", "grid-column-start"];
|
|
ty.exports = wl;
|
|
});
|
|
var sy = v((f4, ny) => {
|
|
l();
|
|
var iy = he(),
|
|
a_ = R(),
|
|
Jt = class extends a_ {
|
|
check(e) {
|
|
return (
|
|
e.parent &&
|
|
!e.parent.some((t) => t.prop && t.prop.startsWith("grid-"))
|
|
);
|
|
}
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = iy(t)),
|
|
r === 2012 ? t + "flex-item-align" : super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "align-self";
|
|
}
|
|
set(e, t) {
|
|
let r = iy(t)[0];
|
|
if (r === 2012)
|
|
return (
|
|
(e.value = Jt.oldValues[e.value] || e.value), super.set(e, t)
|
|
);
|
|
if (r === "final") return super.set(e, t);
|
|
}
|
|
};
|
|
Jt.names = ["align-self", "flex-item-align"];
|
|
Jt.oldValues = { "flex-end": "end", "flex-start": "start" };
|
|
ny.exports = Jt;
|
|
});
|
|
var oy = v((c4, ay) => {
|
|
l();
|
|
var o_ = R(),
|
|
l_ = fe(),
|
|
bl = class extends o_ {
|
|
constructor(e, t, r) {
|
|
super(e, t, r);
|
|
this.prefixes &&
|
|
(this.prefixes = l_.uniq(
|
|
this.prefixes.map((n) => (n === "-ms-" ? "-webkit-" : n)),
|
|
));
|
|
}
|
|
};
|
|
bl.names = ["appearance"];
|
|
ay.exports = bl;
|
|
});
|
|
var fy = v((p4, uy) => {
|
|
l();
|
|
var ly = he(),
|
|
u_ = R(),
|
|
vl = class extends u_ {
|
|
normalize() {
|
|
return "flex-basis";
|
|
}
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = ly(t)),
|
|
r === 2012 ? t + "flex-preferred-size" : super.prefixed(e, t)
|
|
);
|
|
}
|
|
set(e, t) {
|
|
let r;
|
|
if ((([r, t] = ly(t)), r === 2012 || r === "final"))
|
|
return super.set(e, t);
|
|
}
|
|
};
|
|
vl.names = ["flex-basis", "flex-preferred-size"];
|
|
uy.exports = vl;
|
|
});
|
|
var py = v((d4, cy) => {
|
|
l();
|
|
var f_ = R(),
|
|
xl = class extends f_ {
|
|
normalize() {
|
|
return this.name.replace("box-image", "border");
|
|
}
|
|
prefixed(e, t) {
|
|
let r = super.prefixed(e, t);
|
|
return t === "-webkit-" && (r = r.replace("border", "box-image")), r;
|
|
}
|
|
};
|
|
xl.names = [
|
|
"mask-border",
|
|
"mask-border-source",
|
|
"mask-border-slice",
|
|
"mask-border-width",
|
|
"mask-border-outset",
|
|
"mask-border-repeat",
|
|
"mask-box-image",
|
|
"mask-box-image-source",
|
|
"mask-box-image-slice",
|
|
"mask-box-image-width",
|
|
"mask-box-image-outset",
|
|
"mask-box-image-repeat",
|
|
];
|
|
cy.exports = xl;
|
|
});
|
|
var hy = v((h4, dy) => {
|
|
l();
|
|
var c_ = R(),
|
|
Ne = class extends c_ {
|
|
insert(e, t, r) {
|
|
let n = e.prop === "mask-composite",
|
|
a;
|
|
n ? (a = e.value.split(",")) : (a = e.value.match(Ne.regexp) || []),
|
|
(a = a.map((c) => c.trim()).filter((c) => c));
|
|
let s = a.length,
|
|
o;
|
|
if (
|
|
(s &&
|
|
((o = this.clone(e)),
|
|
(o.value = a.map((c) => Ne.oldValues[c] || c).join(", ")),
|
|
a.includes("intersect") && (o.value += ", xor"),
|
|
(o.prop = t + "mask-composite")),
|
|
n)
|
|
)
|
|
return s
|
|
? (this.needCascade(e) &&
|
|
(o.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, o))
|
|
: void 0;
|
|
let u = this.clone(e);
|
|
return (
|
|
(u.prop = t + u.prop),
|
|
s && (u.value = u.value.replace(Ne.regexp, "")),
|
|
this.needCascade(e) && (u.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, u),
|
|
s
|
|
? (this.needCascade(e) &&
|
|
(o.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, o))
|
|
: e
|
|
);
|
|
}
|
|
};
|
|
Ne.names = ["mask", "mask-composite"];
|
|
Ne.oldValues = {
|
|
add: "source-over",
|
|
subtract: "source-out",
|
|
intersect: "source-in",
|
|
exclude: "xor",
|
|
};
|
|
Ne.regexp = new RegExp(
|
|
`\\s+(${Object.keys(Ne.oldValues).join("|")})\\b(?!\\))\\s*(?=[,])`,
|
|
"ig",
|
|
);
|
|
dy.exports = Ne;
|
|
});
|
|
var yy = v((m4, gy) => {
|
|
l();
|
|
var my = he(),
|
|
p_ = R(),
|
|
Xt = class extends p_ {
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = my(t)),
|
|
r === 2009
|
|
? t + "box-align"
|
|
: r === 2012
|
|
? t + "flex-align"
|
|
: super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "align-items";
|
|
}
|
|
set(e, t) {
|
|
let r = my(t)[0];
|
|
return (
|
|
(r === 2009 || r === 2012) &&
|
|
(e.value = Xt.oldValues[e.value] || e.value),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
};
|
|
Xt.names = ["align-items", "flex-align", "box-align"];
|
|
Xt.oldValues = { "flex-end": "end", "flex-start": "start" };
|
|
gy.exports = Xt;
|
|
});
|
|
var by = v((g4, wy) => {
|
|
l();
|
|
var d_ = R(),
|
|
kl = class extends d_ {
|
|
set(e, t) {
|
|
return (
|
|
t === "-ms-" && e.value === "contain" && (e.value = "element"),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
insert(e, t, r) {
|
|
if (!(e.value === "all" && t === "-ms-"))
|
|
return super.insert(e, t, r);
|
|
}
|
|
};
|
|
kl.names = ["user-select"];
|
|
wy.exports = kl;
|
|
});
|
|
var ky = v((y4, xy) => {
|
|
l();
|
|
var vy = he(),
|
|
h_ = R(),
|
|
Sl = class extends h_ {
|
|
normalize() {
|
|
return "flex-shrink";
|
|
}
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = vy(t)),
|
|
r === 2012 ? t + "flex-negative" : super.prefixed(e, t)
|
|
);
|
|
}
|
|
set(e, t) {
|
|
let r;
|
|
if ((([r, t] = vy(t)), r === 2012 || r === "final"))
|
|
return super.set(e, t);
|
|
}
|
|
};
|
|
Sl.names = ["flex-shrink", "flex-negative"];
|
|
xy.exports = Sl;
|
|
});
|
|
var Cy = v((w4, Sy) => {
|
|
l();
|
|
var m_ = R(),
|
|
Cl = class extends m_ {
|
|
prefixed(e, t) {
|
|
return `${t}column-${e}`;
|
|
}
|
|
normalize(e) {
|
|
return e.includes("inside")
|
|
? "break-inside"
|
|
: e.includes("before")
|
|
? "break-before"
|
|
: "break-after";
|
|
}
|
|
set(e, t) {
|
|
return (
|
|
((e.prop === "break-inside" && e.value === "avoid-column") ||
|
|
e.value === "avoid-page") &&
|
|
(e.value = "avoid"),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
insert(e, t, r) {
|
|
if (e.prop !== "break-inside") return super.insert(e, t, r);
|
|
if (!(/region/i.test(e.value) || /page/i.test(e.value)))
|
|
return super.insert(e, t, r);
|
|
}
|
|
};
|
|
Cl.names = [
|
|
"break-inside",
|
|
"page-break-inside",
|
|
"column-break-inside",
|
|
"break-before",
|
|
"page-break-before",
|
|
"column-break-before",
|
|
"break-after",
|
|
"page-break-after",
|
|
"column-break-after",
|
|
];
|
|
Sy.exports = Cl;
|
|
});
|
|
var _y = v((b4, Ay) => {
|
|
l();
|
|
var g_ = R(),
|
|
Al = class extends g_ {
|
|
prefixed(e, t) {
|
|
return t + "print-color-adjust";
|
|
}
|
|
normalize() {
|
|
return "color-adjust";
|
|
}
|
|
};
|
|
Al.names = ["color-adjust", "print-color-adjust"];
|
|
Ay.exports = Al;
|
|
});
|
|
var Ey = v((v4, Oy) => {
|
|
l();
|
|
var y_ = R(),
|
|
Kt = class extends y_ {
|
|
insert(e, t, r) {
|
|
if (t === "-ms-") {
|
|
let n = this.set(this.clone(e), t);
|
|
this.needCascade(e) && (n.raws.before = this.calcBefore(r, e, t));
|
|
let a = "ltr";
|
|
return (
|
|
e.parent.nodes.forEach((s) => {
|
|
s.prop === "direction" &&
|
|
(s.value === "rtl" || s.value === "ltr") &&
|
|
(a = s.value);
|
|
}),
|
|
(n.value = Kt.msValues[a][e.value] || e.value),
|
|
e.parent.insertBefore(e, n)
|
|
);
|
|
}
|
|
return super.insert(e, t, r);
|
|
}
|
|
};
|
|
Kt.names = ["writing-mode"];
|
|
Kt.msValues = {
|
|
ltr: {
|
|
"horizontal-tb": "lr-tb",
|
|
"vertical-rl": "tb-rl",
|
|
"vertical-lr": "tb-lr",
|
|
},
|
|
rtl: {
|
|
"horizontal-tb": "rl-tb",
|
|
"vertical-rl": "bt-rl",
|
|
"vertical-lr": "bt-lr",
|
|
},
|
|
};
|
|
Oy.exports = Kt;
|
|
});
|
|
var Py = v((x4, Ty) => {
|
|
l();
|
|
var w_ = R(),
|
|
_l = class extends w_ {
|
|
set(e, t) {
|
|
return (
|
|
(e.value = e.value.replace(/\s+fill(\s)/, "$1")), super.set(e, t)
|
|
);
|
|
}
|
|
};
|
|
_l.names = ["border-image"];
|
|
Ty.exports = _l;
|
|
});
|
|
var qy = v((k4, Iy) => {
|
|
l();
|
|
var Dy = he(),
|
|
b_ = R(),
|
|
Zt = class extends b_ {
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = Dy(t)),
|
|
r === 2012 ? t + "flex-line-pack" : super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "align-content";
|
|
}
|
|
set(e, t) {
|
|
let r = Dy(t)[0];
|
|
if (r === 2012)
|
|
return (
|
|
(e.value = Zt.oldValues[e.value] || e.value), super.set(e, t)
|
|
);
|
|
if (r === "final") return super.set(e, t);
|
|
}
|
|
};
|
|
Zt.names = ["align-content", "flex-line-pack"];
|
|
Zt.oldValues = {
|
|
"flex-end": "end",
|
|
"flex-start": "start",
|
|
"space-between": "justify",
|
|
"space-around": "distribute",
|
|
};
|
|
Iy.exports = Zt;
|
|
});
|
|
var My = v((S4, Ry) => {
|
|
l();
|
|
var v_ = R(),
|
|
Se = class extends v_ {
|
|
prefixed(e, t) {
|
|
return t === "-moz-"
|
|
? t + (Se.toMozilla[e] || e)
|
|
: super.prefixed(e, t);
|
|
}
|
|
normalize(e) {
|
|
return Se.toNormal[e] || e;
|
|
}
|
|
};
|
|
Se.names = ["border-radius"];
|
|
Se.toMozilla = {};
|
|
Se.toNormal = {};
|
|
for (let i of ["top", "bottom"])
|
|
for (let e of ["left", "right"]) {
|
|
let t = `border-${i}-${e}-radius`,
|
|
r = `border-radius-${i}${e}`;
|
|
Se.names.push(t),
|
|
Se.names.push(r),
|
|
(Se.toMozilla[t] = r),
|
|
(Se.toNormal[r] = t);
|
|
}
|
|
Ry.exports = Se;
|
|
});
|
|
var Fy = v((C4, By) => {
|
|
l();
|
|
var x_ = R(),
|
|
Ol = class extends x_ {
|
|
prefixed(e, t) {
|
|
return e.includes("-start")
|
|
? t + e.replace("-block-start", "-before")
|
|
: t + e.replace("-block-end", "-after");
|
|
}
|
|
normalize(e) {
|
|
return e.includes("-before")
|
|
? e.replace("-before", "-block-start")
|
|
: e.replace("-after", "-block-end");
|
|
}
|
|
};
|
|
Ol.names = [
|
|
"border-block-start",
|
|
"border-block-end",
|
|
"margin-block-start",
|
|
"margin-block-end",
|
|
"padding-block-start",
|
|
"padding-block-end",
|
|
"border-before",
|
|
"border-after",
|
|
"margin-before",
|
|
"margin-after",
|
|
"padding-before",
|
|
"padding-after",
|
|
];
|
|
By.exports = Ol;
|
|
});
|
|
var Ly = v((A4, Ny) => {
|
|
l();
|
|
var k_ = R(),
|
|
{
|
|
parseTemplate: S_,
|
|
warnMissedAreas: C_,
|
|
getGridGap: A_,
|
|
warnGridGap: __,
|
|
inheritGridGap: O_,
|
|
} = ht(),
|
|
El = class extends k_ {
|
|
insert(e, t, r, n) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
if (e.parent.some((m) => m.prop === "-ms-grid-rows")) return;
|
|
let a = A_(e),
|
|
s = O_(e, a),
|
|
{ rows: o, columns: u, areas: c } = S_({ decl: e, gap: s || a }),
|
|
f = Object.keys(c).length > 0,
|
|
d = Boolean(o),
|
|
p = Boolean(u);
|
|
return (
|
|
__({ gap: a, hasColumns: p, decl: e, result: n }),
|
|
C_(c, e, n),
|
|
((d && p) || f) &&
|
|
e.cloneBefore({ prop: "-ms-grid-rows", value: o, raws: {} }),
|
|
p &&
|
|
e.cloneBefore({ prop: "-ms-grid-columns", value: u, raws: {} }),
|
|
e
|
|
);
|
|
}
|
|
};
|
|
El.names = ["grid-template"];
|
|
Ny.exports = El;
|
|
});
|
|
var jy = v((_4, $y) => {
|
|
l();
|
|
var E_ = R(),
|
|
Tl = class extends E_ {
|
|
prefixed(e, t) {
|
|
return t + e.replace("-inline", "");
|
|
}
|
|
normalize(e) {
|
|
return e.replace(
|
|
/(margin|padding|border)-(start|end)/,
|
|
"$1-inline-$2",
|
|
);
|
|
}
|
|
};
|
|
Tl.names = [
|
|
"border-inline-start",
|
|
"border-inline-end",
|
|
"margin-inline-start",
|
|
"margin-inline-end",
|
|
"padding-inline-start",
|
|
"padding-inline-end",
|
|
"border-start",
|
|
"border-end",
|
|
"margin-start",
|
|
"margin-end",
|
|
"padding-start",
|
|
"padding-end",
|
|
];
|
|
$y.exports = Tl;
|
|
});
|
|
var Vy = v((O4, zy) => {
|
|
l();
|
|
var T_ = R(),
|
|
Pl = class extends T_ {
|
|
check(e) {
|
|
return !e.value.includes("flex-") && e.value !== "baseline";
|
|
}
|
|
prefixed(e, t) {
|
|
return t + "grid-row-align";
|
|
}
|
|
normalize() {
|
|
return "align-self";
|
|
}
|
|
};
|
|
Pl.names = ["grid-row-align"];
|
|
zy.exports = Pl;
|
|
});
|
|
var Wy = v((E4, Uy) => {
|
|
l();
|
|
var P_ = R(),
|
|
er = class extends P_ {
|
|
keyframeParents(e) {
|
|
let { parent: t } = e;
|
|
for (; t; ) {
|
|
if (t.type === "atrule" && t.name === "keyframes") return !0;
|
|
({ parent: t } = t);
|
|
}
|
|
return !1;
|
|
}
|
|
contain3d(e) {
|
|
if (e.prop === "transform-origin") return !1;
|
|
for (let t of er.functions3d)
|
|
if (e.value.includes(`${t}(`)) return !0;
|
|
return !1;
|
|
}
|
|
set(e, t) {
|
|
return (
|
|
(e = super.set(e, t)),
|
|
t === "-ms-" && (e.value = e.value.replace(/rotatez/gi, "rotate")),
|
|
e
|
|
);
|
|
}
|
|
insert(e, t, r) {
|
|
if (t === "-ms-") {
|
|
if (!this.contain3d(e) && !this.keyframeParents(e))
|
|
return super.insert(e, t, r);
|
|
} else if (t === "-o-") {
|
|
if (!this.contain3d(e)) return super.insert(e, t, r);
|
|
} else return super.insert(e, t, r);
|
|
}
|
|
};
|
|
er.names = ["transform", "transform-origin"];
|
|
er.functions3d = [
|
|
"matrix3d",
|
|
"translate3d",
|
|
"translateZ",
|
|
"scale3d",
|
|
"scaleZ",
|
|
"rotate3d",
|
|
"rotateX",
|
|
"rotateY",
|
|
"perspective",
|
|
];
|
|
Uy.exports = er;
|
|
});
|
|
var Yy = v((T4, Hy) => {
|
|
l();
|
|
var Gy = he(),
|
|
D_ = R(),
|
|
Dl = class extends D_ {
|
|
normalize() {
|
|
return "flex-direction";
|
|
}
|
|
insert(e, t, r) {
|
|
let n;
|
|
if ((([n, t] = Gy(t)), n !== 2009)) return super.insert(e, t, r);
|
|
if (
|
|
e.parent.some(
|
|
(f) =>
|
|
f.prop === t + "box-orient" || f.prop === t + "box-direction",
|
|
)
|
|
)
|
|
return;
|
|
let s = e.value,
|
|
o,
|
|
u;
|
|
s === "inherit" || s === "initial" || s === "unset"
|
|
? ((o = s), (u = s))
|
|
: ((o = s.includes("row") ? "horizontal" : "vertical"),
|
|
(u = s.includes("reverse") ? "reverse" : "normal"));
|
|
let c = this.clone(e);
|
|
return (
|
|
(c.prop = t + "box-orient"),
|
|
(c.value = o),
|
|
this.needCascade(e) && (c.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, c),
|
|
(c = this.clone(e)),
|
|
(c.prop = t + "box-direction"),
|
|
(c.value = u),
|
|
this.needCascade(e) && (c.raws.before = this.calcBefore(r, e, t)),
|
|
e.parent.insertBefore(e, c)
|
|
);
|
|
}
|
|
old(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = Gy(t)),
|
|
r === 2009
|
|
? [t + "box-orient", t + "box-direction"]
|
|
: super.old(e, t)
|
|
);
|
|
}
|
|
};
|
|
Dl.names = ["flex-direction", "box-direction", "box-orient"];
|
|
Hy.exports = Dl;
|
|
});
|
|
var Jy = v((P4, Qy) => {
|
|
l();
|
|
var I_ = R(),
|
|
Il = class extends I_ {
|
|
check(e) {
|
|
return e.value === "pixelated";
|
|
}
|
|
prefixed(e, t) {
|
|
return t === "-ms-" ? "-ms-interpolation-mode" : super.prefixed(e, t);
|
|
}
|
|
set(e, t) {
|
|
return t !== "-ms-"
|
|
? super.set(e, t)
|
|
: ((e.prop = "-ms-interpolation-mode"),
|
|
(e.value = "nearest-neighbor"),
|
|
e);
|
|
}
|
|
normalize() {
|
|
return "image-rendering";
|
|
}
|
|
process(e, t) {
|
|
return super.process(e, t);
|
|
}
|
|
};
|
|
Il.names = ["image-rendering", "interpolation-mode"];
|
|
Qy.exports = Il;
|
|
});
|
|
var Ky = v((D4, Xy) => {
|
|
l();
|
|
var q_ = R(),
|
|
R_ = fe(),
|
|
ql = class extends q_ {
|
|
constructor(e, t, r) {
|
|
super(e, t, r);
|
|
this.prefixes &&
|
|
(this.prefixes = R_.uniq(
|
|
this.prefixes.map((n) => (n === "-ms-" ? "-webkit-" : n)),
|
|
));
|
|
}
|
|
};
|
|
ql.names = ["backdrop-filter"];
|
|
Xy.exports = ql;
|
|
});
|
|
var ew = v((I4, Zy) => {
|
|
l();
|
|
var M_ = R(),
|
|
B_ = fe(),
|
|
Rl = class extends M_ {
|
|
constructor(e, t, r) {
|
|
super(e, t, r);
|
|
this.prefixes &&
|
|
(this.prefixes = B_.uniq(
|
|
this.prefixes.map((n) => (n === "-ms-" ? "-webkit-" : n)),
|
|
));
|
|
}
|
|
check(e) {
|
|
return e.value.toLowerCase() === "text";
|
|
}
|
|
};
|
|
Rl.names = ["background-clip"];
|
|
Zy.exports = Rl;
|
|
});
|
|
var rw = v((q4, tw) => {
|
|
l();
|
|
var F_ = R(),
|
|
N_ = [
|
|
"none",
|
|
"underline",
|
|
"overline",
|
|
"line-through",
|
|
"blink",
|
|
"inherit",
|
|
"initial",
|
|
"unset",
|
|
],
|
|
Ml = class extends F_ {
|
|
check(e) {
|
|
return e.value.split(/\s+/).some((t) => !N_.includes(t));
|
|
}
|
|
};
|
|
Ml.names = ["text-decoration"];
|
|
tw.exports = Ml;
|
|
});
|
|
var sw = v((R4, nw) => {
|
|
l();
|
|
var iw = he(),
|
|
L_ = R(),
|
|
tr = class extends L_ {
|
|
prefixed(e, t) {
|
|
let r;
|
|
return (
|
|
([r, t] = iw(t)),
|
|
r === 2009
|
|
? t + "box-pack"
|
|
: r === 2012
|
|
? t + "flex-pack"
|
|
: super.prefixed(e, t)
|
|
);
|
|
}
|
|
normalize() {
|
|
return "justify-content";
|
|
}
|
|
set(e, t) {
|
|
let r = iw(t)[0];
|
|
if (r === 2009 || r === 2012) {
|
|
let n = tr.oldValues[e.value] || e.value;
|
|
if (((e.value = n), r !== 2009 || n !== "distribute"))
|
|
return super.set(e, t);
|
|
} else if (r === "final") return super.set(e, t);
|
|
}
|
|
};
|
|
tr.names = ["justify-content", "flex-pack", "box-pack"];
|
|
tr.oldValues = {
|
|
"flex-end": "end",
|
|
"flex-start": "start",
|
|
"space-between": "justify",
|
|
"space-around": "distribute",
|
|
};
|
|
nw.exports = tr;
|
|
});
|
|
var ow = v((M4, aw) => {
|
|
l();
|
|
var $_ = R(),
|
|
Bl = class extends $_ {
|
|
set(e, t) {
|
|
let r = e.value.toLowerCase();
|
|
return (
|
|
t === "-webkit-" &&
|
|
!r.includes(" ") &&
|
|
r !== "contain" &&
|
|
r !== "cover" &&
|
|
(e.value = e.value + " " + e.value),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
};
|
|
Bl.names = ["background-size"];
|
|
aw.exports = Bl;
|
|
});
|
|
var uw = v((B4, lw) => {
|
|
l();
|
|
var j_ = R(),
|
|
Fl = ht(),
|
|
Nl = class extends j_ {
|
|
insert(e, t, r) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
let n = Fl.parse(e),
|
|
[a, s] = Fl.translate(n, 0, 1);
|
|
n[0] &&
|
|
n[0].includes("span") &&
|
|
(s = n[0].join("").replace(/\D/g, "")),
|
|
[
|
|
[e.prop, a],
|
|
[`${e.prop}-span`, s],
|
|
].forEach(([u, c]) => {
|
|
Fl.insertDecl(e, u, c);
|
|
});
|
|
}
|
|
};
|
|
Nl.names = ["grid-row", "grid-column"];
|
|
lw.exports = Nl;
|
|
});
|
|
var pw = v((F4, cw) => {
|
|
l();
|
|
var z_ = R(),
|
|
{
|
|
prefixTrackProp: fw,
|
|
prefixTrackValue: V_,
|
|
autoplaceGridItems: U_,
|
|
getGridGap: W_,
|
|
inheritGridGap: G_,
|
|
} = ht(),
|
|
H_ = il(),
|
|
Ll = class extends z_ {
|
|
prefixed(e, t) {
|
|
return t === "-ms-"
|
|
? fw({ prop: e, prefix: t })
|
|
: super.prefixed(e, t);
|
|
}
|
|
normalize(e) {
|
|
return e.replace(/^grid-(rows|columns)/, "grid-template-$1");
|
|
}
|
|
insert(e, t, r, n) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
let { parent: a, prop: s, value: o } = e,
|
|
u = s.includes("rows"),
|
|
c = s.includes("columns"),
|
|
f = a.some(
|
|
(k) =>
|
|
k.prop === "grid-template" || k.prop === "grid-template-areas",
|
|
);
|
|
if (f && u) return !1;
|
|
let d = new H_({ options: {} }),
|
|
p = d.gridStatus(a, n),
|
|
m = W_(e);
|
|
m = G_(e, m) || m;
|
|
let w = u ? m.row : m.column;
|
|
(p === "no-autoplace" || p === !0) && !f && (w = null);
|
|
let x = V_({ value: o, gap: w });
|
|
e.cloneBefore({ prop: fw({ prop: s, prefix: t }), value: x });
|
|
let y = a.nodes.find((k) => k.prop === "grid-auto-flow"),
|
|
b = "row";
|
|
if (
|
|
(y && !d.disabled(y, n) && (b = y.value.trim()), p === "autoplace")
|
|
) {
|
|
let k = a.nodes.find((_) => _.prop === "grid-template-rows");
|
|
if (!k && f) return;
|
|
if (!k && !f) {
|
|
e.warn(
|
|
n,
|
|
"Autoplacement does not work without grid-template-rows property",
|
|
);
|
|
return;
|
|
}
|
|
!a.nodes.find((_) => _.prop === "grid-template-columns") &&
|
|
!f &&
|
|
e.warn(
|
|
n,
|
|
"Autoplacement does not work without grid-template-columns property",
|
|
),
|
|
c && !f && U_(e, n, m, b);
|
|
}
|
|
}
|
|
};
|
|
Ll.names = [
|
|
"grid-template-rows",
|
|
"grid-template-columns",
|
|
"grid-rows",
|
|
"grid-columns",
|
|
];
|
|
cw.exports = Ll;
|
|
});
|
|
var hw = v((N4, dw) => {
|
|
l();
|
|
var Y_ = R(),
|
|
$l = class extends Y_ {
|
|
check(e) {
|
|
return !e.value.includes("flex-") && e.value !== "baseline";
|
|
}
|
|
prefixed(e, t) {
|
|
return t + "grid-column-align";
|
|
}
|
|
normalize() {
|
|
return "justify-self";
|
|
}
|
|
};
|
|
$l.names = ["grid-column-align"];
|
|
dw.exports = $l;
|
|
});
|
|
var gw = v((L4, mw) => {
|
|
l();
|
|
var Q_ = R(),
|
|
jl = class extends Q_ {
|
|
prefixed(e, t) {
|
|
return t + "scroll-chaining";
|
|
}
|
|
normalize() {
|
|
return "overscroll-behavior";
|
|
}
|
|
set(e, t) {
|
|
return (
|
|
e.value === "auto"
|
|
? (e.value = "chained")
|
|
: (e.value === "none" || e.value === "contain") &&
|
|
(e.value = "none"),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
};
|
|
jl.names = ["overscroll-behavior", "scroll-chaining"];
|
|
mw.exports = jl;
|
|
});
|
|
var bw = v(($4, ww) => {
|
|
l();
|
|
var J_ = R(),
|
|
{
|
|
parseGridAreas: X_,
|
|
warnMissedAreas: K_,
|
|
prefixTrackProp: Z_,
|
|
prefixTrackValue: yw,
|
|
getGridGap: e5,
|
|
warnGridGap: t5,
|
|
inheritGridGap: r5,
|
|
} = ht();
|
|
function i5(i) {
|
|
return i
|
|
.trim()
|
|
.slice(1, -1)
|
|
.split(/["']\s*["']?/g);
|
|
}
|
|
var zl = class extends J_ {
|
|
insert(e, t, r, n) {
|
|
if (t !== "-ms-") return super.insert(e, t, r);
|
|
let a = !1,
|
|
s = !1,
|
|
o = e.parent,
|
|
u = e5(e);
|
|
(u = r5(e, u) || u),
|
|
o.walkDecls(/-ms-grid-rows/, (d) => d.remove()),
|
|
o.walkDecls(/grid-template-(rows|columns)/, (d) => {
|
|
if (d.prop === "grid-template-rows") {
|
|
s = !0;
|
|
let { prop: p, value: m } = d;
|
|
d.cloneBefore({
|
|
prop: Z_({ prop: p, prefix: t }),
|
|
value: yw({ value: m, gap: u.row }),
|
|
});
|
|
} else a = !0;
|
|
});
|
|
let c = i5(e.value);
|
|
a &&
|
|
!s &&
|
|
u.row &&
|
|
c.length > 1 &&
|
|
e.cloneBefore({
|
|
prop: "-ms-grid-rows",
|
|
value: yw({ value: `repeat(${c.length}, auto)`, gap: u.row }),
|
|
raws: {},
|
|
}),
|
|
t5({ gap: u, hasColumns: a, decl: e, result: n });
|
|
let f = X_({ rows: c, gap: u });
|
|
return K_(f, e, n), e;
|
|
}
|
|
};
|
|
zl.names = ["grid-template-areas"];
|
|
ww.exports = zl;
|
|
});
|
|
var xw = v((j4, vw) => {
|
|
l();
|
|
var n5 = R(),
|
|
Vl = class extends n5 {
|
|
set(e, t) {
|
|
return (
|
|
t === "-webkit-" &&
|
|
(e.value = e.value.replace(/\s*(right|left)\s*/i, "")),
|
|
super.set(e, t)
|
|
);
|
|
}
|
|
};
|
|
Vl.names = ["text-emphasis-position"];
|
|
vw.exports = Vl;
|
|
});
|
|
var Sw = v((z4, kw) => {
|
|
l();
|
|
var s5 = R(),
|
|
Ul = class extends s5 {
|
|
set(e, t) {
|
|
return e.prop === "text-decoration-skip-ink" && e.value === "auto"
|
|
? ((e.prop = t + "text-decoration-skip"), (e.value = "ink"), e)
|
|
: super.set(e, t);
|
|
}
|
|
};
|
|
Ul.names = ["text-decoration-skip-ink", "text-decoration-skip"];
|
|
kw.exports = Ul;
|
|
});
|
|
var Tw = v((V4, Ew) => {
|
|
l();
|
|
("use strict");
|
|
Ew.exports = {
|
|
wrap: Cw,
|
|
limit: Aw,
|
|
validate: _w,
|
|
test: Wl,
|
|
curry: a5,
|
|
name: Ow,
|
|
};
|
|
function Cw(i, e, t) {
|
|
var r = e - i;
|
|
return ((((t - i) % r) + r) % r) + i;
|
|
}
|
|
function Aw(i, e, t) {
|
|
return Math.max(i, Math.min(e, t));
|
|
}
|
|
function _w(i, e, t, r, n) {
|
|
if (!Wl(i, e, t, r, n))
|
|
throw new Error(t + " is outside of range [" + i + "," + e + ")");
|
|
return t;
|
|
}
|
|
function Wl(i, e, t, r, n) {
|
|
return !(t < i || t > e || (n && t === e) || (r && t === i));
|
|
}
|
|
function Ow(i, e, t, r) {
|
|
return (t ? "(" : "[") + i + "," + e + (r ? ")" : "]");
|
|
}
|
|
function a5(i, e, t, r) {
|
|
var n = Ow.bind(null, i, e, t, r);
|
|
return {
|
|
wrap: Cw.bind(null, i, e),
|
|
limit: Aw.bind(null, i, e),
|
|
validate: function (a) {
|
|
return _w(i, e, a, t, r);
|
|
},
|
|
test: function (a) {
|
|
return Wl(i, e, a, t, r);
|
|
},
|
|
toString: n,
|
|
name: n,
|
|
};
|
|
}
|
|
});
|
|
var Iw = v((U4, Dw) => {
|
|
l();
|
|
var Gl = Gn(),
|
|
o5 = Tw(),
|
|
l5 = Gt(),
|
|
u5 = ke(),
|
|
f5 = fe(),
|
|
Pw = /top|left|right|bottom/gi,
|
|
Qe = class extends u5 {
|
|
replace(e, t) {
|
|
let r = Gl(e);
|
|
for (let n of r.nodes)
|
|
if (n.type === "function" && n.value === this.name)
|
|
if (
|
|
((n.nodes = this.newDirection(n.nodes)),
|
|
(n.nodes = this.normalize(n.nodes)),
|
|
t === "-webkit- old")
|
|
) {
|
|
if (!this.oldWebkit(n)) return !1;
|
|
} else
|
|
(n.nodes = this.convertDirection(n.nodes)),
|
|
(n.value = t + n.value);
|
|
return r.toString();
|
|
}
|
|
replaceFirst(e, ...t) {
|
|
return t
|
|
.map((n) =>
|
|
n === " "
|
|
? { type: "space", value: n }
|
|
: { type: "word", value: n },
|
|
)
|
|
.concat(e.slice(1));
|
|
}
|
|
normalizeUnit(e, t) {
|
|
return `${(parseFloat(e) / t) * 360}deg`;
|
|
}
|
|
normalize(e) {
|
|
if (!e[0]) return e;
|
|
if (/-?\d+(.\d+)?grad/.test(e[0].value))
|
|
e[0].value = this.normalizeUnit(e[0].value, 400);
|
|
else if (/-?\d+(.\d+)?rad/.test(e[0].value))
|
|
e[0].value = this.normalizeUnit(e[0].value, 2 * Math.PI);
|
|
else if (/-?\d+(.\d+)?turn/.test(e[0].value))
|
|
e[0].value = this.normalizeUnit(e[0].value, 1);
|
|
else if (e[0].value.includes("deg")) {
|
|
let t = parseFloat(e[0].value);
|
|
(t = o5.wrap(0, 360, t)), (e[0].value = `${t}deg`);
|
|
}
|
|
return (
|
|
e[0].value === "0deg"
|
|
? (e = this.replaceFirst(e, "to", " ", "top"))
|
|
: e[0].value === "90deg"
|
|
? (e = this.replaceFirst(e, "to", " ", "right"))
|
|
: e[0].value === "180deg"
|
|
? (e = this.replaceFirst(e, "to", " ", "bottom"))
|
|
: e[0].value === "270deg" &&
|
|
(e = this.replaceFirst(e, "to", " ", "left")),
|
|
e
|
|
);
|
|
}
|
|
newDirection(e) {
|
|
if (e[0].value === "to" || ((Pw.lastIndex = 0), !Pw.test(e[0].value)))
|
|
return e;
|
|
e.unshift(
|
|
{ type: "word", value: "to" },
|
|
{ type: "space", value: " " },
|
|
);
|
|
for (let t = 2; t < e.length && e[t].type !== "div"; t++)
|
|
e[t].type === "word" &&
|
|
(e[t].value = this.revertDirection(e[t].value));
|
|
return e;
|
|
}
|
|
isRadial(e) {
|
|
let t = "before";
|
|
for (let r of e)
|
|
if (t === "before" && r.type === "space") t = "at";
|
|
else if (t === "at" && r.value === "at") t = "after";
|
|
else {
|
|
if (t === "after" && r.type === "space") return !0;
|
|
if (r.type === "div") break;
|
|
t = "before";
|
|
}
|
|
return !1;
|
|
}
|
|
convertDirection(e) {
|
|
return (
|
|
e.length > 0 &&
|
|
(e[0].value === "to"
|
|
? this.fixDirection(e)
|
|
: e[0].value.includes("deg")
|
|
? this.fixAngle(e)
|
|
: this.isRadial(e) && this.fixRadial(e)),
|
|
e
|
|
);
|
|
}
|
|
fixDirection(e) {
|
|
e.splice(0, 2);
|
|
for (let t of e) {
|
|
if (t.type === "div") break;
|
|
t.type === "word" && (t.value = this.revertDirection(t.value));
|
|
}
|
|
}
|
|
fixAngle(e) {
|
|
let t = e[0].value;
|
|
(t = parseFloat(t)),
|
|
(t = Math.abs(450 - t) % 360),
|
|
(t = this.roundFloat(t, 3)),
|
|
(e[0].value = `${t}deg`);
|
|
}
|
|
fixRadial(e) {
|
|
let t = [],
|
|
r = [],
|
|
n,
|
|
a,
|
|
s,
|
|
o,
|
|
u;
|
|
for (o = 0; o < e.length - 2; o++)
|
|
if (
|
|
((n = e[o]),
|
|
(a = e[o + 1]),
|
|
(s = e[o + 2]),
|
|
n.type === "space" && a.value === "at" && s.type === "space")
|
|
) {
|
|
u = o + 3;
|
|
break;
|
|
} else t.push(n);
|
|
let c;
|
|
for (o = u; o < e.length; o++)
|
|
if (e[o].type === "div") {
|
|
c = e[o];
|
|
break;
|
|
} else r.push(e[o]);
|
|
e.splice(0, o, ...r, c, ...t);
|
|
}
|
|
revertDirection(e) {
|
|
return Qe.directions[e.toLowerCase()] || e;
|
|
}
|
|
roundFloat(e, t) {
|
|
return parseFloat(e.toFixed(t));
|
|
}
|
|
oldWebkit(e) {
|
|
let { nodes: t } = e,
|
|
r = Gl.stringify(e.nodes);
|
|
if (
|
|
this.name !== "linear-gradient" ||
|
|
(t[0] && t[0].value.includes("deg")) ||
|
|
r.includes("px") ||
|
|
r.includes("-corner") ||
|
|
r.includes("-side")
|
|
)
|
|
return !1;
|
|
let n = [[]];
|
|
for (let a of t)
|
|
n[n.length - 1].push(a),
|
|
a.type === "div" && a.value === "," && n.push([]);
|
|
this.oldDirection(n), this.colorStops(n), (e.nodes = []);
|
|
for (let a of n) e.nodes = e.nodes.concat(a);
|
|
return (
|
|
e.nodes.unshift(
|
|
{ type: "word", value: "linear" },
|
|
this.cloneDiv(e.nodes),
|
|
),
|
|
(e.value = "-webkit-gradient"),
|
|
!0
|
|
);
|
|
}
|
|
oldDirection(e) {
|
|
let t = this.cloneDiv(e[0]);
|
|
if (e[0][0].value !== "to")
|
|
return e.unshift([
|
|
{ type: "word", value: Qe.oldDirections.bottom },
|
|
t,
|
|
]);
|
|
{
|
|
let r = [];
|
|
for (let a of e[0].slice(2))
|
|
a.type === "word" && r.push(a.value.toLowerCase());
|
|
r = r.join(" ");
|
|
let n = Qe.oldDirections[r] || r;
|
|
return (e[0] = [{ type: "word", value: n }, t]), e[0];
|
|
}
|
|
}
|
|
cloneDiv(e) {
|
|
for (let t of e) if (t.type === "div" && t.value === ",") return t;
|
|
return { type: "div", value: ",", after: " " };
|
|
}
|
|
colorStops(e) {
|
|
let t = [];
|
|
for (let r = 0; r < e.length; r++) {
|
|
let n,
|
|
a = e[r],
|
|
s;
|
|
if (r === 0) continue;
|
|
let o = Gl.stringify(a[0]);
|
|
a[1] && a[1].type === "word"
|
|
? (n = a[1].value)
|
|
: a[2] && a[2].type === "word" && (n = a[2].value);
|
|
let u;
|
|
r === 1 && (!n || n === "0%")
|
|
? (u = `from(${o})`)
|
|
: r === e.length - 1 && (!n || n === "100%")
|
|
? (u = `to(${o})`)
|
|
: n
|
|
? (u = `color-stop(${n}, ${o})`)
|
|
: (u = `color-stop(${o})`);
|
|
let c = a[a.length - 1];
|
|
(e[r] = [{ type: "word", value: u }]),
|
|
c.type === "div" && c.value === "," && (s = e[r].push(c)),
|
|
t.push(s);
|
|
}
|
|
return t;
|
|
}
|
|
old(e) {
|
|
if (e === "-webkit-") {
|
|
let t = this.name === "linear-gradient" ? "linear" : "radial",
|
|
r = "-gradient",
|
|
n = f5.regexp(`-webkit-(${t}-gradient|gradient\\(\\s*${t})`, !1);
|
|
return new l5(this.name, e + this.name, r, n);
|
|
} else return super.old(e);
|
|
}
|
|
add(e, t) {
|
|
let r = e.prop;
|
|
if (r.includes("mask")) {
|
|
if (t === "-webkit-" || t === "-webkit- old")
|
|
return super.add(e, t);
|
|
} else if (
|
|
r === "list-style" ||
|
|
r === "list-style-image" ||
|
|
r === "content"
|
|
) {
|
|
if (t === "-webkit-" || t === "-webkit- old")
|
|
return super.add(e, t);
|
|
} else return super.add(e, t);
|
|
}
|
|
};
|
|
Qe.names = [
|
|
"linear-gradient",
|
|
"repeating-linear-gradient",
|
|
"radial-gradient",
|
|
"repeating-radial-gradient",
|
|
];
|
|
Qe.directions = {
|
|
top: "bottom",
|
|
left: "right",
|
|
bottom: "top",
|
|
right: "left",
|
|
};
|
|
Qe.oldDirections = {
|
|
top: "left bottom, left top",
|
|
left: "right top, left top",
|
|
bottom: "left top, left bottom",
|
|
right: "left top, right top",
|
|
"top right": "left bottom, right top",
|
|
"top left": "right bottom, left top",
|
|
"right top": "left bottom, right top",
|
|
"right bottom": "left top, right bottom",
|
|
"bottom right": "left top, right bottom",
|
|
"bottom left": "right top, left bottom",
|
|
"left top": "right bottom, left top",
|
|
"left bottom": "right top, left bottom",
|
|
};
|
|
Dw.exports = Qe;
|
|
});
|
|
var Mw = v((W4, Rw) => {
|
|
l();
|
|
var c5 = Gt(),
|
|
p5 = ke();
|
|
function qw(i) {
|
|
return new RegExp(`(^|[\\s,(])(${i}($|[\\s),]))`, "gi");
|
|
}
|
|
var Hl = class extends p5 {
|
|
regexp() {
|
|
return (
|
|
this.regexpCache || (this.regexpCache = qw(this.name)),
|
|
this.regexpCache
|
|
);
|
|
}
|
|
isStretch() {
|
|
return (
|
|
this.name === "stretch" ||
|
|
this.name === "fill" ||
|
|
this.name === "fill-available"
|
|
);
|
|
}
|
|
replace(e, t) {
|
|
return t === "-moz-" && this.isStretch()
|
|
? e.replace(this.regexp(), "$1-moz-available$3")
|
|
: t === "-webkit-" && this.isStretch()
|
|
? e.replace(this.regexp(), "$1-webkit-fill-available$3")
|
|
: super.replace(e, t);
|
|
}
|
|
old(e) {
|
|
let t = e + this.name;
|
|
return (
|
|
this.isStretch() &&
|
|
(e === "-moz-"
|
|
? (t = "-moz-available")
|
|
: e === "-webkit-" && (t = "-webkit-fill-available")),
|
|
new c5(this.name, t, t, qw(t))
|
|
);
|
|
}
|
|
add(e, t) {
|
|
if (!(e.prop.includes("grid") && t !== "-webkit-"))
|
|
return super.add(e, t);
|
|
}
|
|
};
|
|
Hl.names = [
|
|
"max-content",
|
|
"min-content",
|
|
"fit-content",
|
|
"fill",
|
|
"fill-available",
|
|
"stretch",
|
|
];
|
|
Rw.exports = Hl;
|
|
});
|
|
var Nw = v((G4, Fw) => {
|
|
l();
|
|
var Bw = Gt(),
|
|
d5 = ke(),
|
|
Yl = class extends d5 {
|
|
replace(e, t) {
|
|
return t === "-webkit-"
|
|
? e.replace(this.regexp(), "$1-webkit-optimize-contrast")
|
|
: t === "-moz-"
|
|
? e.replace(this.regexp(), "$1-moz-crisp-edges")
|
|
: super.replace(e, t);
|
|
}
|
|
old(e) {
|
|
return e === "-webkit-"
|
|
? new Bw(this.name, "-webkit-optimize-contrast")
|
|
: e === "-moz-"
|
|
? new Bw(this.name, "-moz-crisp-edges")
|
|
: super.old(e);
|
|
}
|
|
};
|
|
Yl.names = ["pixelated"];
|
|
Fw.exports = Yl;
|
|
});
|
|
var $w = v((H4, Lw) => {
|
|
l();
|
|
var h5 = ke(),
|
|
Ql = class extends h5 {
|
|
replace(e, t) {
|
|
let r = super.replace(e, t);
|
|
return (
|
|
t === "-webkit-" &&
|
|
(r = r.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, "url($1)$2")),
|
|
r
|
|
);
|
|
}
|
|
};
|
|
Ql.names = ["image-set"];
|
|
Lw.exports = Ql;
|
|
});
|
|
var zw = v((Y4, jw) => {
|
|
l();
|
|
var m5 = ge().list,
|
|
g5 = ke(),
|
|
Jl = class extends g5 {
|
|
replace(e, t) {
|
|
return m5
|
|
.space(e)
|
|
.map((r) => {
|
|
if (r.slice(0, +this.name.length + 1) !== this.name + "(")
|
|
return r;
|
|
let n = r.lastIndexOf(")"),
|
|
a = r.slice(n + 1),
|
|
s = r.slice(this.name.length + 1, n);
|
|
if (t === "-webkit-") {
|
|
let o = s.match(/\d*.?\d+%?/);
|
|
o
|
|
? ((s = s.slice(o[0].length).trim()), (s += `, ${o[0]}`))
|
|
: (s += ", 0.5");
|
|
}
|
|
return t + this.name + "(" + s + ")" + a;
|
|
})
|
|
.join(" ");
|
|
}
|
|
};
|
|
Jl.names = ["cross-fade"];
|
|
jw.exports = Jl;
|
|
});
|
|
var Uw = v((Q4, Vw) => {
|
|
l();
|
|
var y5 = he(),
|
|
w5 = Gt(),
|
|
b5 = ke(),
|
|
Xl = class extends b5 {
|
|
constructor(e, t) {
|
|
super(e, t);
|
|
e === "display-flex" && (this.name = "flex");
|
|
}
|
|
check(e) {
|
|
return e.prop === "display" && e.value === this.name;
|
|
}
|
|
prefixed(e) {
|
|
let t, r;
|
|
return (
|
|
([t, e] = y5(e)),
|
|
t === 2009
|
|
? this.name === "flex"
|
|
? (r = "box")
|
|
: (r = "inline-box")
|
|
: t === 2012
|
|
? this.name === "flex"
|
|
? (r = "flexbox")
|
|
: (r = "inline-flexbox")
|
|
: t === "final" && (r = this.name),
|
|
e + r
|
|
);
|
|
}
|
|
replace(e, t) {
|
|
return this.prefixed(t);
|
|
}
|
|
old(e) {
|
|
let t = this.prefixed(e);
|
|
if (!!t) return new w5(this.name, t);
|
|
}
|
|
};
|
|
Xl.names = ["display-flex", "inline-flex"];
|
|
Vw.exports = Xl;
|
|
});
|
|
var Gw = v((J4, Ww) => {
|
|
l();
|
|
var v5 = ke(),
|
|
Kl = class extends v5 {
|
|
constructor(e, t) {
|
|
super(e, t);
|
|
e === "display-grid" && (this.name = "grid");
|
|
}
|
|
check(e) {
|
|
return e.prop === "display" && e.value === this.name;
|
|
}
|
|
};
|
|
Kl.names = ["display-grid", "inline-grid"];
|
|
Ww.exports = Kl;
|
|
});
|
|
var Yw = v((X4, Hw) => {
|
|
l();
|
|
var x5 = ke(),
|
|
Zl = class extends x5 {
|
|
constructor(e, t) {
|
|
super(e, t);
|
|
e === "filter-function" && (this.name = "filter");
|
|
}
|
|
};
|
|
Zl.names = ["filter", "filter-function"];
|
|
Hw.exports = Zl;
|
|
});
|
|
var Kw = v((K4, Xw) => {
|
|
l();
|
|
var Qw = ii(),
|
|
M = R(),
|
|
Jw = Dm(),
|
|
k5 = Qm(),
|
|
S5 = il(),
|
|
C5 = hg(),
|
|
eu = pt(),
|
|
rr = Ht(),
|
|
A5 = kg(),
|
|
Le = ke(),
|
|
ir = fe(),
|
|
_5 = Cg(),
|
|
O5 = _g(),
|
|
E5 = Eg(),
|
|
T5 = Pg(),
|
|
P5 = Mg(),
|
|
D5 = Ng(),
|
|
I5 = $g(),
|
|
q5 = zg(),
|
|
R5 = Ug(),
|
|
M5 = Gg(),
|
|
B5 = Yg(),
|
|
F5 = Jg(),
|
|
N5 = Kg(),
|
|
L5 = ey(),
|
|
$5 = ry(),
|
|
j5 = sy(),
|
|
z5 = oy(),
|
|
V5 = fy(),
|
|
U5 = py(),
|
|
W5 = hy(),
|
|
G5 = yy(),
|
|
H5 = by(),
|
|
Y5 = ky(),
|
|
Q5 = Cy(),
|
|
J5 = _y(),
|
|
X5 = Ey(),
|
|
K5 = Py(),
|
|
Z5 = qy(),
|
|
eO = My(),
|
|
tO = Fy(),
|
|
rO = Ly(),
|
|
iO = jy(),
|
|
nO = Vy(),
|
|
sO = Wy(),
|
|
aO = Yy(),
|
|
oO = Jy(),
|
|
lO = Ky(),
|
|
uO = ew(),
|
|
fO = rw(),
|
|
cO = sw(),
|
|
pO = ow(),
|
|
dO = uw(),
|
|
hO = pw(),
|
|
mO = hw(),
|
|
gO = gw(),
|
|
yO = bw(),
|
|
wO = xw(),
|
|
bO = Sw(),
|
|
vO = Iw(),
|
|
xO = Mw(),
|
|
kO = Nw(),
|
|
SO = $w(),
|
|
CO = zw(),
|
|
AO = Uw(),
|
|
_O = Gw(),
|
|
OO = Yw();
|
|
rr.hack(_5);
|
|
rr.hack(O5);
|
|
rr.hack(E5);
|
|
rr.hack(T5);
|
|
M.hack(P5);
|
|
M.hack(D5);
|
|
M.hack(I5);
|
|
M.hack(q5);
|
|
M.hack(R5);
|
|
M.hack(M5);
|
|
M.hack(B5);
|
|
M.hack(F5);
|
|
M.hack(N5);
|
|
M.hack(L5);
|
|
M.hack($5);
|
|
M.hack(j5);
|
|
M.hack(z5);
|
|
M.hack(V5);
|
|
M.hack(U5);
|
|
M.hack(W5);
|
|
M.hack(G5);
|
|
M.hack(H5);
|
|
M.hack(Y5);
|
|
M.hack(Q5);
|
|
M.hack(J5);
|
|
M.hack(X5);
|
|
M.hack(K5);
|
|
M.hack(Z5);
|
|
M.hack(eO);
|
|
M.hack(tO);
|
|
M.hack(rO);
|
|
M.hack(iO);
|
|
M.hack(nO);
|
|
M.hack(sO);
|
|
M.hack(aO);
|
|
M.hack(oO);
|
|
M.hack(lO);
|
|
M.hack(uO);
|
|
M.hack(fO);
|
|
M.hack(cO);
|
|
M.hack(pO);
|
|
M.hack(dO);
|
|
M.hack(hO);
|
|
M.hack(mO);
|
|
M.hack(gO);
|
|
M.hack(yO);
|
|
M.hack(wO);
|
|
M.hack(bO);
|
|
Le.hack(vO);
|
|
Le.hack(xO);
|
|
Le.hack(kO);
|
|
Le.hack(SO);
|
|
Le.hack(CO);
|
|
Le.hack(AO);
|
|
Le.hack(_O);
|
|
Le.hack(OO);
|
|
var tu = new Map(),
|
|
si = class {
|
|
constructor(e, t, r = {}) {
|
|
(this.data = e),
|
|
(this.browsers = t),
|
|
(this.options = r),
|
|
([this.add, this.remove] = this.preprocess(this.select(this.data))),
|
|
(this.transition = new k5(this)),
|
|
(this.processor = new S5(this));
|
|
}
|
|
cleaner() {
|
|
if (this.cleanerCache) return this.cleanerCache;
|
|
if (this.browsers.selected.length) {
|
|
let e = new eu(this.browsers.data, []);
|
|
this.cleanerCache = new si(this.data, e, this.options);
|
|
} else return this;
|
|
return this.cleanerCache;
|
|
}
|
|
select(e) {
|
|
let t = { add: {}, remove: {} };
|
|
for (let r in e) {
|
|
let n = e[r],
|
|
a = n.browsers.map((u) => {
|
|
let c = u.split(" ");
|
|
return { browser: `${c[0]} ${c[1]}`, note: c[2] };
|
|
}),
|
|
s = a
|
|
.filter((u) => u.note)
|
|
.map((u) => `${this.browsers.prefix(u.browser)} ${u.note}`);
|
|
(s = ir.uniq(s)),
|
|
(a = a
|
|
.filter((u) => this.browsers.isSelected(u.browser))
|
|
.map((u) => {
|
|
let c = this.browsers.prefix(u.browser);
|
|
return u.note ? `${c} ${u.note}` : c;
|
|
})),
|
|
(a = this.sort(ir.uniq(a))),
|
|
this.options.flexbox === "no-2009" &&
|
|
(a = a.filter((u) => !u.includes("2009")));
|
|
let o = n.browsers.map((u) => this.browsers.prefix(u));
|
|
n.mistakes && (o = o.concat(n.mistakes)),
|
|
(o = o.concat(s)),
|
|
(o = ir.uniq(o)),
|
|
a.length
|
|
? ((t.add[r] = a),
|
|
a.length < o.length &&
|
|
(t.remove[r] = o.filter((u) => !a.includes(u))))
|
|
: (t.remove[r] = o);
|
|
}
|
|
return t;
|
|
}
|
|
sort(e) {
|
|
return e.sort((t, r) => {
|
|
let n = ir.removeNote(t).length,
|
|
a = ir.removeNote(r).length;
|
|
return n === a ? r.length - t.length : a - n;
|
|
});
|
|
}
|
|
preprocess(e) {
|
|
let t = { selectors: [], "@supports": new C5(si, this) };
|
|
for (let n in e.add) {
|
|
let a = e.add[n];
|
|
if (n === "@keyframes" || n === "@viewport")
|
|
t[n] = new A5(n, a, this);
|
|
else if (n === "@resolution") t[n] = new Jw(n, a, this);
|
|
else if (this.data[n].selector)
|
|
t.selectors.push(rr.load(n, a, this));
|
|
else {
|
|
let s = this.data[n].props;
|
|
if (s) {
|
|
let o = Le.load(n, a, this);
|
|
for (let u of s)
|
|
t[u] || (t[u] = { values: [] }), t[u].values.push(o);
|
|
} else {
|
|
let o = (t[n] && t[n].values) || [];
|
|
(t[n] = M.load(n, a, this)), (t[n].values = o);
|
|
}
|
|
}
|
|
}
|
|
let r = { selectors: [] };
|
|
for (let n in e.remove) {
|
|
let a = e.remove[n];
|
|
if (this.data[n].selector) {
|
|
let s = rr.load(n, a);
|
|
for (let o of a) r.selectors.push(s.old(o));
|
|
} else if (n === "@keyframes" || n === "@viewport")
|
|
for (let s of a) {
|
|
let o = `@${s}${n.slice(1)}`;
|
|
r[o] = { remove: !0 };
|
|
}
|
|
else if (n === "@resolution") r[n] = new Jw(n, a, this);
|
|
else {
|
|
let s = this.data[n].props;
|
|
if (s) {
|
|
let o = Le.load(n, [], this);
|
|
for (let u of a) {
|
|
let c = o.old(u);
|
|
if (c)
|
|
for (let f of s)
|
|
r[f] || (r[f] = {}),
|
|
r[f].values || (r[f].values = []),
|
|
r[f].values.push(c);
|
|
}
|
|
} else
|
|
for (let o of a) {
|
|
let u = this.decl(n).old(n, o);
|
|
if (n === "align-self") {
|
|
let c = t[n] && t[n].prefixes;
|
|
if (c) {
|
|
if (o === "-webkit- 2009" && c.includes("-webkit-"))
|
|
continue;
|
|
if (o === "-webkit-" && c.includes("-webkit- 2009"))
|
|
continue;
|
|
}
|
|
}
|
|
for (let c of u) r[c] || (r[c] = {}), (r[c].remove = !0);
|
|
}
|
|
}
|
|
}
|
|
return [t, r];
|
|
}
|
|
decl(e) {
|
|
return tu.has(e) || tu.set(e, M.load(e)), tu.get(e);
|
|
}
|
|
unprefixed(e) {
|
|
let t = this.normalize(Qw.unprefixed(e));
|
|
return t === "flex-direction" && (t = "flex-flow"), t;
|
|
}
|
|
normalize(e) {
|
|
return this.decl(e).normalize(e);
|
|
}
|
|
prefixed(e, t) {
|
|
return (e = Qw.unprefixed(e)), this.decl(e).prefixed(e, t);
|
|
}
|
|
values(e, t) {
|
|
let r = this[e],
|
|
n = r["*"] && r["*"].values,
|
|
a = r[t] && r[t].values;
|
|
return n && a ? ir.uniq(n.concat(a)) : n || a || [];
|
|
}
|
|
group(e) {
|
|
let t = e.parent,
|
|
r = t.index(e),
|
|
{ length: n } = t.nodes,
|
|
a = this.unprefixed(e.prop),
|
|
s = (o, u) => {
|
|
for (r += o; r >= 0 && r < n; ) {
|
|
let c = t.nodes[r];
|
|
if (c.type === "decl") {
|
|
if (
|
|
(o === -1 && c.prop === a && !eu.withPrefix(c.value)) ||
|
|
this.unprefixed(c.prop) !== a
|
|
)
|
|
break;
|
|
if (u(c) === !0) return !0;
|
|
if (o === 1 && c.prop === a && !eu.withPrefix(c.value)) break;
|
|
}
|
|
r += o;
|
|
}
|
|
return !1;
|
|
};
|
|
return {
|
|
up(o) {
|
|
return s(-1, o);
|
|
},
|
|
down(o) {
|
|
return s(1, o);
|
|
},
|
|
};
|
|
}
|
|
};
|
|
Xw.exports = si;
|
|
});
|
|
var eb = v((Z4, Zw) => {
|
|
l();
|
|
Zw.exports = {
|
|
"backdrop-filter": {
|
|
feature: "css-backdrop-filter",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
"safari 16.5",
|
|
],
|
|
},
|
|
element: {
|
|
props: [
|
|
"background",
|
|
"background-image",
|
|
"border-image",
|
|
"mask",
|
|
"list-style",
|
|
"list-style-image",
|
|
"content",
|
|
"mask-image",
|
|
],
|
|
feature: "css-element-function",
|
|
browsers: ["firefox 114"],
|
|
},
|
|
"user-select": {
|
|
mistakes: ["-khtml-"],
|
|
feature: "user-select-none",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
"safari 16.5",
|
|
],
|
|
},
|
|
"background-clip": {
|
|
feature: "background-clip-text",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
hyphens: {
|
|
feature: "css-hyphens",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
"safari 16.5",
|
|
],
|
|
},
|
|
fill: {
|
|
props: [
|
|
"width",
|
|
"min-width",
|
|
"max-width",
|
|
"height",
|
|
"min-height",
|
|
"max-height",
|
|
"inline-size",
|
|
"min-inline-size",
|
|
"max-inline-size",
|
|
"block-size",
|
|
"min-block-size",
|
|
"max-block-size",
|
|
"grid",
|
|
"grid-template",
|
|
"grid-template-rows",
|
|
"grid-template-columns",
|
|
"grid-auto-columns",
|
|
"grid-auto-rows",
|
|
],
|
|
feature: "intrinsic-width",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"fill-available": {
|
|
props: [
|
|
"width",
|
|
"min-width",
|
|
"max-width",
|
|
"height",
|
|
"min-height",
|
|
"max-height",
|
|
"inline-size",
|
|
"min-inline-size",
|
|
"max-inline-size",
|
|
"block-size",
|
|
"min-block-size",
|
|
"max-block-size",
|
|
"grid",
|
|
"grid-template",
|
|
"grid-template-rows",
|
|
"grid-template-columns",
|
|
"grid-auto-columns",
|
|
"grid-auto-rows",
|
|
],
|
|
feature: "intrinsic-width",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
stretch: {
|
|
props: [
|
|
"width",
|
|
"min-width",
|
|
"max-width",
|
|
"height",
|
|
"min-height",
|
|
"max-height",
|
|
"inline-size",
|
|
"min-inline-size",
|
|
"max-inline-size",
|
|
"block-size",
|
|
"min-block-size",
|
|
"max-block-size",
|
|
"grid",
|
|
"grid-template",
|
|
"grid-template-rows",
|
|
"grid-template-columns",
|
|
"grid-auto-columns",
|
|
"grid-auto-rows",
|
|
],
|
|
feature: "intrinsic-width",
|
|
browsers: ["firefox 114"],
|
|
},
|
|
"fit-content": {
|
|
props: [
|
|
"width",
|
|
"min-width",
|
|
"max-width",
|
|
"height",
|
|
"min-height",
|
|
"max-height",
|
|
"inline-size",
|
|
"min-inline-size",
|
|
"max-inline-size",
|
|
"block-size",
|
|
"min-block-size",
|
|
"max-block-size",
|
|
"grid",
|
|
"grid-template",
|
|
"grid-template-rows",
|
|
"grid-template-columns",
|
|
"grid-auto-columns",
|
|
"grid-auto-rows",
|
|
],
|
|
feature: "intrinsic-width",
|
|
browsers: ["firefox 114"],
|
|
},
|
|
"text-decoration-style": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-decoration-color": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-decoration-line": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-decoration": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-decoration-skip": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-decoration-skip-ink": {
|
|
feature: "text-decoration",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"text-size-adjust": {
|
|
feature: "text-size-adjust",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
],
|
|
},
|
|
"mask-clip": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-composite": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-image": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-origin": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-repeat": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border-repeat": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border-source": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
mask: {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-position": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-size": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border-outset": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border-width": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"mask-border-slice": {
|
|
feature: "css-masks",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
"clip-path": { feature: "css-clip-path", browsers: ["samsung 21"] },
|
|
"box-decoration-break": {
|
|
feature: "css-boxdecorationbreak",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
"opera 99",
|
|
"safari 16.5",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
appearance: { feature: "css-appearance", browsers: ["samsung 21"] },
|
|
"image-set": {
|
|
props: [
|
|
"background",
|
|
"background-image",
|
|
"border-image",
|
|
"cursor",
|
|
"mask",
|
|
"mask-image",
|
|
"list-style",
|
|
"list-style-image",
|
|
"content",
|
|
],
|
|
feature: "css-image-set",
|
|
browsers: ["and_uc 15.5", "chrome 109", "samsung 21"],
|
|
},
|
|
"cross-fade": {
|
|
props: [
|
|
"background",
|
|
"background-image",
|
|
"border-image",
|
|
"mask",
|
|
"list-style",
|
|
"list-style-image",
|
|
"content",
|
|
"mask-image",
|
|
],
|
|
feature: "css-cross-fade",
|
|
browsers: [
|
|
"and_chr 114",
|
|
"and_uc 15.5",
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
"samsung 21",
|
|
],
|
|
},
|
|
isolate: {
|
|
props: ["unicode-bidi"],
|
|
feature: "css-unicode-bidi",
|
|
browsers: [
|
|
"ios_saf 16.1",
|
|
"ios_saf 16.3",
|
|
"ios_saf 16.4",
|
|
"ios_saf 16.5",
|
|
"safari 16.5",
|
|
],
|
|
},
|
|
"color-adjust": {
|
|
feature: "css-color-adjust",
|
|
browsers: [
|
|
"chrome 109",
|
|
"chrome 113",
|
|
"chrome 114",
|
|
"edge 114",
|
|
"opera 99",
|
|
],
|
|
},
|
|
};
|
|
});
|
|
var rb = v((eq, tb) => {
|
|
l();
|
|
tb.exports = {};
|
|
});
|
|
var ab = v((tq, sb) => {
|
|
l();
|
|
var EO = Wo(),
|
|
{ agents: TO } = ($n(), Ln),
|
|
ru = ym(),
|
|
PO = pt(),
|
|
DO = Kw(),
|
|
IO = eb(),
|
|
qO = rb(),
|
|
ib = { browsers: TO, prefixes: IO },
|
|
nb = `
|
|
Replace Autoprefixer \`browsers\` option to Browserslist config.
|
|
Use \`browserslist\` key in \`package.json\` or \`.browserslistrc\` file.
|
|
|
|
Using \`browsers\` option can cause errors. Browserslist config can
|
|
be used for Babel, Autoprefixer, postcss-normalize and other tools.
|
|
|
|
If you really need to use option, rename it to \`overrideBrowserslist\`.
|
|
|
|
Learn more at:
|
|
https://github.com/browserslist/browserslist#readme
|
|
https://twitter.com/browserslist
|
|
|
|
`;
|
|
function RO(i) {
|
|
return Object.prototype.toString.apply(i) === "[object Object]";
|
|
}
|
|
var iu = new Map();
|
|
function MO(i, e) {
|
|
e.browsers.selected.length !== 0 &&
|
|
(e.add.selectors.length > 0 ||
|
|
Object.keys(e.add).length > 2 ||
|
|
i.warn(`Autoprefixer target browsers do not need any prefixes.You do not need Autoprefixer anymore.
|
|
Check your Browserslist config to be sure that your targets are set up correctly.
|
|
|
|
Learn more at:
|
|
https://github.com/postcss/autoprefixer#readme
|
|
https://github.com/browserslist/browserslist#readme
|
|
|
|
`));
|
|
}
|
|
sb.exports = nr;
|
|
function nr(...i) {
|
|
let e;
|
|
if (
|
|
(i.length === 1 && RO(i[0])
|
|
? ((e = i[0]), (i = void 0))
|
|
: i.length === 0 || (i.length === 1 && !i[0])
|
|
? (i = void 0)
|
|
: i.length <= 2 && (Array.isArray(i[0]) || !i[0])
|
|
? ((e = i[1]), (i = i[0]))
|
|
: typeof i[i.length - 1] == "object" && (e = i.pop()),
|
|
e || (e = {}),
|
|
e.browser)
|
|
)
|
|
throw new Error(
|
|
"Change `browser` option to `overrideBrowserslist` in Autoprefixer",
|
|
);
|
|
if (e.browserslist)
|
|
throw new Error(
|
|
"Change `browserslist` option to `overrideBrowserslist` in Autoprefixer",
|
|
);
|
|
e.overrideBrowserslist
|
|
? (i = e.overrideBrowserslist)
|
|
: e.browsers &&
|
|
(typeof console != "undefined" &&
|
|
console.warn &&
|
|
(ru.red
|
|
? console.warn(
|
|
ru.red(
|
|
nb.replace(/`[^`]+`/g, (n) => ru.yellow(n.slice(1, -1))),
|
|
),
|
|
)
|
|
: console.warn(nb)),
|
|
(i = e.browsers));
|
|
let t = {
|
|
ignoreUnknownVersions: e.ignoreUnknownVersions,
|
|
stats: e.stats,
|
|
env: e.env,
|
|
};
|
|
function r(n) {
|
|
let a = ib,
|
|
s = new PO(a.browsers, i, n, t),
|
|
o = s.selected.join(", ") + JSON.stringify(e);
|
|
return iu.has(o) || iu.set(o, new DO(a.prefixes, s, e)), iu.get(o);
|
|
}
|
|
return {
|
|
postcssPlugin: "autoprefixer",
|
|
prepare(n) {
|
|
let a = r({ from: n.opts.from, env: e.env });
|
|
return {
|
|
OnceExit(s) {
|
|
MO(n, a),
|
|
e.remove !== !1 && a.processor.remove(s, n),
|
|
e.add !== !1 && a.processor.add(s, n);
|
|
},
|
|
};
|
|
},
|
|
info(n) {
|
|
return (n = n || {}), (n.from = n.from || h.cwd()), qO(r(n));
|
|
},
|
|
options: e,
|
|
browsers: i,
|
|
};
|
|
}
|
|
nr.postcss = !0;
|
|
nr.data = ib;
|
|
nr.defaults = EO.defaults;
|
|
nr.info = () => nr().info();
|
|
});
|
|
var ob = {};
|
|
Ae(ob, { default: () => BO });
|
|
var BO,
|
|
lb = C(() => {
|
|
l();
|
|
BO = [];
|
|
});
|
|
var fb = {};
|
|
Ae(fb, { default: () => FO });
|
|
var ub,
|
|
FO,
|
|
cb = C(() => {
|
|
l();
|
|
hi();
|
|
(ub = K(bi())), (FO = Ze(ub.default.theme));
|
|
});
|
|
var db = {};
|
|
Ae(db, { default: () => NO });
|
|
var pb,
|
|
NO,
|
|
hb = C(() => {
|
|
l();
|
|
hi();
|
|
(pb = K(bi())), (NO = Ze(pb.default));
|
|
});
|
|
l();
|
|
("use strict");
|
|
var LO = Je(mm()),
|
|
$O = Je(ge()),
|
|
jO = Je(ab()),
|
|
zO = Je((lb(), ob)),
|
|
VO = Je((cb(), fb)),
|
|
UO = Je((hb(), db)),
|
|
WO = Je((Zn(), ku)),
|
|
GO = Je((wo(), yo)),
|
|
HO = Je((hs(), tf));
|
|
function Je(i) {
|
|
return i && i.__esModule ? i : { default: i };
|
|
}
|
|
console.warn(
|
|
"cdn.tailwindcss.com should not be used in production. To use Tailwind CSS in production, install it as a PostCSS plugin or use the Tailwind CLI: https://tailwindcss.com/docs/installation",
|
|
);
|
|
var Hn = "tailwind",
|
|
nu = "text/tailwindcss",
|
|
mb = "/template.html",
|
|
xt,
|
|
gb = !0,
|
|
yb = 0,
|
|
su = new Set(),
|
|
au,
|
|
wb = "",
|
|
bb = (i = !1) => ({
|
|
get(e, t) {
|
|
return (!i || t === "config") &&
|
|
typeof e[t] == "object" &&
|
|
e[t] !== null
|
|
? new Proxy(e[t], bb())
|
|
: e[t];
|
|
},
|
|
set(e, t, r) {
|
|
return (e[t] = r), (!i || t === "config") && ou(!0), !0;
|
|
},
|
|
});
|
|
window[Hn] = new Proxy(
|
|
{
|
|
config: {},
|
|
defaultTheme: VO.default,
|
|
defaultConfig: UO.default,
|
|
colors: WO.default,
|
|
plugin: GO.default,
|
|
resolveConfig: HO.default,
|
|
},
|
|
bb(!0),
|
|
);
|
|
function vb(i) {
|
|
au.observe(i, {
|
|
attributes: !0,
|
|
attributeFilter: ["type"],
|
|
characterData: !0,
|
|
subtree: !0,
|
|
childList: !0,
|
|
});
|
|
}
|
|
new MutationObserver(async (i) => {
|
|
let e = !1;
|
|
if (!au) {
|
|
au = new MutationObserver(async () => await ou(!0));
|
|
for (let t of document.querySelectorAll(`style[type="${nu}"]`)) vb(t);
|
|
}
|
|
for (let t of i)
|
|
for (let r of t.addedNodes)
|
|
r.nodeType === 1 &&
|
|
r.tagName === "STYLE" &&
|
|
r.getAttribute("type") === nu &&
|
|
(vb(r), (e = !0));
|
|
await ou(e);
|
|
}).observe(document.documentElement, {
|
|
attributes: !0,
|
|
attributeFilter: ["class"],
|
|
childList: !0,
|
|
subtree: !0,
|
|
});
|
|
async function ou(i = !1) {
|
|
i && (yb++, su.clear());
|
|
let e = "";
|
|
for (let r of document.querySelectorAll(`style[type="${nu}"]`))
|
|
e += r.textContent;
|
|
let t = new Set();
|
|
for (let r of document.querySelectorAll("[class]"))
|
|
for (let n of r.classList) su.has(n) || t.add(n);
|
|
if (
|
|
document.body &&
|
|
(gb || t.size > 0 || e !== wb || !xt || !xt.isConnected)
|
|
) {
|
|
for (let n of t) su.add(n);
|
|
(gb = !1), (wb = e), (self[mb] = Array.from(t).join(" "));
|
|
let { css: r } = await (0, $O.default)([
|
|
(0, LO.default)({
|
|
...window[Hn].config,
|
|
_hash: yb,
|
|
content: [mb],
|
|
plugins: [
|
|
...zO.default,
|
|
...(Array.isArray(window[Hn].config.plugins)
|
|
? window[Hn].config.plugins
|
|
: []),
|
|
],
|
|
}),
|
|
(0, jO.default)({ remove: !1 }),
|
|
]).process(
|
|
`@tailwind base;@tailwind components;@tailwind utilities;${e}`,
|
|
);
|
|
(!xt || !xt.isConnected) &&
|
|
((xt = document.createElement("style")), document.head.append(xt)),
|
|
(xt.textContent = r);
|
|
}
|
|
}
|
|
})();
|
|
/*! https://mths.be/cssesc v3.0.0 by @mathias */
|