tailwind.js

(() => {
    var Pw = Object.create;
    var ii = Object.defineProperty;
    var Dw = Object.getOwnPropertyDescriptor;
    var qw = Object.getOwnPropertyNames;
    var Iw = Object.getPrototypeOf,
        Rw = Object.prototype.hasOwnProperty;
    var Ml = r => ii(r, '__esModule', { value: !0 });
    var Fn = r => {
        if (typeof require != 'undefined') return require(r);
        throw new Error('Dynamic require of "' + r + '" is not supported');
    };
    var A = (r, e) => () => (r && (e = r((r = 0))), e);
    var v = (r, e) => () => (
            e || r((e = { exports: {} }).exports, e), e.exports
        ),
        Ce = (r, e) => {
            Ml(r);
            for (var t in e) ii(r, t, { get: e[t], enumerable: !0 });
        },
        Mw = (r, e, t) => {
            if ((e && typeof e == 'object') || typeof e == 'function')
                for (let i of qw(e))
                    !Rw.call(r, i) &&
                        i !== 'default' &&
                        ii(r, i, {
                            get: () => e[i],
                            enumerable: !(t = Dw(e, i)) || t.enumerable,
                        });
            return r;
        },
        J = r =>
            Mw(
                Ml(
                    ii(
                        r != null ? Pw(Iw(r)) : {},
                        'default',
                        r && r.__esModule && 'default' in r
                            ? { get: () => r.default, enumerable: !0 }
                            : { value: r, enumerable: !0 }
                    )
                ),
                r
            );
    var m,
        l = A(() => {
            m = { platform: '', env: {}, versions: { node: '14.17.6' } };
        });
    var Fw,
        ae,
        Ge = A(() => {
            l();
            (Fw = 0),
                (ae = {
                    readFileSync: r => self[r] || '',
                    statSync: () => ({ mtimeMs: Fw++ }),
                });
        });
    var Nn = v((kO, Nl) => {
        l();
        ('use strict');
        var Fl = class {
            constructor(e = {}) {
                if (!(e.maxSize && e.maxSize > 0))
                    throw new TypeError(
                        '`maxSize` must be a number greater than 0'
                    );
                (this.maxSize = e.maxSize),
                    (this.onEviction = e.onEviction),
                    (this.cache = new Map()),
                    (this.oldCache = new Map()),
                    (this._size = 0);
            }
            _set(e, t) {
                if (
                    (this.cache.set(e, t),
                    this._size++,
                    this._size >= this.maxSize)
                ) {
                    if (
                        ((this._size = 0), typeof this.onEviction == 'function')
                    )
                        for (let [i, n] of this.oldCache.entries())
                            this.onEviction(i, n);
                    (this.oldCache = this.cache), (this.cache = new Map());
                }
            }
            get(e) {
                if (this.cache.has(e)) return this.cache.get(e);
                if (this.oldCache.has(e)) {
                    let t = this.oldCache.get(e);
                    return this.oldCache.delete(e), this._set(e, t), t;
                }
            }
            set(e, t) {
                return (
                    this.cache.has(e) ? this.cache.set(e, t) : this._set(e, t),
                    this
                );
            }
            has(e) {
                return this.cache.has(e) || this.oldCache.has(e);
            }
            peek(e) {
                if (this.cache.has(e)) return this.cache.get(e);
                if (this.oldCache.has(e)) return this.oldCache.get(e);
            }
            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);
            }
            *keys() {
                for (let [e] of this) yield e;
            }
            *values() {
                for (let [, e] of this) yield e;
            }
            *[Symbol.iterator]() {
                for (let e of this.cache) yield e;
                for (let e of this.oldCache) {
                    let [t] = e;
                    this.cache.has(t) || (yield e);
                }
            }
            get size() {
                let e = 0;
                for (let t of this.oldCache.keys()) this.cache.has(t) || e++;
                return Math.min(this._size + e, this.maxSize);
            }
        };
        Nl.exports = Fl;
    });
    var Ll,
        Bl = A(() => {
            l();
            Ll = r => r && r._hash;
        });
    function ni(r) {
        return Ll(r, { ignoreUnknown: !0 });
    }
    var $l = A(() => {
        l();
        Bl();
    });
    var zl = {};
    Ce(zl, { default: () => ie });
    var ie,
        lt = A(() => {
            l();
            ie = { resolve: r => r, extname: r => '.' + r.split('.').pop() };
        });
    var yt,
        si = A(() => {
            l();
            yt = {};
        });
    function jl(r) {
        let e = ae.readFileSync(r, 'utf-8'),
            t = yt(e);
        return { file: r, requires: t };
    }
    function Ln(r) {
        let t = [jl(r)];
        for (let i of t)
            i.requires
                .filter(n => n.startsWith('./') || n.startsWith('../'))
                .forEach(n => {
                    try {
                        let s = ie.dirname(i.file),
                            a = yt.sync(n, { basedir: s }),
                            o = jl(a);
                        t.push(o);
                    } catch (s) {}
                });
        return t;
    }
    var Vl = A(() => {
        l();
        Ge();
        lt();
        si();
        si();
    });
    function ut(r) {
        if (((r = `${r}`), r === '0')) return '0';
        if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(r))
            return r.replace(/^[+-]?/, t => (t === '-' ? '' : '-'));
        let e = ['var', 'calc', 'min', 'max', 'clamp'];
        for (let t of e) if (r.includes(`${t}(`)) return `calc(${r} * -1)`;
    }
    var ai = A(() => {
        l();
    });
    var Ul,
        Wl = A(() => {
            l();
            Ul = [
                'preflight',
                'container',
                'accessibility',
                'pointerEvents',
                'visibility',
                'position',
                'inset',
                'isolation',
                'zIndex',
                'order',
                'gridColumn',
                'gridColumnStart',
                'gridColumnEnd',
                'gridRow',
                'gridRowStart',
                'gridRowEnd',
                'float',
                'clear',
                'margin',
                'boxSizing',
                'display',
                'aspectRatio',
                'height',
                'maxHeight',
                'minHeight',
                'width',
                'minWidth',
                'maxWidth',
                'flex',
                'flexShrink',
                'flexGrow',
                'flexBasis',
                'tableLayout',
                'borderCollapse',
                'borderSpacing',
                'transformOrigin',
                'translate',
                'rotate',
                'skew',
                'scale',
                'transform',
                'animation',
                'cursor',
                'touchAction',
                'userSelect',
                'resize',
                'scrollSnapType',
                'scrollSnapAlign',
                'scrollSnapStop',
                'scrollMargin',
                'scrollPadding',
                'listStylePosition',
                'listStyleType',
                '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',
                'whitespace',
                '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',
            ];
        });
    function Gl(r, e) {
        return r === void 0
            ? e
            : Array.isArray(r)
            ? r
            : [
                  ...new Set(
                      e
                          .filter(i => r !== !1 && r[i] !== !1)
                          .concat(Object.keys(r).filter(i => r[i] !== !1))
                  ),
              ];
    }
    var Hl = A(() => {
        l();
    });
    var Zt = v((MO, Yl) => {
        l();
        Yl.exports = {
            content: [],
            presets: [],
            darkMode: 'media',
            theme: {
                screens: {
                    sm: '640px',
                    md: '768px',
                    lg: '1024px',
                    xl: '1280px',
                    '2xl': '1536px',
                },
                supports: {},
                colors: ({ colors: r }) => ({
                    inherit: r.inherit,
                    current: r.current,
                    transparent: r.transparent,
                    black: r.black,
                    white: r.white,
                    slate: r.slate,
                    gray: r.gray,
                    zinc: r.zinc,
                    neutral: r.neutral,
                    stone: r.stone,
                    red: r.red,
                    orange: r.orange,
                    amber: r.amber,
                    yellow: r.yellow,
                    lime: r.lime,
                    green: r.green,
                    emerald: r.emerald,
                    teal: r.teal,
                    cyan: r.cyan,
                    sky: r.sky,
                    blue: r.blue,
                    indigo: r.indigo,
                    violet: r.violet,
                    purple: r.purple,
                    fuchsia: r.fuchsia,
                    pink: r.pink,
                    rose: r.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',
                },
                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',
                },
                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: {
                    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: r }) => r('blur'),
                backdropBrightness: ({ theme: r }) => r('brightness'),
                backdropContrast: ({ theme: r }) => r('contrast'),
                backdropGrayscale: ({ theme: r }) => r('grayscale'),
                backdropHueRotate: ({ theme: r }) => r('hueRotate'),
                backdropInvert: ({ theme: r }) => r('invert'),
                backdropOpacity: ({ theme: r }) => r('opacity'),
                backdropSaturate: ({ theme: r }) => r('saturate'),
                backdropSepia: ({ theme: r }) => r('sepia'),
                backgroundColor: ({ theme: r }) => r('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: r }) => r('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',
                },
                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',
                },
                borderColor: ({ theme: r }) => ({
                    ...r('colors'),
                    DEFAULT: r('colors.gray.200', 'currentColor'),
                }),
                borderOpacity: ({ theme: r }) => r('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: r }) => ({ ...r('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: r }) => r('colors'),
                caretColor: ({ theme: r }) => r('colors'),
                accentColor: ({ theme: r }) => ({
                    ...r('colors'),
                    auto: 'auto',
                }),
                contrast: {
                    0: '0',
                    50: '.5',
                    75: '.75',
                    100: '1',
                    125: '1.25',
                    150: '1.5',
                    200: '2',
                },
                container: {},
                content: { none: 'none' },
                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: r }) => r('borderColor'),
                divideOpacity: ({ theme: r }) => r('borderOpacity'),
                divideWidth: ({ theme: r }) => r('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: r }) => ({ none: 'none', ...r('colors') }),
                grayscale: { 0: '0', DEFAULT: '100%' },
                hueRotate: {
                    0: '0deg',
                    15: '15deg',
                    30: '30deg',
                    60: '60deg',
                    90: '90deg',
                    180: '180deg',
                },
                invert: { 0: '0', DEFAULT: '100%' },
                flex: {
                    1: '1 1 0%',
                    auto: '1 1 auto',
                    initial: '0 1 auto',
                    none: 'none',
                },
                flexBasis: ({ theme: r }) => ({
                    auto: 'auto',
                    ...r('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',
                        '-apple-system',
                        'BlinkMacSystemFont',
                        '"Segoe UI"',
                        'Roboto',
                        '"Helvetica Neue"',
                        'Arial',
                        '"Noto Sans"',
                        '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: r }) => r('spacing'),
                gradientColorStops: ({ theme: r }) => r('colors'),
                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-full': '1 / -1',
                },
                gridRowStart: {
                    auto: 'auto',
                    1: '1',
                    2: '2',
                    3: '3',
                    4: '4',
                    5: '5',
                    6: '6',
                    7: '7',
                },
                gridRowEnd: {
                    auto: 'auto',
                    1: '1',
                    2: '2',
                    3: '3',
                    4: '4',
                    5: '5',
                    6: '6',
                    7: '7',
                },
                gridTemplateColumns: {
                    none: 'none',
                    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',
                    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))',
                },
                height: ({ theme: r }) => ({
                    auto: 'auto',
                    ...r('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',
                    min: 'min-content',
                    max: 'max-content',
                    fit: 'fit-content',
                }),
                inset: ({ theme: r }) => ({
                    auto: 'auto',
                    ...r('spacing'),
                    '1/2': '50%',
                    '1/3': '33.333333%',
                    '2/3': '66.666667%',
                    '1/4': '25%',
                    '2/4': '50%',
                    '3/4': '75%',
                    full: '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',
                },
                margin: ({ theme: r }) => ({ auto: 'auto', ...r('spacing') }),
                maxHeight: ({ theme: r }) => ({
                    ...r('spacing'),
                    full: '100%',
                    screen: '100vh',
                    min: 'min-content',
                    max: 'max-content',
                    fit: 'fit-content',
                }),
                maxWidth: ({ theme: r, breakpoints: e }) => ({
                    none: 'none',
                    0: '0rem',
                    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(r('screens')),
                }),
                minHeight: {
                    0: '0px',
                    full: '100%',
                    screen: '100vh',
                    min: 'min-content',
                    max: 'max-content',
                    fit: 'fit-content',
                },
                minWidth: {
                    0: '0px',
                    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',
                    20: '0.2',
                    25: '0.25',
                    30: '0.3',
                    40: '0.4',
                    50: '0.5',
                    60: '0.6',
                    70: '0.7',
                    75: '0.75',
                    80: '0.8',
                    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',
                },
                padding: ({ theme: r }) => r('spacing'),
                placeholderColor: ({ theme: r }) => r('colors'),
                placeholderOpacity: ({ theme: r }) => r('opacity'),
                outlineColor: ({ theme: r }) => r('colors'),
                outlineOffset: {
                    0: '0px',
                    1: '1px',
                    2: '2px',
                    4: '4px',
                    8: '8px',
                },
                outlineWidth: {
                    0: '0px',
                    1: '1px',
                    2: '2px',
                    4: '4px',
                    8: '8px',
                },
                ringColor: ({ theme: r }) => ({
                    DEFAULT: r('colors.blue.500', '#3b82f6'),
                    ...r('colors'),
                }),
                ringOffsetColor: ({ theme: r }) => r('colors'),
                ringOffsetWidth: {
                    0: '0px',
                    1: '1px',
                    2: '2px',
                    4: '4px',
                    8: '8px',
                },
                ringOpacity: ({ theme: r }) => ({
                    DEFAULT: '0.5',
                    ...r('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',
                },
                scrollMargin: ({ theme: r }) => ({ ...r('spacing') }),
                scrollPadding: ({ theme: r }) => r('spacing'),
                sepia: { 0: '0', DEFAULT: '100%' },
                skew: {
                    0: '0deg',
                    1: '1deg',
                    2: '2deg',
                    3: '3deg',
                    6: '6deg',
                    12: '12deg',
                },
                space: ({ theme: r }) => ({ ...r('spacing') }),
                stroke: ({ theme: r }) => ({ none: 'none', ...r('colors') }),
                strokeWidth: { 0: '0', 1: '1', 2: '2' },
                textColor: ({ theme: r }) => r('colors'),
                textDecorationColor: ({ theme: r }) => r('colors'),
                textDecorationThickness: {
                    auto: 'auto',
                    'from-font': 'from-font',
                    0: '0px',
                    1: '1px',
                    2: '2px',
                    4: '4px',
                    8: '8px',
                },
                textUnderlineOffset: {
                    auto: 'auto',
                    0: '0px',
                    1: '1px',
                    2: '2px',
                    4: '4px',
                    8: '8px',
                },
                textIndent: ({ theme: r }) => ({ ...r('spacing') }),
                textOpacity: ({ theme: r }) => r('opacity'),
                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: {
                    75: '75ms',
                    100: '100ms',
                    150: '150ms',
                    200: '200ms',
                    300: '300ms',
                    500: '500ms',
                    700: '700ms',
                    1e3: '1000ms',
                },
                transitionDuration: {
                    DEFAULT: '150ms',
                    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: r }) => ({
                    ...r('spacing'),
                    '1/2': '50%',
                    '1/3': '33.333333%',
                    '2/3': '66.666667%',
                    '1/4': '25%',
                    '2/4': '50%',
                    '3/4': '75%',
                    full: '100%',
                }),
                width: ({ theme: r }) => ({
                    auto: 'auto',
                    ...r('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',
                    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',
                },
            },
            variantOrder: [
                'first',
                'last',
                'odd',
                'even',
                'visited',
                'checked',
                'empty',
                'read-only',
                'group-hover',
                'group-focus',
                'focus-within',
                'hover',
                'focus',
                'focus-visible',
                'active',
                'disabled',
            ],
            plugins: [],
        };
    });
    var Ql = {};
    Ce(Ql, { default: () => _e });
    var _e,
        oi = A(() => {
            l();
            _e = new Proxy({}, { get: () => String });
        });
    function Bn(r, e, t) {
        (typeof m != 'undefined' && m.env.JEST_WORKER_ID) ||
            (t && Jl.has(t)) ||
            (t && Jl.add(t),
            console.warn(''),
            e.forEach(i => console.warn(r, '-', i)));
    }
    function $n(r) {
        return _e.dim(r);
    }
    var Jl,
        N,
        Ae = A(() => {
            l();
            oi();
            Jl = new Set();
            N = {
                info(r, e) {
                    Bn(
                        _e.bold(_e.cyan('info')),
                        ...(Array.isArray(r) ? [r] : [e, r])
                    );
                },
                warn(r, e) {
                    Bn(
                        _e.bold(_e.yellow('warn')),
                        ...(Array.isArray(r) ? [r] : [e, r])
                    );
                },
                risk(r, e) {
                    Bn(
                        _e.bold(_e.magenta('risk')),
                        ...(Array.isArray(r) ? [r] : [e, r])
                    );
                },
            };
        });
    var Xl = {};
    Ce(Xl, { default: () => zn });
    function er({ version: r, from: e, to: t }) {
        N.warn(`${e}-color-renamed`, [
            `As of Tailwind CSS ${r}, \`${e}\` has been renamed to \`${t}\`.`,
            'Update your configuration file to silence this warning.',
        ]);
    }
    var zn,
        jn = A(() => {
            l();
            Ae();
            zn = {
                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',
                },
                gray: {
                    50: '#f9fafb',
                    100: '#f3f4f6',
                    200: '#e5e7eb',
                    300: '#d1d5db',
                    400: '#9ca3af',
                    500: '#6b7280',
                    600: '#4b5563',
                    700: '#374151',
                    800: '#1f2937',
                    900: '#111827',
                },
                zinc: {
                    50: '#fafafa',
                    100: '#f4f4f5',
                    200: '#e4e4e7',
                    300: '#d4d4d8',
                    400: '#a1a1aa',
                    500: '#71717a',
                    600: '#52525b',
                    700: '#3f3f46',
                    800: '#27272a',
                    900: '#18181b',
                },
                neutral: {
                    50: '#fafafa',
                    100: '#f5f5f5',
                    200: '#e5e5e5',
                    300: '#d4d4d4',
                    400: '#a3a3a3',
                    500: '#737373',
                    600: '#525252',
                    700: '#404040',
                    800: '#262626',
                    900: '#171717',
                },
                stone: {
                    50: '#fafaf9',
                    100: '#f5f5f4',
                    200: '#e7e5e4',
                    300: '#d6d3d1',
                    400: '#a8a29e',
                    500: '#78716c',
                    600: '#57534e',
                    700: '#44403c',
                    800: '#292524',
                    900: '#1c1917',
                },
                red: {
                    50: '#fef2f2',
                    100: '#fee2e2',
                    200: '#fecaca',
                    300: '#fca5a5',
                    400: '#f87171',
                    500: '#ef4444',
                    600: '#dc2626',
                    700: '#b91c1c',
                    800: '#991b1b',
                    900: '#7f1d1d',
                },
                orange: {
                    50: '#fff7ed',
                    100: '#ffedd5',
                    200: '#fed7aa',
                    300: '#fdba74',
                    400: '#fb923c',
                    500: '#f97316',
                    600: '#ea580c',
                    700: '#c2410c',
                    800: '#9a3412',
                    900: '#7c2d12',
                },
                amber: {
                    50: '#fffbeb',
                    100: '#fef3c7',
                    200: '#fde68a',
                    300: '#fcd34d',
                    400: '#fbbf24',
                    500: '#f59e0b',
                    600: '#d97706',
                    700: '#b45309',
                    800: '#92400e',
                    900: '#78350f',
                },
                yellow: {
                    50: '#fefce8',
                    100: '#fef9c3',
                    200: '#fef08a',
                    300: '#fde047',
                    400: '#facc15',
                    500: '#eab308',
                    600: '#ca8a04',
                    700: '#a16207',
                    800: '#854d0e',
                    900: '#713f12',
                },
                lime: {
                    50: '#f7fee7',
                    100: '#ecfccb',
                    200: '#d9f99d',
                    300: '#bef264',
                    400: '#a3e635',
                    500: '#84cc16',
                    600: '#65a30d',
                    700: '#4d7c0f',
                    800: '#3f6212',
                    900: '#365314',
                },
                green: {
                    50: '#f0fdf4',
                    100: '#dcfce7',
                    200: '#bbf7d0',
                    300: '#86efac',
                    400: '#4ade80',
                    500: '#22c55e',
                    600: '#16a34a',
                    700: '#15803d',
                    800: '#166534',
                    900: '#14532d',
                },
                emerald: {
                    50: '#ecfdf5',
                    100: '#d1fae5',
                    200: '#a7f3d0',
                    300: '#6ee7b7',
                    400: '#34d399',
                    500: '#10b981',
                    600: '#059669',
                    700: '#047857',
                    800: '#065f46',
                    900: '#064e3b',
                },
                teal: {
                    50: '#f0fdfa',
                    100: '#ccfbf1',
                    200: '#99f6e4',
                    300: '#5eead4',
                    400: '#2dd4bf',
                    500: '#14b8a6',
                    600: '#0d9488',
                    700: '#0f766e',
                    800: '#115e59',
                    900: '#134e4a',
                },
                cyan: {
                    50: '#ecfeff',
                    100: '#cffafe',
                    200: '#a5f3fc',
                    300: '#67e8f9',
                    400: '#22d3ee',
                    500: '#06b6d4',
                    600: '#0891b2',
                    700: '#0e7490',
                    800: '#155e75',
                    900: '#164e63',
                },
                sky: {
                    50: '#f0f9ff',
                    100: '#e0f2fe',
                    200: '#bae6fd',
                    300: '#7dd3fc',
                    400: '#38bdf8',
                    500: '#0ea5e9',
                    600: '#0284c7',
                    700: '#0369a1',
                    800: '#075985',
                    900: '#0c4a6e',
                },
                blue: {
                    50: '#eff6ff',
                    100: '#dbeafe',
                    200: '#bfdbfe',
                    300: '#93c5fd',
                    400: '#60a5fa',
                    500: '#3b82f6',
                    600: '#2563eb',
                    700: '#1d4ed8',
                    800: '#1e40af',
                    900: '#1e3a8a',
                },
                indigo: {
                    50: '#eef2ff',
                    100: '#e0e7ff',
                    200: '#c7d2fe',
                    300: '#a5b4fc',
                    400: '#818cf8',
                    500: '#6366f1',
                    600: '#4f46e5',
                    700: '#4338ca',
                    800: '#3730a3',
                    900: '#312e81',
                },
                violet: {
                    50: '#f5f3ff',
                    100: '#ede9fe',
                    200: '#ddd6fe',
                    300: '#c4b5fd',
                    400: '#a78bfa',
                    500: '#8b5cf6',
                    600: '#7c3aed',
                    700: '#6d28d9',
                    800: '#5b21b6',
                    900: '#4c1d95',
                },
                purple: {
                    50: '#faf5ff',
                    100: '#f3e8ff',
                    200: '#e9d5ff',
                    300: '#d8b4fe',
                    400: '#c084fc',
                    500: '#a855f7',
                    600: '#9333ea',
                    700: '#7e22ce',
                    800: '#6b21a8',
                    900: '#581c87',
                },
                fuchsia: {
                    50: '#fdf4ff',
                    100: '#fae8ff',
                    200: '#f5d0fe',
                    300: '#f0abfc',
                    400: '#e879f9',
                    500: '#d946ef',
                    600: '#c026d3',
                    700: '#a21caf',
                    800: '#86198f',
                    900: '#701a75',
                },
                pink: {
                    50: '#fdf2f8',
                    100: '#fce7f3',
                    200: '#fbcfe8',
                    300: '#f9a8d4',
                    400: '#f472b6',
                    500: '#ec4899',
                    600: '#db2777',
                    700: '#be185d',
                    800: '#9d174d',
                    900: '#831843',
                },
                rose: {
                    50: '#fff1f2',
                    100: '#ffe4e6',
                    200: '#fecdd3',
                    300: '#fda4af',
                    400: '#fb7185',
                    500: '#f43f5e',
                    600: '#e11d48',
                    700: '#be123c',
                    800: '#9f1239',
                    900: '#881337',
                },
                get lightBlue() {
                    return (
                        er({ version: 'v2.2', from: 'lightBlue', to: 'sky' }),
                        this.sky
                    );
                },
                get warmGray() {
                    return (
                        er({ version: 'v3.0', from: 'warmGray', to: 'stone' }),
                        this.stone
                    );
                },
                get trueGray() {
                    return (
                        er({
                            version: 'v3.0',
                            from: 'trueGray',
                            to: 'neutral',
                        }),
                        this.neutral
                    );
                },
                get coolGray() {
                    return (
                        er({ version: 'v3.0', from: 'coolGray', to: 'gray' }),
                        this.gray
                    );
                },
                get blueGray() {
                    return (
                        er({ version: 'v3.0', from: 'blueGray', to: 'slate' }),
                        this.slate
                    );
                },
            };
        });
    function Vn(r, ...e) {
        for (let t of e) {
            for (let i in t) r?.hasOwnProperty?.(i) || (r[i] = t[i]);
            for (let i of Object.getOwnPropertySymbols(t))
                r?.hasOwnProperty?.(i) || (r[i] = t[i]);
        }
        return r;
    }
    var Kl = A(() => {
        l();
    });
    function He(r) {
        if (Array.isArray(r)) return r;
        let e = r.split('[').length - 1,
            t = r.split(']').length - 1;
        if (e !== t)
            throw new Error(`Path is invalid. Has unbalanced brackets: ${r}`);
        return r.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean);
    }
    var li = A(() => {
        l();
    });
    function Zl(r) {
        (() => {
            if (
                r.purge ||
                !r.content ||
                (!Array.isArray(r.content) &&
                    !(typeof r.content == 'object' && r.content !== null))
            )
                return !1;
            if (Array.isArray(r.content))
                return r.content.every(t =>
                    typeof t == 'string'
                        ? !0
                        : !(
                              typeof t?.raw != 'string' ||
                              (t?.extension && typeof t?.extension != 'string')
                          )
                );
            if (typeof r.content == 'object' && r.content !== null) {
                if (
                    Object.keys(r.content).some(
                        t =>
                            ![
                                'files',
                                'relative',
                                'extract',
                                'transform',
                            ].includes(t)
                    )
                )
                    return !1;
                if (Array.isArray(r.content.files)) {
                    if (
                        !r.content.files.every(t =>
                            typeof t == 'string'
                                ? !0
                                : !(
                                      typeof t?.raw != 'string' ||
                                      (t?.extension &&
                                          typeof t?.extension != 'string')
                                  )
                        )
                    )
                        return !1;
                    if (typeof r.content.extract == 'object') {
                        for (let t of Object.values(r.content.extract))
                            if (typeof t != 'function') return !1;
                    } else if (
                        !(
                            r.content.extract === void 0 ||
                            typeof r.content.extract == 'function'
                        )
                    )
                        return !1;
                    if (typeof r.content.transform == 'object') {
                        for (let t of Object.values(r.content.transform))
                            if (typeof t != 'function') return !1;
                    } else if (
                        !(
                            r.content.transform === void 0 ||
                            typeof r.content.transform == 'function'
                        )
                    )
                        return !1;
                    if (
                        typeof r.content.relative != 'boolean' &&
                        typeof r.content.relative != 'undefined'
                    )
                        return !1;
                }
                return !0;
            }
            return !1;
        })() ||
            N.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',
            ]),
            (r.safelist = (() => {
                let { content: t, purge: i, safelist: n } = r;
                return Array.isArray(n)
                    ? n
                    : Array.isArray(t?.safelist)
                    ? t.safelist
                    : Array.isArray(i?.safelist)
                    ? i.safelist
                    : Array.isArray(i?.options?.safelist)
                    ? i.options.safelist
                    : [];
            })()),
            (r.blocklist = (() => {
                let { blocklist: t } = r;
                if (Array.isArray(t)) {
                    if (t.every(i => typeof i == 'string')) return t;
                    N.warn('blocklist-invalid', [
                        'The `blocklist` option must be an array of strings.',
                        'https://tailwindcss.com/docs/content-configuration#discarding-classes',
                    ]);
                }
                return [];
            })()),
            typeof r.prefix == 'function'
                ? (N.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',
                  ]),
                  (r.prefix = ''))
                : (r.prefix = r.prefix ?? ''),
            (r.content = {
                relative: (() => {
                    let { content: t } = r;
                    return t?.relative
                        ? t.relative
                        : r.future?.relativeContentPathsByDefault ?? !1;
                })(),
                files: (() => {
                    let { content: t, purge: i } = r;
                    return Array.isArray(i)
                        ? i
                        : Array.isArray(i?.content)
                        ? i.content
                        : Array.isArray(t)
                        ? t
                        : Array.isArray(t?.content)
                        ? t.content
                        : Array.isArray(t?.files)
                        ? t.files
                        : [];
                })(),
                extract: (() => {
                    let t = (() =>
                            r.purge?.extract
                                ? r.purge.extract
                                : r.content?.extract
                                ? r.content.extract
                                : r.purge?.extract?.DEFAULT
                                ? r.purge.extract.DEFAULT
                                : r.content?.extract?.DEFAULT
                                ? r.content.extract.DEFAULT
                                : r.purge?.options?.extractors
                                ? r.purge.options.extractors
                                : r.content?.options?.extractors
                                ? r.content.options.extractors
                                : {})(),
                        i = {},
                        n = (() => {
                            if (r.purge?.options?.defaultExtractor)
                                return r.purge.options.defaultExtractor;
                            if (r.content?.options?.defaultExtractor)
                                return r.content.options.defaultExtractor;
                        })();
                    if (
                        (n !== void 0 && (i.DEFAULT = n),
                        typeof t == 'function')
                    )
                        i.DEFAULT = t;
                    else if (Array.isArray(t))
                        for (let { extensions: s, extractor: a } of t ?? [])
                            for (let o of s) i[o] = a;
                    else
                        typeof t == 'object' &&
                            t !== null &&
                            Object.assign(i, t);
                    return i;
                })(),
                transform: (() => {
                    let t = (() =>
                            r.purge?.transform
                                ? r.purge.transform
                                : r.content?.transform
                                ? r.content.transform
                                : r.purge?.transform?.DEFAULT
                                ? r.purge.transform.DEFAULT
                                : r.content?.transform?.DEFAULT
                                ? r.content.transform.DEFAULT
                                : {})(),
                        i = {};
                    return (
                        typeof t == 'function' && (i.DEFAULT = t),
                        typeof t == 'object' &&
                            t !== null &&
                            Object.assign(i, t),
                        i
                    );
                })(),
            });
        for (let t of r.content.files)
            if (typeof t == 'string' && /{([^,]*?)}/g.test(t)) {
                N.warn('invalid-glob-braces', [
                    `The glob pattern ${$n(
                        t
                    )} in your Tailwind CSS configuration is invalid.`,
                    `Update it to ${$n(
                        t.replace(/{([^,]*?)}/g, '$1')
                    )} to silence this warning.`,
                ]);
                break;
            }
        return r;
    }
    var eu = A(() => {
        l();
        Ae();
    });
    function ee(r) {
        if (Object.prototype.toString.call(r) !== '[object Object]') return !1;
        let e = Object.getPrototypeOf(r);
        return e === null || e === Object.prototype;
    }
    var wt = A(() => {
        l();
    });
    function Ye(r) {
        return Array.isArray(r)
            ? r.map(e => Ye(e))
            : typeof r == 'object' && r !== null
            ? Object.fromEntries(Object.entries(r).map(([e, t]) => [e, Ye(t)]))
            : r;
    }
    var ui = A(() => {
        l();
    });
    var ci = v((fi, tu) => {
        l();
        ('use strict');
        fi.__esModule = !0;
        fi.default = Bw;
        function Nw(r) {
            for (
                var e = r.toLowerCase(), t = '', i = !1, n = 0;
                n < 6 && e[n] !== void 0;
                n++
            ) {
                var s = e.charCodeAt(n),
                    a = (s >= 97 && s <= 102) || (s >= 48 && s <= 57);
                if (((i = s === 32), !a)) 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 + (i ? 1 : 0)]
                    : [String.fromCodePoint(o), t.length + (i ? 1 : 0)];
            }
        }
        var Lw = /\\/;
        function Bw(r) {
            var e = Lw.test(r);
            if (!e) return r;
            for (var t = '', i = 0; i < r.length; i++) {
                if (r[i] === '\\') {
                    var n = Nw(r.slice(i + 1, i + 7));
                    if (n !== void 0) {
                        (t += n[0]), (i += n[1]);
                        continue;
                    }
                    if (r[i + 1] === '\\') {
                        (t += '\\'), i++;
                        continue;
                    }
                    r.length === i + 1 && (t += r[i]);
                    continue;
                }
                t += r[i];
            }
            return t;
        }
        tu.exports = fi.default;
    });
    var iu = v((pi, ru) => {
        l();
        ('use strict');
        pi.__esModule = !0;
        pi.default = $w;
        function $w(r) {
            for (
                var e = arguments.length,
                    t = new Array(e > 1 ? e - 1 : 0),
                    i = 1;
                i < e;
                i++
            )
                t[i - 1] = arguments[i];
            for (; t.length > 0; ) {
                var n = t.shift();
                if (!r[n]) return;
                r = r[n];
            }
            return r;
        }
        ru.exports = pi.default;
    });
    var su = v((di, nu) => {
        l();
        ('use strict');
        di.__esModule = !0;
        di.default = zw;
        function zw(r) {
            for (
                var e = arguments.length,
                    t = new Array(e > 1 ? e - 1 : 0),
                    i = 1;
                i < e;
                i++
            )
                t[i - 1] = arguments[i];
            for (; t.length > 0; ) {
                var n = t.shift();
                r[n] || (r[n] = {}), (r = r[n]);
            }
        }
        nu.exports = di.default;
    });
    var ou = v((hi, au) => {
        l();
        ('use strict');
        hi.__esModule = !0;
        hi.default = jw;
        function jw(r) {
            for (var e = '', t = r.indexOf('/*'), i = 0; t >= 0; ) {
                e = e + r.slice(i, t);
                var n = r.indexOf('*/', t + 2);
                if (n < 0) return e;
                (i = n + 2), (t = r.indexOf('/*', i));
            }
            return (e = e + r.slice(i)), e;
        }
        au.exports = hi.default;
    });
    var tr = v(Pe => {
        l();
        ('use strict');
        Pe.__esModule = !0;
        Pe.stripComments = Pe.ensureObject = Pe.getProp = Pe.unesc = void 0;
        var Vw = mi(ci());
        Pe.unesc = Vw.default;
        var Uw = mi(iu());
        Pe.getProp = Uw.default;
        var Ww = mi(su());
        Pe.ensureObject = Ww.default;
        var Gw = mi(ou());
        Pe.stripComments = Gw.default;
        function mi(r) {
            return r && r.__esModule ? r : { default: r };
        }
    });
    var Le = v((rr, fu) => {
        l();
        ('use strict');
        rr.__esModule = !0;
        rr.default = void 0;
        var lu = tr();
        function uu(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function Hw(r, e, t) {
            return e && uu(r.prototype, e), t && uu(r, t), r;
        }
        var Yw = function r(e, t) {
                if (typeof e != 'object' || e === null) return e;
                var i = new e.constructor();
                for (var n in e)
                    if (!!e.hasOwnProperty(n)) {
                        var s = e[n],
                            a = typeof s;
                        n === 'parent' && a === 'object'
                            ? t && (i[n] = t)
                            : s instanceof Array
                            ? (i[n] = s.map(function (o) {
                                  return r(o, i);
                              }))
                            : (i[n] = r(s, i));
                    }
                return i;
            },
            Qw = (function () {
                function r(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 = r.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 i in arguments)
                                this.parent.insertBefore(this, arguments[i]);
                            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 (i) {
                        i === void 0 && (i = {});
                        var n = Yw(this);
                        for (var s in i) n[s] = i[s];
                        return n;
                    }),
                    (e.appendToPropertyAndEscape = function (i, n, s) {
                        this.raws || (this.raws = {});
                        var a = this[i],
                            o = this.raws[i];
                        (this[i] = a + n),
                            o || s !== n
                                ? (this.raws[i] = (o || a) + s)
                                : delete this.raws[i];
                    }),
                    (e.setPropertyAndEscape = function (i, n, s) {
                        this.raws || (this.raws = {}),
                            (this[i] = n),
                            (this.raws[i] = s);
                    }),
                    (e.setPropertyWithoutEscape = function (i, n) {
                        (this[i] = n), this.raws && delete this.raws[i];
                    }),
                    (e.isAtPosition = function (i, n) {
                        if (this.source && this.source.start && this.source.end)
                            return !(
                                this.source.start.line > i ||
                                this.source.end.line < i ||
                                (this.source.start.line === i &&
                                    this.source.start.column > n) ||
                                (this.source.end.line === i &&
                                    this.source.end.column < n)
                            );
                    }),
                    (e.stringifyProperty = function (i) {
                        return (this.raws && this.raws[i]) || this[i];
                    }),
                    (e.valueToString = function () {
                        return String(this.stringifyProperty('value'));
                    }),
                    (e.toString = function () {
                        return [
                            this.rawSpaceBefore,
                            this.valueToString(),
                            this.rawSpaceAfter,
                        ].join('');
                    }),
                    Hw(r, [
                        {
                            key: 'rawSpaceBefore',
                            get: function () {
                                var i =
                                    this.raws &&
                                    this.raws.spaces &&
                                    this.raws.spaces.before;
                                return (
                                    i === void 0 &&
                                        (i = this.spaces && this.spaces.before),
                                    i || ''
                                );
                            },
                            set: function (i) {
                                (0, lu.ensureObject)(this, 'raws', 'spaces'),
                                    (this.raws.spaces.before = i);
                            },
                        },
                        {
                            key: 'rawSpaceAfter',
                            get: function () {
                                var i =
                                    this.raws &&
                                    this.raws.spaces &&
                                    this.raws.spaces.after;
                                return (
                                    i === void 0 && (i = this.spaces.after),
                                    i || ''
                                );
                            },
                            set: function (i) {
                                (0, lu.ensureObject)(this, 'raws', 'spaces'),
                                    (this.raws.spaces.after = i);
                            },
                        },
                    ]),
                    r
                );
            })();
        rr.default = Qw;
        fu.exports = rr.default;
    });
    var te = v(U => {
        l();
        ('use strict');
        U.__esModule = !0;
        U.UNIVERSAL =
            U.ATTRIBUTE =
            U.CLASS =
            U.COMBINATOR =
            U.COMMENT =
            U.ID =
            U.NESTING =
            U.PSEUDO =
            U.ROOT =
            U.SELECTOR =
            U.STRING =
            U.TAG =
                void 0;
        var Jw = 'tag';
        U.TAG = Jw;
        var Xw = 'string';
        U.STRING = Xw;
        var Kw = 'selector';
        U.SELECTOR = Kw;
        var Zw = 'root';
        U.ROOT = Zw;
        var eb = 'pseudo';
        U.PSEUDO = eb;
        var tb = 'nesting';
        U.NESTING = tb;
        var rb = 'id';
        U.ID = rb;
        var ib = 'comment';
        U.COMMENT = ib;
        var nb = 'combinator';
        U.COMBINATOR = nb;
        var sb = 'class';
        U.CLASS = sb;
        var ab = 'attribute';
        U.ATTRIBUTE = ab;
        var ob = 'universal';
        U.UNIVERSAL = ob;
    });
    var gi = v((ir, hu) => {
        l();
        ('use strict');
        ir.__esModule = !0;
        ir.default = void 0;
        var lb = fb(Le()),
            Be = ub(te());
        function cu() {
            if (typeof WeakMap != 'function') return null;
            var r = new WeakMap();
            return (
                (cu = function () {
                    return r;
                }),
                r
            );
        }
        function ub(r) {
            if (r && r.__esModule) return r;
            if (r === null || (typeof r != 'object' && typeof r != 'function'))
                return { default: r };
            var e = cu();
            if (e && e.has(r)) return e.get(r);
            var t = {},
                i = Object.defineProperty && Object.getOwnPropertyDescriptor;
            for (var n in r)
                if (Object.prototype.hasOwnProperty.call(r, n)) {
                    var s = i ? Object.getOwnPropertyDescriptor(r, n) : null;
                    s && (s.get || s.set)
                        ? Object.defineProperty(t, n, s)
                        : (t[n] = r[n]);
                }
            return (t.default = r), e && e.set(r, t), t;
        }
        function fb(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function cb(r, e) {
            var t;
            if (typeof Symbol == 'undefined' || r[Symbol.iterator] == null) {
                if (
                    Array.isArray(r) ||
                    (t = pb(r)) ||
                    (e && r && typeof r.length == 'number')
                ) {
                    t && (r = t);
                    var i = 0;
                    return function () {
                        return i >= r.length
                            ? { done: !0 }
                            : { done: !1, value: r[i++] };
                    };
                }
                throw new TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
            }
            return (t = r[Symbol.iterator]()), t.next.bind(t);
        }
        function pb(r, e) {
            if (!!r) {
                if (typeof r == 'string') return pu(r, e);
                var t = Object.prototype.toString.call(r).slice(8, -1);
                if (
                    (t === 'Object' &&
                        r.constructor &&
                        (t = r.constructor.name),
                    t === 'Map' || t === 'Set')
                )
                    return Array.from(r);
                if (
                    t === 'Arguments' ||
                    /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
                )
                    return pu(r, e);
            }
        }
        function pu(r, e) {
            (e == null || e > r.length) && (e = r.length);
            for (var t = 0, i = new Array(e); t < e; t++) i[t] = r[t];
            return i;
        }
        function du(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function db(r, e, t) {
            return e && du(r.prototype, e), t && du(r, t), r;
        }
        function hb(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                Un(r, e);
        }
        function Un(r, e) {
            return (
                (Un =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                Un(r, e)
            );
        }
        var mb = (function (r) {
            hb(e, r);
            function e(i) {
                var n;
                return (
                    (n = r.call(this, i) || 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 s;
                    for (var a in this.indexes)
                        (s = this.indexes[a]),
                            s >= n && (this.indexes[a] = s - 1);
                    return this;
                }),
                (t.removeAll = function () {
                    for (var n = cb(this.nodes), s; !(s = n()).done; ) {
                        var a = s.value;
                        a.parent = void 0;
                    }
                    return (this.nodes = []), this;
                }),
                (t.empty = function () {
                    return this.removeAll();
                }),
                (t.insertAfter = function (n, s) {
                    s.parent = this;
                    var a = this.index(n);
                    this.nodes.splice(a + 1, 0, s), (s.parent = this);
                    var o;
                    for (var u in this.indexes)
                        (o = this.indexes[u]),
                            a <= o && (this.indexes[u] = o + 1);
                    return this;
                }),
                (t.insertBefore = function (n, s) {
                    s.parent = this;
                    var a = this.index(n);
                    this.nodes.splice(a, 0, s), (s.parent = this);
                    var o;
                    for (var u in this.indexes)
                        (o = this.indexes[u]),
                            o <= a && (this.indexes[u] = o + 1);
                    return this;
                }),
                (t._findChildAtPosition = function (n, s) {
                    var a = void 0;
                    return (
                        this.each(function (o) {
                            if (o.atPosition) {
                                var u = o.atPosition(n, s);
                                if (u) return (a = u), !1;
                            } else if (o.isAtPosition(n, s)) return (a = o), !1;
                        }),
                        a
                    );
                }),
                (t.atPosition = function (n, s) {
                    if (this.isAtPosition(n, s))
                        return this._findChildAtPosition(n, s) || 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 s = this.lastEach;
                    if (((this.indexes[s] = 0), !!this.length)) {
                        for (
                            var a, o;
                            this.indexes[s] < this.length &&
                            ((a = this.indexes[s]),
                            (o = n(this.at(a), a)),
                            o !== !1);

                        )
                            this.indexes[s] += 1;
                        if ((delete this.indexes[s], o === !1)) return !1;
                    }
                }),
                (t.walk = function (n) {
                    return this.each(function (s, a) {
                        var o = n(s, a);
                        if ((o !== !1 && s.length && (o = s.walk(n)), o === !1))
                            return !1;
                    });
                }),
                (t.walkAttributes = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.ATTRIBUTE) return n.call(s, a);
                    });
                }),
                (t.walkClasses = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.CLASS) return n.call(s, a);
                    });
                }),
                (t.walkCombinators = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.COMBINATOR) return n.call(s, a);
                    });
                }),
                (t.walkComments = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.COMMENT) return n.call(s, a);
                    });
                }),
                (t.walkIds = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.ID) return n.call(s, a);
                    });
                }),
                (t.walkNesting = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.NESTING) return n.call(s, a);
                    });
                }),
                (t.walkPseudos = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.PSEUDO) return n.call(s, a);
                    });
                }),
                (t.walkTags = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.TAG) return n.call(s, a);
                    });
                }),
                (t.walkUniversals = function (n) {
                    var s = this;
                    return this.walk(function (a) {
                        if (a.type === Be.UNIVERSAL) return n.call(s, a);
                    });
                }),
                (t.split = function (n) {
                    var s = this,
                        a = [];
                    return this.reduce(function (o, u, c) {
                        var f = n.call(s, u);
                        return (
                            a.push(u),
                            f
                                ? (o.push(a), (a = []))
                                : c === s.length - 1 && o.push(a),
                            o
                        );
                    }, []);
                }),
                (t.map = function (n) {
                    return this.nodes.map(n);
                }),
                (t.reduce = function (n, s) {
                    return this.nodes.reduce(n, s);
                }),
                (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('');
                }),
                db(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
            );
        })(lb.default);
        ir.default = mb;
        hu.exports = ir.default;
    });
    var Gn = v((nr, gu) => {
        l();
        ('use strict');
        nr.__esModule = !0;
        nr.default = void 0;
        var gb = wb(gi()),
            yb = te();
        function wb(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function mu(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function bb(r, e, t) {
            return e && mu(r.prototype, e), t && mu(r, t), r;
        }
        function vb(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                Wn(r, e);
        }
        function Wn(r, e) {
            return (
                (Wn =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                Wn(r, e)
            );
        }
        var xb = (function (r) {
            vb(e, r);
            function e(i) {
                var n;
                return (n = r.call(this, i) || this), (n.type = yb.ROOT), n;
            }
            var t = e.prototype;
            return (
                (t.toString = function () {
                    var n = this.reduce(function (s, a) {
                        return s.push(String(a)), s;
                    }, []).join(',');
                    return this.trailingComma ? n + ',' : n;
                }),
                (t.error = function (n, s) {
                    return this._error ? this._error(n, s) : new Error(n);
                }),
                bb(e, [
                    {
                        key: 'errorGenerator',
                        set: function (n) {
                            this._error = n;
                        },
                    },
                ]),
                e
            );
        })(gb.default);
        nr.default = xb;
        gu.exports = nr.default;
    });
    var Yn = v((sr, yu) => {
        l();
        ('use strict');
        sr.__esModule = !0;
        sr.default = void 0;
        var kb = Cb(gi()),
            Sb = te();
        function Cb(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function _b(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                Hn(r, e);
        }
        function Hn(r, e) {
            return (
                (Hn =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                Hn(r, e)
            );
        }
        var Ab = (function (r) {
            _b(e, r);
            function e(t) {
                var i;
                return (i = r.call(this, t) || this), (i.type = Sb.SELECTOR), i;
            }
            return e;
        })(kb.default);
        sr.default = Ab;
        yu.exports = sr.default;
    });
    var yi = v((HO, wu) => {
        l();
        ('use strict');
        var Ob = {},
            Eb = Ob.hasOwnProperty,
            Tb = function (e, t) {
                if (!e) return t;
                var i = {};
                for (var n in t) i[n] = Eb.call(e, n) ? e[n] : t[n];
                return i;
            },
            Pb = /[ -,\.\/:-@\[-\^`\{-~]/,
            Db = /[ -,\.\/:-@\[\]\^`\{-~]/,
            qb = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g,
            Qn = function r(e, t) {
                (t = Tb(t, r.options)),
                    t.quotes != 'single' &&
                        t.quotes != 'double' &&
                        (t.quotes = 'single');
                for (
                    var i = t.quotes == 'double' ? '"' : "'",
                        n = t.isIdentifier,
                        s = e.charAt(0),
                        a = '',
                        o = 0,
                        u = e.length;
                    o < u;

                ) {
                    var c = e.charAt(o++),
                        f = c.charCodeAt(),
                        p = void 0;
                    if (f < 32 || f > 126) {
                        if (f >= 55296 && f <= 56319 && o < u) {
                            var h = e.charCodeAt(o++);
                            (h & 64512) == 56320
                                ? (f = ((f & 1023) << 10) + (h & 1023) + 65536)
                                : o--;
                        }
                        p = '\\' + f.toString(16).toUpperCase() + ' ';
                    } else
                        t.escapeEverything
                            ? Pb.test(c)
                                ? (p = '\\' + c)
                                : (p =
                                      '\\' + f.toString(16).toUpperCase() + ' ')
                            : /[\t\n\f\r\x0B]/.test(c)
                            ? (p = '\\' + f.toString(16).toUpperCase() + ' ')
                            : c == '\\' ||
                              (!n &&
                                  ((c == '"' && i == c) ||
                                      (c == "'" && i == c))) ||
                              (n && Db.test(c))
                            ? (p = '\\' + c)
                            : (p = c);
                    a += p;
                }
                return (
                    n &&
                        (/^-[-\d]/.test(a)
                            ? (a = '\\-' + a.slice(1))
                            : /\d/.test(s) &&
                              (a = '\\3' + s + ' ' + a.slice(1))),
                    (a = a.replace(qb, function (d, y, k) {
                        return y && y.length % 2 ? d : (y || '') + k;
                    })),
                    !n && t.wrap ? i + a + i : a
                );
            };
        Qn.options = {
            escapeEverything: !1,
            isIdentifier: !1,
            quotes: 'single',
            wrap: !1,
        };
        Qn.version = '3.0.0';
        wu.exports = Qn;
    });
    var Xn = v((ar, xu) => {
        l();
        ('use strict');
        ar.__esModule = !0;
        ar.default = void 0;
        var Ib = bu(yi()),
            Rb = tr(),
            Mb = bu(Le()),
            Fb = te();
        function bu(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function vu(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function Nb(r, e, t) {
            return e && vu(r.prototype, e), t && vu(r, t), r;
        }
        function Lb(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                Jn(r, e);
        }
        function Jn(r, e) {
            return (
                (Jn =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                Jn(r, e)
            );
        }
        var Bb = (function (r) {
            Lb(e, r);
            function e(i) {
                var n;
                return (
                    (n = r.call(this, i) || this),
                    (n.type = Fb.CLASS),
                    (n._constructed = !0),
                    n
                );
            }
            var t = e.prototype;
            return (
                (t.valueToString = function () {
                    return '.' + r.prototype.valueToString.call(this);
                }),
                Nb(e, [
                    {
                        key: 'value',
                        get: function () {
                            return this._value;
                        },
                        set: function (n) {
                            if (this._constructed) {
                                var s = (0, Ib.default)(n, {
                                    isIdentifier: !0,
                                });
                                s !== n
                                    ? ((0, Rb.ensureObject)(this, 'raws'),
                                      (this.raws.value = s))
                                    : this.raws && delete this.raws.value;
                            }
                            this._value = n;
                        },
                    },
                ]),
                e
            );
        })(Mb.default);
        ar.default = Bb;
        xu.exports = ar.default;
    });
    var Zn = v((or, ku) => {
        l();
        ('use strict');
        or.__esModule = !0;
        or.default = void 0;
        var $b = jb(Le()),
            zb = te();
        function jb(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function Vb(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                Kn(r, e);
        }
        function Kn(r, e) {
            return (
                (Kn =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                Kn(r, e)
            );
        }
        var Ub = (function (r) {
            Vb(e, r);
            function e(t) {
                var i;
                return (i = r.call(this, t) || this), (i.type = zb.COMMENT), i;
            }
            return e;
        })($b.default);
        or.default = Ub;
        ku.exports = or.default;
    });
    var ts = v((lr, Su) => {
        l();
        ('use strict');
        lr.__esModule = !0;
        lr.default = void 0;
        var Wb = Hb(Le()),
            Gb = te();
        function Hb(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function Yb(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                es(r, e);
        }
        function es(r, e) {
            return (
                (es =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                es(r, e)
            );
        }
        var Qb = (function (r) {
            Yb(e, r);
            function e(i) {
                var n;
                return (n = r.call(this, i) || this), (n.type = Gb.ID), n;
            }
            var t = e.prototype;
            return (
                (t.valueToString = function () {
                    return '#' + r.prototype.valueToString.call(this);
                }),
                e
            );
        })(Wb.default);
        lr.default = Qb;
        Su.exports = lr.default;
    });
    var wi = v((ur, Au) => {
        l();
        ('use strict');
        ur.__esModule = !0;
        ur.default = void 0;
        var Jb = Cu(yi()),
            Xb = tr(),
            Kb = Cu(Le());
        function Cu(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function _u(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function Zb(r, e, t) {
            return e && _u(r.prototype, e), t && _u(r, t), r;
        }
        function e0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                rs(r, e);
        }
        function rs(r, e) {
            return (
                (rs =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                rs(r, e)
            );
        }
        var t0 = (function (r) {
            e0(e, r);
            function e() {
                return r.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(
                        r.prototype.valueToString.call(this)
                    );
                }),
                Zb(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 s = (0, Jb.default)(n, { isIdentifier: !0 });
                            (this._namespace = n),
                                s !== n
                                    ? ((0, Xb.ensureObject)(this, 'raws'),
                                      (this.raws.namespace = s))
                                    : 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
            );
        })(Kb.default);
        ur.default = t0;
        Au.exports = ur.default;
    });
    var ns = v((fr, Ou) => {
        l();
        ('use strict');
        fr.__esModule = !0;
        fr.default = void 0;
        var r0 = n0(wi()),
            i0 = te();
        function n0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function s0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                is(r, e);
        }
        function is(r, e) {
            return (
                (is =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                is(r, e)
            );
        }
        var a0 = (function (r) {
            s0(e, r);
            function e(t) {
                var i;
                return (i = r.call(this, t) || this), (i.type = i0.TAG), i;
            }
            return e;
        })(r0.default);
        fr.default = a0;
        Ou.exports = fr.default;
    });
    var as = v((cr, Eu) => {
        l();
        ('use strict');
        cr.__esModule = !0;
        cr.default = void 0;
        var o0 = u0(Le()),
            l0 = te();
        function u0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function f0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                ss(r, e);
        }
        function ss(r, e) {
            return (
                (ss =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                ss(r, e)
            );
        }
        var c0 = (function (r) {
            f0(e, r);
            function e(t) {
                var i;
                return (i = r.call(this, t) || this), (i.type = l0.STRING), i;
            }
            return e;
        })(o0.default);
        cr.default = c0;
        Eu.exports = cr.default;
    });
    var ls = v((pr, Tu) => {
        l();
        ('use strict');
        pr.__esModule = !0;
        pr.default = void 0;
        var p0 = h0(gi()),
            d0 = te();
        function h0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function m0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                os(r, e);
        }
        function os(r, e) {
            return (
                (os =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                os(r, e)
            );
        }
        var g0 = (function (r) {
            m0(e, r);
            function e(i) {
                var n;
                return (n = r.call(this, i) || this), (n.type = d0.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
            );
        })(p0.default);
        pr.default = g0;
        Tu.exports = pr.default;
    });
    var Pu = {};
    Ce(Pu, { deprecate: () => y0 });
    function y0(r) {
        return r;
    }
    var Du = A(() => {
        l();
    });
    var Iu = v((YO, qu) => {
        l();
        qu.exports = (Du(), Pu).deprecate;
    });
    var hs = v(mr => {
        l();
        ('use strict');
        mr.__esModule = !0;
        mr.unescapeValue = ps;
        mr.default = void 0;
        var dr = fs(yi()),
            w0 = fs(ci()),
            b0 = fs(wi()),
            v0 = te(),
            us;
        function fs(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function Ru(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function x0(r, e, t) {
            return e && Ru(r.prototype, e), t && Ru(r, t), r;
        }
        function k0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                cs(r, e);
        }
        function cs(r, e) {
            return (
                (cs =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                cs(r, e)
            );
        }
        var hr = Iu(),
            S0 = /^('|")([^]*)\1$/,
            C0 = hr(function () {},
            'Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.'),
            _0 = hr(function () {},
            'Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.'),
            A0 = hr(function () {},
            'Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.');
        function ps(r) {
            var e = !1,
                t = null,
                i = r,
                n = i.match(S0);
            return (
                n && ((t = n[1]), (i = n[2])),
                (i = (0, w0.default)(i)),
                i !== r && (e = !0),
                { deprecatedUsage: e, unescaped: i, quoteMark: t }
            );
        }
        function O0(r) {
            if (r.quoteMark !== void 0 || r.value === void 0) return r;
            A0();
            var e = ps(r.value),
                t = e.quoteMark,
                i = e.unescaped;
            return (
                r.raws || (r.raws = {}),
                r.raws.value === void 0 && (r.raws.value = r.value),
                (r.value = i),
                (r.quoteMark = t),
                r
            );
        }
        var bi = (function (r) {
            k0(e, r);
            function e(i) {
                var n;
                return (
                    i === void 0 && (i = {}),
                    (n = r.call(this, O0(i)) || this),
                    (n.type = v0.ATTRIBUTE),
                    (n.raws = n.raws || {}),
                    Object.defineProperty(n.raws, 'unquoted', {
                        get: hr(function () {
                            return n.value;
                        }, 'attr.raws.unquoted is deprecated. Call attr.value instead.'),
                        set: hr(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 s = this._determineQuoteMark(n),
                        a = ds[s],
                        o = (0, dr.default)(this._value, a);
                    return o;
                }),
                (t._determineQuoteMark = function (n) {
                    return n.smart
                        ? this.smartQuoteMark(n)
                        : this.preferredQuoteMark(n);
                }),
                (t.setValue = function (n, s) {
                    s === void 0 && (s = {}),
                        (this._value = n),
                        (this._quoteMark = this._determineQuoteMark(s)),
                        this._syncRawValue();
                }),
                (t.smartQuoteMark = function (n) {
                    var s = this.value,
                        a = s.replace(/[^']/g, '').length,
                        o = s.replace(/[^"]/g, '').length;
                    if (a + o === 0) {
                        var u = (0, dr.default)(s, { isIdentifier: !0 });
                        if (u === s) return e.NO_QUOTE;
                        var c = this.preferredQuoteMark(n);
                        if (c === e.NO_QUOTE) {
                            var f =
                                    this.quoteMark ||
                                    n.quoteMark ||
                                    e.DOUBLE_QUOTE,
                                p = ds[f],
                                h = (0, dr.default)(s, p);
                            if (h.length < u.length) return f;
                        }
                        return c;
                    } else
                        return o === a
                            ? this.preferredQuoteMark(n)
                            : o < a
                            ? e.DOUBLE_QUOTE
                            : e.SINGLE_QUOTE;
                }),
                (t.preferredQuoteMark = function (n) {
                    var s = n.preferCurrentQuoteMark
                        ? this.quoteMark
                        : n.quoteMark;
                    return (
                        s === void 0 &&
                            (s = n.preferCurrentQuoteMark
                                ? n.quoteMark
                                : this.quoteMark),
                        s === void 0 && (s = e.DOUBLE_QUOTE),
                        s
                    );
                }),
                (t._syncRawValue = function () {
                    var n = (0, dr.default)(this._value, ds[this.quoteMark]);
                    n === this._value
                        ? this.raws && delete this.raws.value
                        : (this.raws.value = n);
                }),
                (t._handleEscapes = function (n, s) {
                    if (this._constructed) {
                        var a = (0, dr.default)(s, { isIdentifier: !0 });
                        a !== s ? (this.raws[n] = a) : delete this.raws[n];
                    }
                }),
                (t._spacesFor = function (n) {
                    var s = { before: '', after: '' },
                        a = this.spaces[n] || {},
                        o = (this.raws.spaces && this.raws.spaces[n]) || {};
                    return Object.assign(s, a, o);
                }),
                (t._stringFor = function (n, s, a) {
                    s === void 0 && (s = n), a === void 0 && (a = Mu);
                    var o = this._spacesFor(s);
                    return a(this.stringifyProperty(n), o);
                }),
                (t.offsetOf = function (n) {
                    var s = 1,
                        a = this._spacesFor('attribute');
                    if (
                        ((s += a.before.length),
                        n === 'namespace' || n === 'ns')
                    )
                        return this.namespace ? s : -1;
                    if (
                        n === 'attributeNS' ||
                        ((s += this.namespaceString.length),
                        this.namespace && (s += 1),
                        n === 'attribute')
                    )
                        return s;
                    (s += this.stringifyProperty('attribute').length),
                        (s += a.after.length);
                    var o = this._spacesFor('operator');
                    s += o.before.length;
                    var u = this.stringifyProperty('operator');
                    if (n === 'operator') return u ? s : -1;
                    (s += u.length), (s += o.after.length);
                    var c = this._spacesFor('value');
                    s += c.before.length;
                    var f = this.stringifyProperty('value');
                    if (n === 'value') return f ? s : -1;
                    (s += f.length), (s += c.after.length);
                    var p = this._spacesFor('insensitive');
                    return (
                        (s += p.before.length),
                        n === 'insensitive' && this.insensitive ? s : -1
                    );
                }),
                (t.toString = function () {
                    var n = this,
                        s = [this.rawSpaceBefore, '['];
                    return (
                        s.push(
                            this._stringFor('qualifiedAttribute', 'attribute')
                        ),
                        this.operator &&
                            (this.value || this.value === '') &&
                            (s.push(this._stringFor('operator')),
                            s.push(this._stringFor('value')),
                            s.push(
                                this._stringFor(
                                    'insensitiveFlag',
                                    'insensitive',
                                    function (a, o) {
                                        return (
                                            a.length > 0 &&
                                                !n.quoted &&
                                                o.before.length === 0 &&
                                                !(
                                                    n.spaces.value &&
                                                    n.spaces.value.after
                                                ) &&
                                                (o.before = ' '),
                                            Mu(a, o)
                                        );
                                    }
                                )
                            )),
                        s.push(']'),
                        s.push(this.rawSpaceAfter),
                        s.join('')
                    );
                }),
                x0(e, [
                    {
                        key: 'quoted',
                        get: function () {
                            var n = this.quoteMark;
                            return n === "'" || n === '"';
                        },
                        set: function (n) {
                            _0();
                        },
                    },
                    {
                        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 s = ps(n),
                                    a = s.deprecatedUsage,
                                    o = s.unescaped,
                                    u = s.quoteMark;
                                if (
                                    (a && C0(),
                                    o === this._value && u === this._quoteMark)
                                )
                                    return;
                                (this._value = o),
                                    (this._quoteMark = u),
                                    this._syncRawValue();
                            } else this._value = n;
                        },
                    },
                    {
                        key: 'attribute',
                        get: function () {
                            return this._attribute;
                        },
                        set: function (n) {
                            this._handleEscapes('attribute', n),
                                (this._attribute = n);
                        },
                    },
                ]),
                e
            );
        })(b0.default);
        mr.default = bi;
        bi.NO_QUOTE = null;
        bi.SINGLE_QUOTE = "'";
        bi.DOUBLE_QUOTE = '"';
        var ds =
            ((us = {
                "'": { quotes: 'single', wrap: !0 },
                '"': { quotes: 'double', wrap: !0 },
            }),
            (us[null] = { isIdentifier: !0 }),
            us);
        function Mu(r, e) {
            return '' + e.before + r + e.after;
        }
    });
    var gs = v((gr, Fu) => {
        l();
        ('use strict');
        gr.__esModule = !0;
        gr.default = void 0;
        var E0 = P0(wi()),
            T0 = te();
        function P0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function D0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                ms(r, e);
        }
        function ms(r, e) {
            return (
                (ms =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                ms(r, e)
            );
        }
        var q0 = (function (r) {
            D0(e, r);
            function e(t) {
                var i;
                return (
                    (i = r.call(this, t) || this),
                    (i.type = T0.UNIVERSAL),
                    (i.value = '*'),
                    i
                );
            }
            return e;
        })(E0.default);
        gr.default = q0;
        Fu.exports = gr.default;
    });
    var ws = v((yr, Nu) => {
        l();
        ('use strict');
        yr.__esModule = !0;
        yr.default = void 0;
        var I0 = M0(Le()),
            R0 = te();
        function M0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function F0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                ys(r, e);
        }
        function ys(r, e) {
            return (
                (ys =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                ys(r, e)
            );
        }
        var N0 = (function (r) {
            F0(e, r);
            function e(t) {
                var i;
                return (
                    (i = r.call(this, t) || this), (i.type = R0.COMBINATOR), i
                );
            }
            return e;
        })(I0.default);
        yr.default = N0;
        Nu.exports = yr.default;
    });
    var vs = v((wr, Lu) => {
        l();
        ('use strict');
        wr.__esModule = !0;
        wr.default = void 0;
        var L0 = $0(Le()),
            B0 = te();
        function $0(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function z0(r, e) {
            (r.prototype = Object.create(e.prototype)),
                (r.prototype.constructor = r),
                bs(r, e);
        }
        function bs(r, e) {
            return (
                (bs =
                    Object.setPrototypeOf ||
                    function (i, n) {
                        return (i.__proto__ = n), i;
                    }),
                bs(r, e)
            );
        }
        var j0 = (function (r) {
            z0(e, r);
            function e(t) {
                var i;
                return (
                    (i = r.call(this, t) || this),
                    (i.type = B0.NESTING),
                    (i.value = '&'),
                    i
                );
            }
            return e;
        })(L0.default);
        wr.default = j0;
        Lu.exports = wr.default;
    });
    var $u = v((vi, Bu) => {
        l();
        ('use strict');
        vi.__esModule = !0;
        vi.default = V0;
        function V0(r) {
            return r.sort(function (e, t) {
                return e - t;
            });
        }
        Bu.exports = vi.default;
    });
    var xs = v(P => {
        l();
        ('use strict');
        P.__esModule = !0;
        P.combinator =
            P.word =
            P.comment =
            P.str =
            P.tab =
            P.newline =
            P.feed =
            P.cr =
            P.backslash =
            P.bang =
            P.slash =
            P.doubleQuote =
            P.singleQuote =
            P.space =
            P.greaterThan =
            P.pipe =
            P.equals =
            P.plus =
            P.caret =
            P.tilde =
            P.dollar =
            P.closeSquare =
            P.openSquare =
            P.closeParenthesis =
            P.openParenthesis =
            P.semicolon =
            P.colon =
            P.comma =
            P.at =
            P.asterisk =
            P.ampersand =
                void 0;
        var U0 = 38;
        P.ampersand = U0;
        var W0 = 42;
        P.asterisk = W0;
        var G0 = 64;
        P.at = G0;
        var H0 = 44;
        P.comma = H0;
        var Y0 = 58;
        P.colon = Y0;
        var Q0 = 59;
        P.semicolon = Q0;
        var J0 = 40;
        P.openParenthesis = J0;
        var X0 = 41;
        P.closeParenthesis = X0;
        var K0 = 91;
        P.openSquare = K0;
        var Z0 = 93;
        P.closeSquare = Z0;
        var ev = 36;
        P.dollar = ev;
        var tv = 126;
        P.tilde = tv;
        var rv = 94;
        P.caret = rv;
        var iv = 43;
        P.plus = iv;
        var nv = 61;
        P.equals = nv;
        var sv = 124;
        P.pipe = sv;
        var av = 62;
        P.greaterThan = av;
        var ov = 32;
        P.space = ov;
        var zu = 39;
        P.singleQuote = zu;
        var lv = 34;
        P.doubleQuote = lv;
        var uv = 47;
        P.slash = uv;
        var fv = 33;
        P.bang = fv;
        var cv = 92;
        P.backslash = cv;
        var pv = 13;
        P.cr = pv;
        var dv = 12;
        P.feed = dv;
        var hv = 10;
        P.newline = hv;
        var mv = 9;
        P.tab = mv;
        var gv = zu;
        P.str = gv;
        var yv = -1;
        P.comment = yv;
        var wv = -2;
        P.word = wv;
        var bv = -3;
        P.combinator = bv;
    });
    var Uu = v(br => {
        l();
        ('use strict');
        br.__esModule = !0;
        br.default = Av;
        br.FIELDS = void 0;
        var O = vv(xs()),
            bt,
            V;
        function ju() {
            if (typeof WeakMap != 'function') return null;
            var r = new WeakMap();
            return (
                (ju = function () {
                    return r;
                }),
                r
            );
        }
        function vv(r) {
            if (r && r.__esModule) return r;
            if (r === null || (typeof r != 'object' && typeof r != 'function'))
                return { default: r };
            var e = ju();
            if (e && e.has(r)) return e.get(r);
            var t = {},
                i = Object.defineProperty && Object.getOwnPropertyDescriptor;
            for (var n in r)
                if (Object.prototype.hasOwnProperty.call(r, n)) {
                    var s = i ? Object.getOwnPropertyDescriptor(r, n) : null;
                    s && (s.get || s.set)
                        ? Object.defineProperty(t, n, s)
                        : (t[n] = r[n]);
                }
            return (t.default = r), e && e.set(r, t), t;
        }
        var xv =
                ((bt = {}),
                (bt[O.tab] = !0),
                (bt[O.newline] = !0),
                (bt[O.cr] = !0),
                (bt[O.feed] = !0),
                bt),
            kv =
                ((V = {}),
                (V[O.space] = !0),
                (V[O.tab] = !0),
                (V[O.newline] = !0),
                (V[O.cr] = !0),
                (V[O.feed] = !0),
                (V[O.ampersand] = !0),
                (V[O.asterisk] = !0),
                (V[O.bang] = !0),
                (V[O.comma] = !0),
                (V[O.colon] = !0),
                (V[O.semicolon] = !0),
                (V[O.openParenthesis] = !0),
                (V[O.closeParenthesis] = !0),
                (V[O.openSquare] = !0),
                (V[O.closeSquare] = !0),
                (V[O.singleQuote] = !0),
                (V[O.doubleQuote] = !0),
                (V[O.plus] = !0),
                (V[O.pipe] = !0),
                (V[O.tilde] = !0),
                (V[O.greaterThan] = !0),
                (V[O.equals] = !0),
                (V[O.dollar] = !0),
                (V[O.caret] = !0),
                (V[O.slash] = !0),
                V),
            ks = {},
            Vu = '0123456789abcdefABCDEF';
        for (xi = 0; xi < Vu.length; xi++) ks[Vu.charCodeAt(xi)] = !0;
        var xi;
        function Sv(r, e) {
            var t = e,
                i;
            do {
                if (((i = r.charCodeAt(t)), kv[i])) return t - 1;
                i === O.backslash ? (t = Cv(r, t) + 1) : t++;
            } while (t < r.length);
            return t - 1;
        }
        function Cv(r, e) {
            var t = e,
                i = r.charCodeAt(t + 1);
            if (!xv[i])
                if (ks[i]) {
                    var n = 0;
                    do t++, n++, (i = r.charCodeAt(t + 1));
                    while (ks[i] && n < 6);
                    n < 6 && i === O.space && t++;
                } else t++;
            return t;
        }
        var _v = {
            TYPE: 0,
            START_LINE: 1,
            START_COL: 2,
            END_LINE: 3,
            END_COL: 4,
            START_POS: 5,
            END_POS: 6,
        };
        br.FIELDS = _v;
        function Av(r) {
            var e = [],
                t = r.css.valueOf(),
                i = t,
                n = i.length,
                s = -1,
                a = 1,
                o = 0,
                u = 0,
                c,
                f,
                p,
                h,
                d,
                y,
                k,
                w,
                b,
                x,
                S,
                _,
                D;
            function M(B, q) {
                if (r.safe) (t += q), (b = t.length - 1);
                else throw r.error('Unclosed ' + B, a, o - s, o);
            }
            for (; o < n; ) {
                switch (
                    ((c = t.charCodeAt(o)),
                    c === O.newline && ((s = o), (a += 1)),
                    c)
                ) {
                    case O.space:
                    case O.tab:
                    case O.newline:
                    case O.cr:
                    case O.feed:
                        b = o;
                        do
                            (b += 1),
                                (c = t.charCodeAt(b)),
                                c === O.newline && ((s = b), (a += 1));
                        while (
                            c === O.space ||
                            c === O.newline ||
                            c === O.tab ||
                            c === O.cr ||
                            c === O.feed
                        );
                        (D = O.space), (h = a), (p = b - s - 1), (u = b);
                        break;
                    case O.plus:
                    case O.greaterThan:
                    case O.tilde:
                    case O.pipe:
                        b = o;
                        do (b += 1), (c = t.charCodeAt(b));
                        while (
                            c === O.plus ||
                            c === O.greaterThan ||
                            c === O.tilde ||
                            c === O.pipe
                        );
                        (D = O.combinator), (h = a), (p = o - s), (u = b);
                        break;
                    case O.asterisk:
                    case O.ampersand:
                    case O.bang:
                    case O.comma:
                    case O.equals:
                    case O.dollar:
                    case O.caret:
                    case O.openSquare:
                    case O.closeSquare:
                    case O.colon:
                    case O.semicolon:
                    case O.openParenthesis:
                    case O.closeParenthesis:
                        (b = o), (D = c), (h = a), (p = o - s), (u = b + 1);
                        break;
                    case O.singleQuote:
                    case O.doubleQuote:
                        (_ = c === O.singleQuote ? "'" : '"'), (b = o);
                        do
                            for (
                                d = !1,
                                    b = t.indexOf(_, b + 1),
                                    b === -1 && M('quote', _),
                                    y = b;
                                t.charCodeAt(y - 1) === O.backslash;

                            )
                                (y -= 1), (d = !d);
                        while (d);
                        (D = O.str), (h = a), (p = o - s), (u = b + 1);
                        break;
                    default:
                        c === O.slash && t.charCodeAt(o + 1) === O.asterisk
                            ? ((b = t.indexOf('*/', o + 2) + 1),
                              b === 0 && M('comment', '*/'),
                              (f = t.slice(o, b + 1)),
                              (w = f.split(`
`)),
                              (k = w.length - 1),
                              k > 0
                                  ? ((x = a + k), (S = b - w[k].length))
                                  : ((x = a), (S = s)),
                              (D = O.comment),
                              (a = x),
                              (h = x),
                              (p = b - S))
                            : c === O.slash
                            ? ((b = o),
                              (D = c),
                              (h = a),
                              (p = o - s),
                              (u = b + 1))
                            : ((b = Sv(t, o)),
                              (D = O.word),
                              (h = a),
                              (p = b - s)),
                            (u = b + 1);
                        break;
                }
                e.push([D, a, o - s, h, p, o, u]),
                    S && ((s = S), (S = null)),
                    (o = u);
            }
            return e;
        }
    });
    var Ku = v((vr, Xu) => {
        l();
        ('use strict');
        vr.__esModule = !0;
        vr.default = void 0;
        var Ov = ge(Gn()),
            Ss = ge(Yn()),
            Ev = ge(Xn()),
            Wu = ge(Zn()),
            Tv = ge(ts()),
            Pv = ge(ns()),
            Cs = ge(as()),
            Dv = ge(ls()),
            Gu = ki(hs()),
            qv = ge(gs()),
            _s = ge(ws()),
            Iv = ge(vs()),
            Rv = ge($u()),
            C = ki(Uu()),
            E = ki(xs()),
            Mv = ki(te()),
            Y = tr(),
            ft,
            As;
        function Hu() {
            if (typeof WeakMap != 'function') return null;
            var r = new WeakMap();
            return (
                (Hu = function () {
                    return r;
                }),
                r
            );
        }
        function ki(r) {
            if (r && r.__esModule) return r;
            if (r === null || (typeof r != 'object' && typeof r != 'function'))
                return { default: r };
            var e = Hu();
            if (e && e.has(r)) return e.get(r);
            var t = {},
                i = Object.defineProperty && Object.getOwnPropertyDescriptor;
            for (var n in r)
                if (Object.prototype.hasOwnProperty.call(r, n)) {
                    var s = i ? Object.getOwnPropertyDescriptor(r, n) : null;
                    s && (s.get || s.set)
                        ? Object.defineProperty(t, n, s)
                        : (t[n] = r[n]);
                }
            return (t.default = r), e && e.set(r, t), t;
        }
        function ge(r) {
            return r && r.__esModule ? r : { default: r };
        }
        function Yu(r, e) {
            for (var t = 0; t < e.length; t++) {
                var i = e[t];
                (i.enumerable = i.enumerable || !1),
                    (i.configurable = !0),
                    'value' in i && (i.writable = !0),
                    Object.defineProperty(r, i.key, i);
            }
        }
        function Fv(r, e, t) {
            return e && Yu(r.prototype, e), t && Yu(r, t), r;
        }
        var Os =
                ((ft = {}),
                (ft[E.space] = !0),
                (ft[E.cr] = !0),
                (ft[E.feed] = !0),
                (ft[E.newline] = !0),
                (ft[E.tab] = !0),
                ft),
            Nv = Object.assign({}, Os, ((As = {}), (As[E.comment] = !0), As));
        function Qu(r) {
            return {
                line: r[C.FIELDS.START_LINE],
                column: r[C.FIELDS.START_COL],
            };
        }
        function Ju(r) {
            return { line: r[C.FIELDS.END_LINE], column: r[C.FIELDS.END_COL] };
        }
        function ct(r, e, t, i) {
            return {
                start: { line: r, column: e },
                end: { line: t, column: i },
            };
        }
        function vt(r) {
            return ct(
                r[C.FIELDS.START_LINE],
                r[C.FIELDS.START_COL],
                r[C.FIELDS.END_LINE],
                r[C.FIELDS.END_COL]
            );
        }
        function Es(r, e) {
            if (!!r)
                return ct(
                    r[C.FIELDS.START_LINE],
                    r[C.FIELDS.START_COL],
                    e[C.FIELDS.END_LINE],
                    e[C.FIELDS.END_COL]
                );
        }
        function xt(r, e) {
            var t = r[e];
            if (typeof t == 'string')
                return (
                    t.indexOf('\\') !== -1 &&
                        ((0, Y.ensureObject)(r, 'raws'),
                        (r[e] = (0, Y.unesc)(t)),
                        r.raws[e] === void 0 && (r.raws[e] = t)),
                    r
                );
        }
        function Ts(r, e) {
            for (var t = -1, i = []; (t = r.indexOf(e, t + 1)) !== -1; )
                i.push(t);
            return i;
        }
        function Lv() {
            var r = Array.prototype.concat.apply([], arguments);
            return r.filter(function (e, t) {
                return t === r.indexOf(e);
            });
        }
        var Bv = (function () {
            function r(t, i) {
                i === void 0 && (i = {}),
                    (this.rule = t),
                    (this.options = Object.assign({ lossy: !1, safe: !1 }, i)),
                    (this.position = 0),
                    (this.css =
                        typeof this.rule == 'string'
                            ? this.rule
                            : this.rule.selector),
                    (this.tokens = (0, C.default)({
                        css: this.css,
                        error: this._errorGenerator(),
                        safe: this.options.safe,
                    }));
                var n = Es(this.tokens[0], this.tokens[this.tokens.length - 1]);
                (this.root = new Ov.default({ source: n })),
                    (this.root.errorGenerator = this._errorGenerator());
                var s = new Ss.default({
                    source: { start: { line: 1, column: 1 } },
                });
                this.root.append(s), (this.current = s), this.loop();
            }
            var e = r.prototype;
            return (
                (e._errorGenerator = function () {
                    var i = this;
                    return function (n, s) {
                        return typeof i.rule == 'string'
                            ? new Error(n)
                            : i.rule.error(n, s);
                    };
                }),
                (e.attribute = function () {
                    var i = [],
                        n = this.currToken;
                    for (
                        this.position++;
                        this.position < this.tokens.length &&
                        this.currToken[C.FIELDS.TYPE] !== E.closeSquare;

                    )
                        i.push(this.currToken), this.position++;
                    if (this.currToken[C.FIELDS.TYPE] !== E.closeSquare)
                        return this.expected(
                            'closing square bracket',
                            this.currToken[C.FIELDS.START_POS]
                        );
                    var s = i.length,
                        a = {
                            source: ct(
                                n[1],
                                n[2],
                                this.currToken[3],
                                this.currToken[4]
                            ),
                            sourceIndex: n[C.FIELDS.START_POS],
                        };
                    if (s === 1 && !~[E.word].indexOf(i[0][C.FIELDS.TYPE]))
                        return this.expected(
                            'attribute',
                            i[0][C.FIELDS.START_POS]
                        );
                    for (var o = 0, u = '', c = '', f = null, p = !1; o < s; ) {
                        var h = i[o],
                            d = this.content(h),
                            y = i[o + 1];
                        switch (h[C.FIELDS.TYPE]) {
                            case E.space:
                                if (((p = !0), this.options.lossy)) break;
                                if (f) {
                                    (0, Y.ensureObject)(a, 'spaces', f);
                                    var k = a.spaces[f].after || '';
                                    a.spaces[f].after = k + d;
                                    var w =
                                        (0, Y.getProp)(
                                            a,
                                            'raws',
                                            'spaces',
                                            f,
                                            'after'
                                        ) || null;
                                    w && (a.raws.spaces[f].after = w + d);
                                } else (u = u + d), (c = c + d);
                                break;
                            case E.asterisk:
                                if (y[C.FIELDS.TYPE] === E.equals)
                                    (a.operator = d), (f = 'operator');
                                else if (
                                    (!a.namespace ||
                                        (f === 'namespace' && !p)) &&
                                    y
                                ) {
                                    u &&
                                        ((0, Y.ensureObject)(
                                            a,
                                            'spaces',
                                            'attribute'
                                        ),
                                        (a.spaces.attribute.before = u),
                                        (u = '')),
                                        c &&
                                            ((0, Y.ensureObject)(
                                                a,
                                                'raws',
                                                'spaces',
                                                'attribute'
                                            ),
                                            (a.raws.spaces.attribute.before =
                                                u),
                                            (c = '')),
                                        (a.namespace = (a.namespace || '') + d);
                                    var b =
                                        (0, Y.getProp)(
                                            a,
                                            'raws',
                                            'namespace'
                                        ) || null;
                                    b && (a.raws.namespace += d),
                                        (f = 'namespace');
                                }
                                p = !1;
                                break;
                            case E.dollar:
                                if (f === 'value') {
                                    var x = (0, Y.getProp)(a, 'raws', 'value');
                                    (a.value += '$'),
                                        x && (a.raws.value = x + '$');
                                    break;
                                }
                            case E.caret:
                                y[C.FIELDS.TYPE] === E.equals &&
                                    ((a.operator = d), (f = 'operator')),
                                    (p = !1);
                                break;
                            case E.combinator:
                                if (
                                    (d === '~' &&
                                        y[C.FIELDS.TYPE] === E.equals &&
                                        ((a.operator = d), (f = 'operator')),
                                    d !== '|')
                                ) {
                                    p = !1;
                                    break;
                                }
                                y[C.FIELDS.TYPE] === E.equals
                                    ? ((a.operator = d), (f = 'operator'))
                                    : !a.namespace &&
                                      !a.attribute &&
                                      (a.namespace = !0),
                                    (p = !1);
                                break;
                            case E.word:
                                if (
                                    y &&
                                    this.content(y) === '|' &&
                                    i[o + 2] &&
                                    i[o + 2][C.FIELDS.TYPE] !== E.equals &&
                                    !a.operator &&
                                    !a.namespace
                                )
                                    (a.namespace = d), (f = 'namespace');
                                else if (
                                    !a.attribute ||
                                    (f === 'attribute' && !p)
                                ) {
                                    u &&
                                        ((0, Y.ensureObject)(
                                            a,
                                            'spaces',
                                            'attribute'
                                        ),
                                        (a.spaces.attribute.before = u),
                                        (u = '')),
                                        c &&
                                            ((0, Y.ensureObject)(
                                                a,
                                                'raws',
                                                'spaces',
                                                'attribute'
                                            ),
                                            (a.raws.spaces.attribute.before =
                                                c),
                                            (c = '')),
                                        (a.attribute = (a.attribute || '') + d);
                                    var S =
                                        (0, Y.getProp)(
                                            a,
                                            'raws',
                                            'attribute'
                                        ) || null;
                                    S && (a.raws.attribute += d),
                                        (f = 'attribute');
                                } else if (
                                    (!a.value && a.value !== '') ||
                                    (f === 'value' && !p)
                                ) {
                                    var _ = (0, Y.unesc)(d),
                                        D =
                                            (0, Y.getProp)(
                                                a,
                                                'raws',
                                                'value'
                                            ) || '',
                                        M = a.value || '';
                                    (a.value = M + _),
                                        (a.quoteMark = null),
                                        (_ !== d || D) &&
                                            ((0, Y.ensureObject)(a, 'raws'),
                                            (a.raws.value = (D || M) + d)),
                                        (f = 'value');
                                } else {
                                    var B = d === 'i' || d === 'I';
                                    (a.value || a.value === '') &&
                                    (a.quoteMark || p)
                                        ? ((a.insensitive = B),
                                          (!B || d === 'I') &&
                                              ((0, Y.ensureObject)(a, 'raws'),
                                              (a.raws.insensitiveFlag = d)),
                                          (f = 'insensitive'),
                                          u &&
                                              ((0, Y.ensureObject)(
                                                  a,
                                                  'spaces',
                                                  'insensitive'
                                              ),
                                              (a.spaces.insensitive.before = u),
                                              (u = '')),
                                          c &&
                                              ((0, Y.ensureObject)(
                                                  a,
                                                  'raws',
                                                  'spaces',
                                                  'insensitive'
                                              ),
                                              (a.raws.spaces.insensitive.before =
                                                  c),
                                              (c = '')))
                                        : (a.value || a.value === '') &&
                                          ((f = 'value'),
                                          (a.value += d),
                                          a.raws.value && (a.raws.value += d));
                                }
                                p = !1;
                                break;
                            case E.str:
                                if (!a.attribute || !a.operator)
                                    return this.error(
                                        'Expected an attribute followed by an operator preceding the string.',
                                        { index: h[C.FIELDS.START_POS] }
                                    );
                                var q = (0, Gu.unescapeValue)(d),
                                    F = q.unescaped,
                                    X = q.quoteMark;
                                (a.value = F),
                                    (a.quoteMark = X),
                                    (f = 'value'),
                                    (0, Y.ensureObject)(a, 'raws'),
                                    (a.raws.value = d),
                                    (p = !1);
                                break;
                            case E.equals:
                                if (!a.attribute)
                                    return this.expected(
                                        'attribute',
                                        h[C.FIELDS.START_POS],
                                        d
                                    );
                                if (a.value)
                                    return this.error(
                                        'Unexpected "=" found; an operator was already defined.',
                                        { index: h[C.FIELDS.START_POS] }
                                    );
                                (a.operator = a.operator ? a.operator + d : d),
                                    (f = 'operator'),
                                    (p = !1);
                                break;
                            case E.comment:
                                if (f)
                                    if (
                                        p ||
                                        (y && y[C.FIELDS.TYPE] === E.space) ||
                                        f === 'insensitive'
                                    ) {
                                        var ce =
                                                (0, Y.getProp)(
                                                    a,
                                                    'spaces',
                                                    f,
                                                    'after'
                                                ) || '',
                                            se =
                                                (0, Y.getProp)(
                                                    a,
                                                    'raws',
                                                    'spaces',
                                                    f,
                                                    'after'
                                                ) || ce;
                                        (0, Y.ensureObject)(
                                            a,
                                            'raws',
                                            'spaces',
                                            f
                                        ),
                                            (a.raws.spaces[f].after = se + d);
                                    } else {
                                        var re = a[f] || '',
                                            pe =
                                                (0, Y.getProp)(a, 'raws', f) ||
                                                re;
                                        (0, Y.ensureObject)(a, 'raws'),
                                            (a.raws[f] = pe + d);
                                    }
                                else c = c + d;
                                break;
                            default:
                                return this.error(
                                    'Unexpected "' + d + '" found.',
                                    { index: h[C.FIELDS.START_POS] }
                                );
                        }
                        o++;
                    }
                    xt(a, 'attribute'),
                        xt(a, 'namespace'),
                        this.newNode(new Gu.default(a)),
                        this.position++;
                }),
                (e.parseWhitespaceEquivalentTokens = function (i) {
                    i < 0 && (i = this.tokens.length);
                    var n = this.position,
                        s = [],
                        a = '',
                        o = void 0;
                    do
                        if (Os[this.currToken[C.FIELDS.TYPE]])
                            this.options.lossy || (a += this.content());
                        else if (this.currToken[C.FIELDS.TYPE] === E.comment) {
                            var u = {};
                            a && ((u.before = a), (a = '')),
                                (o = new Wu.default({
                                    value: this.content(),
                                    source: vt(this.currToken),
                                    sourceIndex:
                                        this.currToken[C.FIELDS.START_POS],
                                    spaces: u,
                                })),
                                s.push(o);
                        }
                    while (++this.position < i);
                    if (a) {
                        if (o) o.spaces.after = a;
                        else if (!this.options.lossy) {
                            var c = this.tokens[n],
                                f = this.tokens[this.position - 1];
                            s.push(
                                new Cs.default({
                                    value: '',
                                    source: ct(
                                        c[C.FIELDS.START_LINE],
                                        c[C.FIELDS.START_COL],
                                        f[C.FIELDS.END_LINE],
                                        f[C.FIELDS.END_COL]
                                    ),
                                    sourceIndex: c[C.FIELDS.START_POS],
                                    spaces: { before: a, after: '' },
                                })
                            );
                        }
                    }
                    return s;
                }),
                (e.convertWhitespaceNodesToSpace = function (i, n) {
                    var s = this;
                    n === void 0 && (n = !1);
                    var a = '',
                        o = '';
                    i.forEach(function (c) {
                        var f = s.lossySpace(c.spaces.before, n),
                            p = s.lossySpace(c.rawSpaceBefore, n);
                        (a +=
                            f +
                            s.lossySpace(c.spaces.after, n && f.length === 0)),
                            (o +=
                                f +
                                c.value +
                                s.lossySpace(
                                    c.rawSpaceAfter,
                                    n && p.length === 0
                                ));
                    }),
                        o === a && (o = void 0);
                    var u = { space: a, rawSpace: o };
                    return u;
                }),
                (e.isNamedCombinator = function (i) {
                    return (
                        i === void 0 && (i = this.position),
                        this.tokens[i + 0] &&
                            this.tokens[i + 0][C.FIELDS.TYPE] === E.slash &&
                            this.tokens[i + 1] &&
                            this.tokens[i + 1][C.FIELDS.TYPE] === E.word &&
                            this.tokens[i + 2] &&
                            this.tokens[i + 2][C.FIELDS.TYPE] === E.slash
                    );
                }),
                (e.namedCombinator = function () {
                    if (this.isNamedCombinator()) {
                        var i = this.content(this.tokens[this.position + 1]),
                            n = (0, Y.unesc)(i).toLowerCase(),
                            s = {};
                        n !== i && (s.value = '/' + i + '/');
                        var a = new _s.default({
                            value: '/' + n + '/',
                            source: ct(
                                this.currToken[C.FIELDS.START_LINE],
                                this.currToken[C.FIELDS.START_COL],
                                this.tokens[this.position + 2][
                                    C.FIELDS.END_LINE
                                ],
                                this.tokens[this.position + 2][C.FIELDS.END_COL]
                            ),
                            sourceIndex: this.currToken[C.FIELDS.START_POS],
                            raws: s,
                        });
                        return (this.position = this.position + 3), a;
                    } else this.unexpected();
                }),
                (e.combinator = function () {
                    var i = this;
                    if (this.content() === '|') return this.namespace();
                    var n = this.locateNextMeaningfulToken(this.position);
                    if (n < 0 || this.tokens[n][C.FIELDS.TYPE] === E.comma) {
                        var s = this.parseWhitespaceEquivalentTokens(n);
                        if (s.length > 0) {
                            var a = this.current.last;
                            if (a) {
                                var o = this.convertWhitespaceNodesToSpace(s),
                                    u = o.space,
                                    c = o.rawSpace;
                                c !== void 0 && (a.rawSpaceAfter += c),
                                    (a.spaces.after += u);
                            } else
                                s.forEach(function (D) {
                                    return i.newNode(D);
                                });
                        }
                        return;
                    }
                    var f = this.currToken,
                        p = void 0;
                    n > this.position &&
                        (p = this.parseWhitespaceEquivalentTokens(n));
                    var h;
                    if (
                        (this.isNamedCombinator()
                            ? (h = this.namedCombinator())
                            : this.currToken[C.FIELDS.TYPE] === E.combinator
                            ? ((h = new _s.default({
                                  value: this.content(),
                                  source: vt(this.currToken),
                                  sourceIndex:
                                      this.currToken[C.FIELDS.START_POS],
                              })),
                              this.position++)
                            : Os[this.currToken[C.FIELDS.TYPE]] ||
                              p ||
                              this.unexpected(),
                        h)
                    ) {
                        if (p) {
                            var d = this.convertWhitespaceNodesToSpace(p),
                                y = d.space,
                                k = d.rawSpace;
                            (h.spaces.before = y), (h.rawSpaceBefore = k);
                        }
                    } else {
                        var w = this.convertWhitespaceNodesToSpace(p, !0),
                            b = w.space,
                            x = w.rawSpace;
                        x || (x = b);
                        var S = {},
                            _ = { spaces: {} };
                        b.endsWith(' ') && x.endsWith(' ')
                            ? ((S.before = b.slice(0, b.length - 1)),
                              (_.spaces.before = x.slice(0, x.length - 1)))
                            : b.startsWith(' ') && x.startsWith(' ')
                            ? ((S.after = b.slice(1)),
                              (_.spaces.after = x.slice(1)))
                            : (_.value = x),
                            (h = new _s.default({
                                value: ' ',
                                source: Es(f, this.tokens[this.position - 1]),
                                sourceIndex: f[C.FIELDS.START_POS],
                                spaces: S,
                                raws: _,
                            }));
                    }
                    return (
                        this.currToken &&
                            this.currToken[C.FIELDS.TYPE] === E.space &&
                            ((h.spaces.after = this.optionalSpace(
                                this.content()
                            )),
                            this.position++),
                        this.newNode(h)
                    );
                }),
                (e.comma = function () {
                    if (this.position === this.tokens.length - 1) {
                        (this.root.trailingComma = !0), this.position++;
                        return;
                    }
                    this.current._inferEndPosition();
                    var i = new Ss.default({
                        source: { start: Qu(this.tokens[this.position + 1]) },
                    });
                    this.current.parent.append(i),
                        (this.current = i),
                        this.position++;
                }),
                (e.comment = function () {
                    var i = this.currToken;
                    this.newNode(
                        new Wu.default({
                            value: this.content(),
                            source: vt(i),
                            sourceIndex: i[C.FIELDS.START_POS],
                        })
                    ),
                        this.position++;
                }),
                (e.error = function (i, n) {
                    throw this.root.error(i, n);
                }),
                (e.missingBackslash = function () {
                    return this.error(
                        'Expected a backslash preceding the semicolon.',
                        { index: this.currToken[C.FIELDS.START_POS] }
                    );
                }),
                (e.missingParenthesis = function () {
                    return this.expected(
                        'opening parenthesis',
                        this.currToken[C.FIELDS.START_POS]
                    );
                }),
                (e.missingSquareBracket = function () {
                    return this.expected(
                        'opening square bracket',
                        this.currToken[C.FIELDS.START_POS]
                    );
                }),
                (e.unexpected = function () {
                    return this.error(
                        "Unexpected '" +
                            this.content() +
                            "'. Escaping special characters with \\ may help.",
                        this.currToken[C.FIELDS.START_POS]
                    );
                }),
                (e.namespace = function () {
                    var i =
                        (this.prevToken && this.content(this.prevToken)) || !0;
                    if (this.nextToken[C.FIELDS.TYPE] === E.word)
                        return this.position++, this.word(i);
                    if (this.nextToken[C.FIELDS.TYPE] === E.asterisk)
                        return this.position++, this.universal(i);
                }),
                (e.nesting = function () {
                    if (this.nextToken) {
                        var i = this.content(this.nextToken);
                        if (i === '|') {
                            this.position++;
                            return;
                        }
                    }
                    var n = this.currToken;
                    this.newNode(
                        new Iv.default({
                            value: this.content(),
                            source: vt(n),
                            sourceIndex: n[C.FIELDS.START_POS],
                        })
                    ),
                        this.position++;
                }),
                (e.parentheses = function () {
                    var i = this.current.last,
                        n = 1;
                    if ((this.position++, i && i.type === Mv.PSEUDO)) {
                        var s = new Ss.default({
                                source: {
                                    start: Qu(this.tokens[this.position - 1]),
                                },
                            }),
                            a = this.current;
                        for (
                            i.append(s), this.current = s;
                            this.position < this.tokens.length && n;

                        )
                            this.currToken[C.FIELDS.TYPE] ===
                                E.openParenthesis && n++,
                                this.currToken[C.FIELDS.TYPE] ===
                                    E.closeParenthesis && n--,
                                n
                                    ? this.parse()
                                    : ((this.current.source.end = Ju(
                                          this.currToken
                                      )),
                                      (this.current.parent.source.end = Ju(
                                          this.currToken
                                      )),
                                      this.position++);
                        this.current = a;
                    } else {
                        for (
                            var o = this.currToken, u = '(', c;
                            this.position < this.tokens.length && n;

                        )
                            this.currToken[C.FIELDS.TYPE] ===
                                E.openParenthesis && n++,
                                this.currToken[C.FIELDS.TYPE] ===
                                    E.closeParenthesis && n--,
                                (c = this.currToken),
                                (u += this.parseParenthesisToken(
                                    this.currToken
                                )),
                                this.position++;
                        i
                            ? i.appendToPropertyAndEscape('value', u, u)
                            : this.newNode(
                                  new Cs.default({
                                      value: u,
                                      source: ct(
                                          o[C.FIELDS.START_LINE],
                                          o[C.FIELDS.START_COL],
                                          c[C.FIELDS.END_LINE],
                                          c[C.FIELDS.END_COL]
                                      ),
                                      sourceIndex: o[C.FIELDS.START_POS],
                                  })
                              );
                    }
                    if (n)
                        return this.expected(
                            'closing parenthesis',
                            this.currToken[C.FIELDS.START_POS]
                        );
                }),
                (e.pseudo = function () {
                    for (
                        var i = this, n = '', s = this.currToken;
                        this.currToken &&
                        this.currToken[C.FIELDS.TYPE] === E.colon;

                    )
                        (n += this.content()), this.position++;
                    if (!this.currToken)
                        return this.expected(
                            ['pseudo-class', 'pseudo-element'],
                            this.position - 1
                        );
                    if (this.currToken[C.FIELDS.TYPE] === E.word)
                        this.splitWord(!1, function (a, o) {
                            (n += a),
                                i.newNode(
                                    new Dv.default({
                                        value: n,
                                        source: Es(s, i.currToken),
                                        sourceIndex: s[C.FIELDS.START_POS],
                                    })
                                ),
                                o > 1 &&
                                    i.nextToken &&
                                    i.nextToken[C.FIELDS.TYPE] ===
                                        E.openParenthesis &&
                                    i.error('Misplaced parenthesis.', {
                                        index: i.nextToken[C.FIELDS.START_POS],
                                    });
                        });
                    else
                        return this.expected(
                            ['pseudo-class', 'pseudo-element'],
                            this.currToken[C.FIELDS.START_POS]
                        );
                }),
                (e.space = function () {
                    var i = this.content();
                    this.position === 0 ||
                    this.prevToken[C.FIELDS.TYPE] === E.comma ||
                    this.prevToken[C.FIELDS.TYPE] === E.openParenthesis ||
                    this.current.nodes.every(function (n) {
                        return n.type === 'comment';
                    })
                        ? ((this.spaces = this.optionalSpace(i)),
                          this.position++)
                        : this.position === this.tokens.length - 1 ||
                          this.nextToken[C.FIELDS.TYPE] === E.comma ||
                          this.nextToken[C.FIELDS.TYPE] === E.closeParenthesis
                        ? ((this.current.last.spaces.after =
                              this.optionalSpace(i)),
                          this.position++)
                        : this.combinator();
                }),
                (e.string = function () {
                    var i = this.currToken;
                    this.newNode(
                        new Cs.default({
                            value: this.content(),
                            source: vt(i),
                            sourceIndex: i[C.FIELDS.START_POS],
                        })
                    ),
                        this.position++;
                }),
                (e.universal = function (i) {
                    var n = this.nextToken;
                    if (n && this.content(n) === '|')
                        return this.position++, this.namespace();
                    var s = this.currToken;
                    this.newNode(
                        new qv.default({
                            value: this.content(),
                            source: vt(s),
                            sourceIndex: s[C.FIELDS.START_POS],
                        }),
                        i
                    ),
                        this.position++;
                }),
                (e.splitWord = function (i, n) {
                    for (
                        var s = this, a = this.nextToken, o = this.content();
                        a &&
                        ~[E.dollar, E.caret, E.equals, E.word].indexOf(
                            a[C.FIELDS.TYPE]
                        );

                    ) {
                        this.position++;
                        var u = this.content();
                        if (((o += u), u.lastIndexOf('\\') === u.length - 1)) {
                            var c = this.nextToken;
                            c &&
                                c[C.FIELDS.TYPE] === E.space &&
                                ((o += this.requiredSpace(this.content(c))),
                                this.position++);
                        }
                        a = this.nextToken;
                    }
                    var f = Ts(o, '.').filter(function (y) {
                            var k = o[y - 1] === '\\',
                                w = /^\d+\.\d+%$/.test(o);
                            return !k && !w;
                        }),
                        p = Ts(o, '#').filter(function (y) {
                            return o[y - 1] !== '\\';
                        }),
                        h = Ts(o, '#{');
                    h.length &&
                        (p = p.filter(function (y) {
                            return !~h.indexOf(y);
                        }));
                    var d = (0, Rv.default)(Lv([0].concat(f, p)));
                    d.forEach(function (y, k) {
                        var w = d[k + 1] || o.length,
                            b = o.slice(y, w);
                        if (k === 0 && n) return n.call(s, b, d.length);
                        var x,
                            S = s.currToken,
                            _ = S[C.FIELDS.START_POS] + d[k],
                            D = ct(S[1], S[2] + y, S[3], S[2] + (w - 1));
                        if (~f.indexOf(y)) {
                            var M = {
                                value: b.slice(1),
                                source: D,
                                sourceIndex: _,
                            };
                            x = new Ev.default(xt(M, 'value'));
                        } else if (~p.indexOf(y)) {
                            var B = {
                                value: b.slice(1),
                                source: D,
                                sourceIndex: _,
                            };
                            x = new Tv.default(xt(B, 'value'));
                        } else {
                            var q = { value: b, source: D, sourceIndex: _ };
                            xt(q, 'value'), (x = new Pv.default(q));
                        }
                        s.newNode(x, i), (i = null);
                    }),
                        this.position++;
                }),
                (e.word = function (i) {
                    var n = this.nextToken;
                    return n && this.content(n) === '|'
                        ? (this.position++, this.namespace())
                        : this.splitWord(i);
                }),
                (e.loop = function () {
                    for (; this.position < this.tokens.length; ) this.parse(!0);
                    return this.current._inferEndPosition(), this.root;
                }),
                (e.parse = function (i) {
                    switch (this.currToken[C.FIELDS.TYPE]) {
                        case E.space:
                            this.space();
                            break;
                        case E.comment:
                            this.comment();
                            break;
                        case E.openParenthesis:
                            this.parentheses();
                            break;
                        case E.closeParenthesis:
                            i && this.missingParenthesis();
                            break;
                        case E.openSquare:
                            this.attribute();
                            break;
                        case E.dollar:
                        case E.caret:
                        case E.equals:
                        case E.word:
                            this.word();
                            break;
                        case E.colon:
                            this.pseudo();
                            break;
                        case E.comma:
                            this.comma();
                            break;
                        case E.asterisk:
                            this.universal();
                            break;
                        case E.ampersand:
                            this.nesting();
                            break;
                        case E.slash:
                        case E.combinator:
                            this.combinator();
                            break;
                        case E.str:
                            this.string();
                            break;
                        case E.closeSquare:
                            this.missingSquareBracket();
                        case E.semicolon:
                            this.missingBackslash();
                        default:
                            this.unexpected();
                    }
                }),
                (e.expected = function (i, n, s) {
                    if (Array.isArray(i)) {
                        var a = i.pop();
                        i = i.join(', ') + ' or ' + a;
                    }
                    var o = /^[aeiou]/.test(i[0]) ? 'an' : 'a';
                    return s
                        ? this.error(
                              'Expected ' +
                                  o +
                                  ' ' +
                                  i +
                                  ', found "' +
                                  s +
                                  '" instead.',
                              { index: n }
                          )
                        : this.error('Expected ' + o + ' ' + i + '.', {
                              index: n,
                          });
                }),
                (e.requiredSpace = function (i) {
                    return this.options.lossy ? ' ' : i;
                }),
                (e.optionalSpace = function (i) {
                    return this.options.lossy ? '' : i;
                }),
                (e.lossySpace = function (i, n) {
                    return this.options.lossy ? (n ? ' ' : '') : i;
                }),
                (e.parseParenthesisToken = function (i) {
                    var n = this.content(i);
                    return i[C.FIELDS.TYPE] === E.space
                        ? this.requiredSpace(n)
                        : n;
                }),
                (e.newNode = function (i, n) {
                    return (
                        n &&
                            (/^ +$/.test(n) &&
                                (this.options.lossy ||
                                    (this.spaces = (this.spaces || '') + n),
                                (n = !0)),
                            (i.namespace = n),
                            xt(i, 'namespace')),
                        this.spaces &&
                            ((i.spaces.before = this.spaces),
                            (this.spaces = '')),
                        this.current.append(i)
                    );
                }),
                (e.content = function (i) {
                    return (
                        i === void 0 && (i = this.currToken),
                        this.css.slice(
                            i[C.FIELDS.START_POS],
                            i[C.FIELDS.END_POS]
                        )
                    );
                }),
                (e.locateNextMeaningfulToken = function (i) {
                    i === void 0 && (i = this.position + 1);
                    for (var n = i; n < this.tokens.length; )
                        if (Nv[this.tokens[n][C.FIELDS.TYPE]]) {
                            n++;
                            continue;
                        } else return n;
                    return -1;
                }),
                Fv(r, [
                    {
                        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];
                        },
                    },
                ]),
                r
            );
        })();
        vr.default = Bv;
        Xu.exports = vr.default;
    });
    var ef = v((xr, Zu) => {
        l();
        ('use strict');
        xr.__esModule = !0;
        xr.default = void 0;
        var $v = zv(Ku());
        function zv(r) {
            return r && r.__esModule ? r : { default: r };
        }
        var jv = (function () {
            function r(t, i) {
                (this.func = t || function () {}),
                    (this.funcRes = null),
                    (this.options = i);
            }
            var e = r.prototype;
            return (
                (e._shouldUpdateSelector = function (i, n) {
                    n === void 0 && (n = {});
                    var s = Object.assign({}, this.options, n);
                    return s.updateSelector === !1 ? !1 : typeof i != 'string';
                }),
                (e._isLossy = function (i) {
                    i === void 0 && (i = {});
                    var n = Object.assign({}, this.options, i);
                    return n.lossless === !1;
                }),
                (e._root = function (i, n) {
                    n === void 0 && (n = {});
                    var s = new $v.default(i, this._parseOptions(n));
                    return s.root;
                }),
                (e._parseOptions = function (i) {
                    return { lossy: this._isLossy(i) };
                }),
                (e._run = function (i, n) {
                    var s = this;
                    return (
                        n === void 0 && (n = {}),
                        new Promise(function (a, o) {
                            try {
                                var u = s._root(i, n);
                                Promise.resolve(s.func(u))
                                    .then(function (c) {
                                        var f = void 0;
                                        return (
                                            s._shouldUpdateSelector(i, n) &&
                                                ((f = u.toString()),
                                                (i.selector = f)),
                                            { transform: c, root: u, string: f }
                                        );
                                    })
                                    .then(a, o);
                            } catch (c) {
                                o(c);
                                return;
                            }
                        })
                    );
                }),
                (e._runSync = function (i, n) {
                    n === void 0 && (n = {});
                    var s = this._root(i, n),
                        a = this.func(s);
                    if (a && typeof a.then == 'function')
                        throw new Error(
                            'Selector processor returned a promise to a synchronous call.'
                        );
                    var o = void 0;
                    return (
                        n.updateSelector &&
                            typeof i != 'string' &&
                            ((o = s.toString()), (i.selector = o)),
                        { transform: a, root: s, string: o }
                    );
                }),
                (e.ast = function (i, n) {
                    return this._run(i, n).then(function (s) {
                        return s.root;
                    });
                }),
                (e.astSync = function (i, n) {
                    return this._runSync(i, n).root;
                }),
                (e.transform = function (i, n) {
                    return this._run(i, n).then(function (s) {
                        return s.transform;
                    });
                }),
                (e.transformSync = function (i, n) {
                    return this._runSync(i, n).transform;
                }),
                (e.process = function (i, n) {
                    return this._run(i, n).then(function (s) {
                        return s.string || s.root.toString();
                    });
                }),
                (e.processSync = function (i, n) {
                    var s = this._runSync(i, n);
                    return s.string || s.root.toString();
                }),
                r
            );
        })();
        xr.default = jv;
        Zu.exports = xr.default;
    });
    var tf = v(W => {
        l();
        ('use strict');
        W.__esModule = !0;
        W.universal =
            W.tag =
            W.string =
            W.selector =
            W.root =
            W.pseudo =
            W.nesting =
            W.id =
            W.comment =
            W.combinator =
            W.className =
            W.attribute =
                void 0;
        var Vv = ye(hs()),
            Uv = ye(Xn()),
            Wv = ye(ws()),
            Gv = ye(Zn()),
            Hv = ye(ts()),
            Yv = ye(vs()),
            Qv = ye(ls()),
            Jv = ye(Gn()),
            Xv = ye(Yn()),
            Kv = ye(as()),
            Zv = ye(ns()),
            ex = ye(gs());
        function ye(r) {
            return r && r.__esModule ? r : { default: r };
        }
        var tx = function (e) {
            return new Vv.default(e);
        };
        W.attribute = tx;
        var rx = function (e) {
            return new Uv.default(e);
        };
        W.className = rx;
        var ix = function (e) {
            return new Wv.default(e);
        };
        W.combinator = ix;
        var nx = function (e) {
            return new Gv.default(e);
        };
        W.comment = nx;
        var sx = function (e) {
            return new Hv.default(e);
        };
        W.id = sx;
        var ax = function (e) {
            return new Yv.default(e);
        };
        W.nesting = ax;
        var ox = function (e) {
            return new Qv.default(e);
        };
        W.pseudo = ox;
        var lx = function (e) {
            return new Jv.default(e);
        };
        W.root = lx;
        var ux = function (e) {
            return new Xv.default(e);
        };
        W.selector = ux;
        var fx = function (e) {
            return new Kv.default(e);
        };
        W.string = fx;
        var cx = function (e) {
            return new Zv.default(e);
        };
        W.tag = cx;
        var px = function (e) {
            return new ex.default(e);
        };
        W.universal = px;
    });
    var af = v(L => {
        l();
        ('use strict');
        L.__esModule = !0;
        L.isNode = Ps;
        L.isPseudoElement = sf;
        L.isPseudoClass = Sx;
        L.isContainer = Cx;
        L.isNamespace = _x;
        L.isUniversal =
            L.isTag =
            L.isString =
            L.isSelector =
            L.isRoot =
            L.isPseudo =
            L.isNesting =
            L.isIdentifier =
            L.isComment =
            L.isCombinator =
            L.isClassName =
            L.isAttribute =
                void 0;
        var Q = te(),
            oe,
            dx =
                ((oe = {}),
                (oe[Q.ATTRIBUTE] = !0),
                (oe[Q.CLASS] = !0),
                (oe[Q.COMBINATOR] = !0),
                (oe[Q.COMMENT] = !0),
                (oe[Q.ID] = !0),
                (oe[Q.NESTING] = !0),
                (oe[Q.PSEUDO] = !0),
                (oe[Q.ROOT] = !0),
                (oe[Q.SELECTOR] = !0),
                (oe[Q.STRING] = !0),
                (oe[Q.TAG] = !0),
                (oe[Q.UNIVERSAL] = !0),
                oe);
        function Ps(r) {
            return typeof r == 'object' && dx[r.type];
        }
        function we(r, e) {
            return Ps(e) && e.type === r;
        }
        var rf = we.bind(null, Q.ATTRIBUTE);
        L.isAttribute = rf;
        var hx = we.bind(null, Q.CLASS);
        L.isClassName = hx;
        var mx = we.bind(null, Q.COMBINATOR);
        L.isCombinator = mx;
        var gx = we.bind(null, Q.COMMENT);
        L.isComment = gx;
        var yx = we.bind(null, Q.ID);
        L.isIdentifier = yx;
        var wx = we.bind(null, Q.NESTING);
        L.isNesting = wx;
        var Ds = we.bind(null, Q.PSEUDO);
        L.isPseudo = Ds;
        var bx = we.bind(null, Q.ROOT);
        L.isRoot = bx;
        var vx = we.bind(null, Q.SELECTOR);
        L.isSelector = vx;
        var xx = we.bind(null, Q.STRING);
        L.isString = xx;
        var nf = we.bind(null, Q.TAG);
        L.isTag = nf;
        var kx = we.bind(null, Q.UNIVERSAL);
        L.isUniversal = kx;
        function sf(r) {
            return (
                Ds(r) &&
                r.value &&
                (r.value.startsWith('::') ||
                    r.value.toLowerCase() === ':before' ||
                    r.value.toLowerCase() === ':after' ||
                    r.value.toLowerCase() === ':first-letter' ||
                    r.value.toLowerCase() === ':first-line')
            );
        }
        function Sx(r) {
            return Ds(r) && !sf(r);
        }
        function Cx(r) {
            return !!(Ps(r) && r.walk);
        }
        function _x(r) {
            return rf(r) || nf(r);
        }
    });
    var of = v(Oe => {
        l();
        ('use strict');
        Oe.__esModule = !0;
        var qs = te();
        Object.keys(qs).forEach(function (r) {
            r === 'default' ||
                r === '__esModule' ||
                (r in Oe && Oe[r] === qs[r]) ||
                (Oe[r] = qs[r]);
        });
        var Is = tf();
        Object.keys(Is).forEach(function (r) {
            r === 'default' ||
                r === '__esModule' ||
                (r in Oe && Oe[r] === Is[r]) ||
                (Oe[r] = Is[r]);
        });
        var Rs = af();
        Object.keys(Rs).forEach(function (r) {
            r === 'default' ||
                r === '__esModule' ||
                (r in Oe && Oe[r] === Rs[r]) ||
                (Oe[r] = Rs[r]);
        });
    });
    var De = v((kr, uf) => {
        l();
        ('use strict');
        kr.__esModule = !0;
        kr.default = void 0;
        var Ax = Tx(ef()),
            Ox = Ex(of());
        function lf() {
            if (typeof WeakMap != 'function') return null;
            var r = new WeakMap();
            return (
                (lf = function () {
                    return r;
                }),
                r
            );
        }
        function Ex(r) {
            if (r && r.__esModule) return r;
            if (r === null || (typeof r != 'object' && typeof r != 'function'))
                return { default: r };
            var e = lf();
            if (e && e.has(r)) return e.get(r);
            var t = {},
                i = Object.defineProperty && Object.getOwnPropertyDescriptor;
            for (var n in r)
                if (Object.prototype.hasOwnProperty.call(r, n)) {
                    var s = i ? Object.getOwnPropertyDescriptor(r, n) : null;
                    s && (s.get || s.set)
                        ? Object.defineProperty(t, n, s)
                        : (t[n] = r[n]);
                }
            return (t.default = r), e && e.set(r, t), t;
        }
        function Tx(r) {
            return r && r.__esModule ? r : { default: r };
        }
        var Ms = function (e) {
            return new Ax.default(e);
        };
        Object.assign(Ms, Ox);
        delete Ms.__esModule;
        var Px = Ms;
        kr.default = Px;
        uf.exports = kr.default;
    });
    function pt(r) {
        return r.replace(/\\,/g, '\\2c ');
    }
    var Si = A(() => {
        l();
    });
    var cf = v((rE, ff) => {
        l();
        ('use strict');
        ff.exports = {
            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 Sr(r, { loose: e = !1 } = {}) {
        if (typeof r != 'string') return null;
        if (((r = r.trim()), r === 'transparent'))
            return { mode: 'rgb', color: ['0', '0', '0'], alpha: '0' };
        if (r in Fs.default)
            return { mode: 'rgb', color: Fs.default[r].map(s => s.toString()) };
        let t = r
            .replace(qx, (s, a, o, u, c) =>
                ['#', a, a, o, o, u, u, c ? c + c : ''].join('')
            )
            .match(Dx);
        if (t !== null)
            return {
                mode: 'rgb',
                color: [
                    parseInt(t[1], 16),
                    parseInt(t[2], 16),
                    parseInt(t[3], 16),
                ].map(s => s.toString()),
                alpha: t[4] ? (parseInt(t[4], 16) / 255).toString() : void 0,
            };
        let i = r.match(Ix) ?? r.match(Rx);
        if (i === null) return null;
        let n = [i[2], i[3], i[4]].filter(Boolean).map(s => s.toString());
        return (!e && n.length !== 3) ||
            (n.length < 3 && !n.some(s => /^var\(.*?\)$/.test(s)))
            ? null
            : { mode: i[1], color: n, alpha: i[5]?.toString?.() };
    }
    function Ns({ mode: r, color: e, alpha: t }) {
        let i = t !== void 0;
        return `${r}(${e.join(' ')}${i ? ` / ${t}` : ''})`;
    }
    var Fs,
        Dx,
        qx,
        Qe,
        Ci,
        pf,
        Je,
        Ix,
        Rx,
        Ls = A(() => {
            l();
            (Fs = J(cf())),
                (Dx = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i),
                (qx = /^#([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i),
                (Qe = /(?:\d+|\d*\.\d+)%?/),
                (Ci = /(?:\s*,\s*|\s+)/),
                (pf = /\s*[,/]\s*/),
                (Je = /var\(--(?:[^ )]*?)\)/),
                (Ix = new RegExp(
                    `^(rgb)a?\\(\\s*(${Qe.source}|${Je.source})(?:${Ci.source}(${Qe.source}|${Je.source}))?(?:${Ci.source}(${Qe.source}|${Je.source}))?(?:${pf.source}(${Qe.source}|${Je.source}))?\\s*\\)$`
                )),
                (Rx = new RegExp(
                    `^(hsl)a?\\(\\s*((?:${Qe.source})(?:deg|rad|grad|turn)?|${Je.source})(?:${Ci.source}(${Qe.source}|${Je.source}))?(?:${Ci.source}(${Qe.source}|${Je.source}))?(?:${pf.source}(${Qe.source}|${Je.source}))?\\s*\\)$`
                ));
        });
    function qe(r, e, t) {
        if (typeof r == 'function') return r({ opacityValue: e });
        let i = Sr(r, { loose: !0 });
        return i === null ? t : Ns({ ...i, alpha: e });
    }
    function le({ color: r, property: e, variable: t }) {
        let i = [].concat(e);
        if (typeof r == 'function')
            return {
                [t]: '1',
                ...Object.fromEntries(
                    i.map(s => [
                        s,
                        r({ opacityVariable: t, opacityValue: `var(${t})` }),
                    ])
                ),
            };
        let n = Sr(r);
        return n === null
            ? Object.fromEntries(i.map(s => [s, r]))
            : n.alpha !== void 0
            ? Object.fromEntries(i.map(s => [s, r]))
            : {
                  [t]: '1',
                  ...Object.fromEntries(
                      i.map(s => [s, Ns({ ...n, alpha: `var(${t})` })])
                  ),
              };
    }
    var Cr = A(() => {
        l();
        Ls();
    });
    function de(r, e) {
        let t = [],
            i = [],
            n = 0;
        for (let s = 0; s < r.length; s++) {
            let a = r[s];
            t.length === 0 &&
                a === e[0] &&
                (e.length === 1 || r.slice(s, s + e.length) === e) &&
                (i.push(r.slice(n, s)), (n = s + e.length)),
                a === '(' || a === '[' || a === '{'
                    ? t.push(a)
                    : ((a === ')' && t[t.length - 1] === '(') ||
                          (a === ']' && t[t.length - 1] === '[') ||
                          (a === '}' && t[t.length - 1] === '{')) &&
                      t.pop();
        }
        return i.push(r.slice(n)), i;
    }
    var _r = A(() => {
        l();
    });
    function _i(r) {
        return de(r, ',').map(t => {
            let i = t.trim(),
                n = { raw: i },
                s = i.split(Fx),
                a = new Set();
            for (let o of s)
                (df.lastIndex = 0),
                    !a.has('KEYWORD') && Mx.has(o)
                        ? ((n.keyword = o), a.add('KEYWORD'))
                        : df.test(o)
                        ? a.has('X')
                            ? a.has('Y')
                                ? a.has('BLUR')
                                    ? a.has('SPREAD') ||
                                      ((n.spread = o), a.add('SPREAD'))
                                    : ((n.blur = o), a.add('BLUR'))
                                : ((n.y = o), a.add('Y'))
                            : ((n.x = o), a.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 hf(r) {
        return r
            .map(e =>
                e.valid
                    ? [e.keyword, e.x, e.y, e.blur, e.spread, e.color]
                          .filter(Boolean)
                          .join(' ')
                    : e.raw
            )
            .join(', ');
    }
    var Mx,
        Fx,
        df,
        Bs = A(() => {
            l();
            _r();
            (Mx = new Set(['inset', 'inherit', 'initial', 'revert', 'unset'])),
                (Fx = /\ +(?![^(]*\))/g),
                (df = /^-?(\d+|\.\d+)(.*?)$/g);
        });
    function $s(r) {
        return Nx.some(e => new RegExp(`^${e}\\(.*\\)`).test(r));
    }
    function H(r, e = !0) {
        return r.includes('url(')
            ? r
                  .split(/(url\(.*?\))/g)
                  .filter(Boolean)
                  .map(t => (/^url\(.*?\)$/.test(t) ? t : H(t, !1)))
                  .join('')
            : ((r = r
                  .replace(/([^\\])_+/g, (t, i) => i + ' '.repeat(t.length - 1))
                  .replace(/^_/g, ' ')
                  .replace(/\\_/g, '_')),
              e && (r = r.trim()),
              (r = r.replace(/(calc|min|max|clamp)\(.+\)/g, t =>
                  t.replace(
                      /(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g,
                      '$1 $2 '
                  )
              )),
              r);
    }
    function zs(r) {
        return r.startsWith('url(');
    }
    function js(r) {
        return !isNaN(Number(r)) || $s(r);
    }
    function Ar(r) {
        return (r.endsWith('%') && js(r.slice(0, -1))) || $s(r);
    }
    function Or(r) {
        return (
            r === '0' ||
            new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${Bx}$`).test(
                r
            ) ||
            $s(r)
        );
    }
    function mf(r) {
        return $x.has(r);
    }
    function gf(r) {
        let e = _i(H(r));
        for (let t of e) if (!t.valid) return !1;
        return !0;
    }
    function yf(r) {
        let e = 0;
        return de(r, '_').every(
            i => (
                (i = H(i)),
                i.startsWith('var(')
                    ? !0
                    : Sr(i, { loose: !0 }) !== null
                    ? (e++, !0)
                    : !1
            )
        )
            ? e > 0
            : !1;
    }
    function wf(r) {
        let e = 0;
        return de(r, ',').every(
            i => (
                (i = H(i)),
                i.startsWith('var(')
                    ? !0
                    : zs(i) ||
                      jx(i) ||
                      ['element(', 'image(', 'cross-fade(', 'image-set('].some(
                          n => i.startsWith(n)
                      )
                    ? (e++, !0)
                    : !1
            )
        )
            ? e > 0
            : !1;
    }
    function jx(r) {
        r = H(r);
        for (let e of zx) if (r.startsWith(`${e}(`)) return !0;
        return !1;
    }
    function bf(r) {
        let e = 0;
        return de(r, '_').every(
            i => (
                (i = H(i)),
                i.startsWith('var(')
                    ? !0
                    : Vx.has(i) || Or(i) || Ar(i)
                    ? (e++, !0)
                    : !1
            )
        )
            ? e > 0
            : !1;
    }
    function vf(r) {
        let e = 0;
        return de(r, ',').every(
            i => (
                (i = H(i)),
                i.startsWith('var(')
                    ? !0
                    : (i.includes(' ') && !/(['"])([^"']+)\1/g.test(i)) ||
                      /^\d/g.test(i)
                    ? !1
                    : (e++, !0)
            )
        )
            ? e > 0
            : !1;
    }
    function xf(r) {
        return Ux.has(r);
    }
    function kf(r) {
        return Wx.has(r);
    }
    function Sf(r) {
        return Gx.has(r);
    }
    var Nx,
        Lx,
        Bx,
        $x,
        zx,
        Vx,
        Ux,
        Wx,
        Gx,
        Er = A(() => {
            l();
            Ls();
            Bs();
            _r();
            Nx = ['min', 'max', 'clamp', 'calc'];
            (Lx = [
                'cm',
                'mm',
                'Q',
                'in',
                'pc',
                'pt',
                'px',
                'em',
                'ex',
                'ch',
                'rem',
                'lh',
                'vw',
                'vh',
                'vmin',
                'vmax',
            ]),
                (Bx = `(?:${Lx.join('|')})`);
            $x = new Set(['thin', 'medium', 'thick']);
            zx = new Set([
                'linear-gradient',
                'radial-gradient',
                'repeating-linear-gradient',
                'repeating-radial-gradient',
                'conic-gradient',
            ]);
            Vx = new Set(['center', 'top', 'right', 'bottom', 'left']);
            Ux = new Set([
                'serif',
                'sans-serif',
                'monospace',
                'cursive',
                'fantasy',
                'system-ui',
                'ui-serif',
                'ui-sans-serif',
                'ui-monospace',
                'ui-rounded',
                'math',
                'emoji',
                'fangsong',
            ]);
            Wx = new Set([
                'xx-small',
                'x-small',
                'small',
                'medium',
                'large',
                'x-large',
                'x-large',
                'xxx-large',
            ]);
            Gx = new Set(['larger', 'smaller']);
        });
    function Cf(r) {
        let e = ['cover', 'contain'];
        return de(r, ',').every(t => {
            let i = de(t, '_').filter(Boolean);
            return i.length === 1 && e.includes(i[0])
                ? !0
                : i.length !== 1 && i.length !== 2
                ? !1
                : i.every(n => Or(n) || Ar(n) || n === 'auto');
        });
    }
    var _f = A(() => {
        l();
        Er();
        _r();
    });
    function K(r, e) {
        return Ai.future.includes(e)
            ? r.future === 'all' || (r?.future?.[e] ?? Af[e] ?? !1)
            : Ai.experimental.includes(e)
            ? r.experimental === 'all' || (r?.experimental?.[e] ?? Af[e] ?? !1)
            : !1;
    }
    function Of(r) {
        return r.experimental === 'all'
            ? Ai.experimental
            : Object.keys(r?.experimental ?? {}).filter(
                  e => Ai.experimental.includes(e) && r.experimental[e]
              );
    }
    function Ef(r) {
        if (m.env.JEST_WORKER_ID === void 0 && Of(r).length > 0) {
            let e = Of(r)
                .map(t => _e.yellow(t))
                .join(', ');
            N.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 Af,
        Ai,
        $e = A(() => {
            l();
            oi();
            Ae();
            (Af = { optimizeUniversalDefaults: !1, generalizedModifiers: !0 }),
                (Ai = {
                    future: [
                        'hoverOnlyWhenSupported',
                        'respectDefaultRingColorOpacity',
                        'disableColorOpacityUtilitiesByDefault',
                        'relativeContentPathsByDefault',
                    ],
                    experimental: [
                        'optimizeUniversalDefaults',
                        'generalizedModifiers',
                    ],
                });
        });
    function Tf(r, e) {
        return (0, Vs.default)(n => {
            n.walkClasses(s => {
                let a = e(s.value);
                (s.value = a),
                    s.raws && s.raws.value && (s.raws.value = pt(s.raws.value));
            });
        }).processSync(r);
    }
    function Pf(r, e) {
        return (0, Vs.default)(n => {
            n.each(s => {
                s.nodes.some(o => o.type === 'class' && o.value === e) ||
                    s.remove();
            });
        }).processSync(r);
    }
    function Df(r, e) {
        if (!Xe(r)) return;
        let t = r.slice(1, -1);
        if (!!e(t)) return H(t);
    }
    function Hx(r, e = {}, t) {
        let i = e[r];
        if (i !== void 0) return ut(i);
        if (Xe(r)) {
            let n = Df(r, t);
            return n === void 0 ? void 0 : ut(n);
        }
    }
    function Tr(r, e = {}, { validate: t = () => !0 } = {}) {
        let i = e.values?.[r];
        return i !== void 0
            ? i
            : e.supportsNegativeValues && r.startsWith('-')
            ? Hx(r.slice(1), e.values, t)
            : Df(r, t);
    }
    function Xe(r) {
        return r.startsWith('[') && r.endsWith(']');
    }
    function qf(r) {
        let e = r.lastIndexOf('/');
        return e === -1 || e === r.length - 1
            ? [r, void 0]
            : Xe(r) && !r.includes(']/[')
            ? [r, void 0]
            : [r.slice(0, e), r.slice(e + 1)];
    }
    function kt(r) {
        if (typeof r == 'string' && r.includes('<alpha-value>')) {
            let e = r;
            return ({ opacityValue: t = 1 }) => e.replace('<alpha-value>', t);
        }
        return r;
    }
    function Yx(
        r,
        e = {},
        { tailwindConfig: t = {}, utilityModifier: i, rawModifier: n } = {}
    ) {
        if (e.values?.[n] !== void 0) return kt(e.values?.[n]);
        let [s, a] = qf(n);
        if (a !== void 0) {
            let o = e.values?.[s] ?? (Xe(s) ? s.slice(1, -1) : void 0);
            return o === void 0
                ? void 0
                : ((o = kt(o)),
                  Xe(a)
                      ? qe(o, a.slice(1, -1))
                      : t.theme?.opacity?.[a] === void 0
                      ? void 0
                      : qe(o, t.theme.opacity[a]));
        }
        return Tr(n, e, { rawModifier: n, utilityModifier: i, validate: yf });
    }
    function Qx(r, e = {}) {
        return e.values?.[r];
    }
    function he(r) {
        return (e, t, i) => Tr(e, t, { ...i, validate: r });
    }
    function Jx(r, e) {
        let t = r.indexOf(e);
        return t === -1 ? [void 0, r] : [r.slice(0, t), r.slice(t + 1)];
    }
    function Us(r, e, t, i) {
        if (Xe(e)) {
            let s = e.slice(1, -1),
                [a, o] = Jx(s, ':');
            if (!/^[\w-_]+$/g.test(a)) o = s;
            else if (a !== void 0 && !Rf.includes(a)) return [];
            if (o.length > 0 && Rf.includes(a))
                return [Tr(`[${o}]`, t), a, null];
        }
        let n = Ws(r, e, t, i);
        for (let s of n) return s;
        return [];
    }
    function* Ws(r, e, t, i) {
        let n = K(i, 'generalizedModifiers'),
            [s, a] = qf(e);
        if (
            ((n &&
                t.modifiers != null &&
                (t.modifiers === 'any' ||
                    (typeof t.modifiers == 'object' &&
                        ((a && Xe(a)) || a in t.modifiers)))) ||
                ((s = e), (a = void 0)),
            a !== void 0 && s === '' && (s = 'DEFAULT'),
            a !== void 0)
        ) {
            if (typeof t.modifiers == 'object') {
                let c = t.modifiers?.[a] ?? null;
                c !== null ? (a = c) : Xe(a) && (a = a.slice(1, -1));
            }
            let u = Tr(e, t, {
                rawModifier: e,
                utilityModifier: a,
                tailwindConfig: i,
            });
            u !== void 0 && (yield [u, 'any', null]);
        }
        for (let { type: u } of r ?? []) {
            let c = If[u](s, t, {
                rawModifier: e,
                utilityModifier: a,
                tailwindConfig: i,
            });
            c !== void 0 && (yield [c, u, a ?? null]);
        }
    }
    var Vs,
        If,
        Rf,
        Pr = A(() => {
            l();
            Vs = J(De());
            Si();
            Cr();
            Er();
            ai();
            _f();
            $e();
            (If = {
                any: Tr,
                color: Yx,
                url: he(zs),
                image: he(wf),
                length: he(Or),
                percentage: he(Ar),
                position: he(bf),
                lookup: Qx,
                'generic-name': he(xf),
                'family-name': he(vf),
                number: he(js),
                'line-width': he(mf),
                'absolute-size': he(kf),
                'relative-size': he(Sf),
                shadow: he(gf),
                size: he(Cf),
            }),
                (Rf = Object.keys(If));
        });
    function $(r) {
        return typeof r == 'function' ? r({}) : r;
    }
    var Gs = A(() => {
        l();
    });
    function St(r) {
        return typeof r == 'function';
    }
    function Dr(r, ...e) {
        let t = e.pop();
        for (let i of e)
            for (let n in i) {
                let s = t(r[n], i[n]);
                s === void 0
                    ? ee(r[n]) && ee(i[n])
                        ? (r[n] = Dr({}, r[n], i[n], t))
                        : (r[n] = i[n])
                    : (r[n] = s);
            }
        return r;
    }
    function Xx(r, ...e) {
        return St(r) ? r(...e) : r;
    }
    function Kx(r) {
        return r.reduce(
            (e, { extend: t }) =>
                Dr(e, t, (i, n) =>
                    i === void 0 ? [n] : Array.isArray(i) ? [n, ...i] : [n, i]
                ),
            {}
        );
    }
    function Zx(r) {
        return { ...r.reduce((e, t) => Vn(e, t), {}), extend: Kx(r) };
    }
    function Ff(r, e) {
        if (Array.isArray(r) && ee(r[0])) return r.concat(e);
        if (Array.isArray(e) && ee(e[0]) && ee(r)) return [r, ...e];
        if (Array.isArray(e)) return e;
    }
    function e1({ extend: r, ...e }) {
        return Dr(e, r, (t, i) =>
            !St(t) && !i.some(St)
                ? Dr({}, t, ...i, Ff)
                : (n, s) => Dr({}, ...[t, ...i].map(a => Xx(a, n, s)), Ff)
        );
    }
    function* t1(r) {
        let e = He(r);
        if (e.length === 0 || (yield e, Array.isArray(r))) return;
        let t = /^(.*?)\s*\/\s*([^/]+)$/,
            i = r.match(t);
        if (i !== null) {
            let [, n, s] = i,
                a = He(n);
            (a.alpha = s), yield a;
        }
    }
    function r1(r) {
        let e = (t, i) => {
            for (let n of t1(t)) {
                let s = 0,
                    a = r;
                for (; a != null && s < n.length; )
                    (a = a[n[s++]]),
                        (a =
                            St(a) && (n.alpha === void 0 || s <= n.length - 1)
                                ? a(e, Hs)
                                : a);
                if (a !== void 0) {
                    if (n.alpha !== void 0) {
                        let o = kt(a);
                        return qe(o, n.alpha, $(o));
                    }
                    return ee(a) ? Ye(a) : a;
                }
            }
            return i;
        };
        return (
            Object.assign(e, { theme: e, ...Hs }),
            Object.keys(r).reduce(
                (t, i) => ((t[i] = St(r[i]) ? r[i](e, Hs) : r[i]), t),
                {}
            )
        );
    }
    function Nf(r) {
        let e = [];
        return (
            r.forEach(t => {
                e = [...e, t];
                let i = t?.plugins ?? [];
                i.length !== 0 &&
                    i.forEach(n => {
                        n.__isOptionsFunction && (n = n()),
                            (e = [...e, ...Nf([n?.config ?? {}])]);
                    });
            }),
            e
        );
    }
    function i1(r) {
        return [...r].reduceRight(
            (t, i) => (St(i) ? i({ corePlugins: t }) : Gl(i, t)),
            Ul
        );
    }
    function n1(r) {
        return [...r].reduceRight((t, i) => [...t, ...i], []);
    }
    function Ys(r) {
        let e = [
            ...Nf(r),
            {
                prefix: '',
                important: !1,
                separator: ':',
                variantOrder: Mf.default.variantOrder,
            },
        ];
        return Zl(
            Vn(
                {
                    theme: r1(e1(Zx(e.map(t => t?.theme ?? {})))),
                    corePlugins: i1(e.map(t => t.corePlugins)),
                    plugins: n1(r.map(t => t?.plugins ?? [])),
                },
                ...e
            )
        );
    }
    var Mf,
        Hs,
        Lf = A(() => {
            l();
            ai();
            Wl();
            Hl();
            Mf = J(Zt());
            jn();
            Kl();
            li();
            eu();
            wt();
            ui();
            Pr();
            Cr();
            Gs();
            Hs = {
                colors: zn,
                negative(r) {
                    return Object.keys(r)
                        .filter(e => r[e] !== '0')
                        .reduce((e, t) => {
                            let i = ut(r[t]);
                            return i !== void 0 && (e[`-${t}`] = i), e;
                        }, {});
                },
                breakpoints(r) {
                    return Object.keys(r)
                        .filter(e => typeof r[e] == 'string')
                        .reduce(
                            (e, t) => ({ ...e, [`screen-${t}`]: r[t] }),
                            {}
                        );
                },
            };
        });
    function Oi(r) {
        let e = (r?.presets ?? [Bf.default])
                .slice()
                .reverse()
                .flatMap(n => Oi(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,
                    },
                },
            },
            i = Object.keys(t)
                .filter(n => K(r, n))
                .map(n => t[n]);
        return [r, ...i, ...e];
    }
    var Bf,
        $f = A(() => {
            l();
            Bf = J(Zt());
            $e();
        });
    var zf = {};
    Ce(zf, { default: () => qr });
    function qr(...r) {
        let [, ...e] = Oi(r[0]);
        return Ys([...r, ...e]);
    }
    var Qs = A(() => {
        l();
        Lf();
        $f();
    });
    function Ei(r) {
        return typeof r == 'object' && r !== null;
    }
    function s1(r) {
        return Object.keys(r).length === 0;
    }
    function jf(r) {
        return typeof r == 'string' || r instanceof String;
    }
    function Js(r) {
        if (Ei(r) && r.config === void 0 && !s1(r)) return null;
        if (Ei(r) && r.config !== void 0 && jf(r.config))
            return ie.resolve(r.config);
        if (Ei(r) && r.config !== void 0 && Ei(r.config)) return null;
        if (jf(r)) return ie.resolve(r);
        for (let e of ['./tailwind.config.js', './tailwind.config.cjs'])
            try {
                let t = ie.resolve(e);
                return ae.accessSync(t), t;
            } catch (t) {}
        return null;
    }
    var Vf = A(() => {
        l();
        Ge();
        lt();
    });
    var Uf = {};
    Ce(Uf, { default: () => Xs });
    var Xs,
        Ks = A(() => {
            l();
            Xs = { parse: r => ({ href: r }) };
        });
    var Zs = v(() => {
        l();
    });
    var Ti = v((QE, Hf) => {
        l();
        ('use strict');
        var Wf = (oi(), Ql),
            Gf = Zs(),
            Ct = class extends Error {
                constructor(e, t, i, n, s, a) {
                    super(e);
                    (this.name = 'CssSyntaxError'),
                        (this.reason = e),
                        s && (this.file = s),
                        n && (this.source = n),
                        a && (this.plugin = a),
                        typeof t != 'undefined' &&
                            typeof i != 'undefined' &&
                            (typeof t == 'number'
                                ? ((this.line = t), (this.column = i))
                                : ((this.line = t.line),
                                  (this.column = t.column),
                                  (this.endLine = i.line),
                                  (this.endColumn = i.column))),
                        this.setMessage(),
                        Error.captureStackTrace &&
                            Error.captureStackTrace(this, Ct);
                }
                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 = Wf.isColorSupported),
                        Gf && e && (t = Gf(t));
                    let i = t.split(/\r?\n/),
                        n = Math.max(this.line - 3, 0),
                        s = Math.min(this.line + 2, i.length),
                        a = String(s).length,
                        o,
                        u;
                    if (e) {
                        let { bold: c, red: f, gray: p } = Wf.createColors(!0);
                        (o = h => c(f(h))), (u = h => p(h));
                    } else o = u = c => c;
                    return i.slice(n, s).map((c, f) => {
                        let p = n + 1 + f,
                            h = ' ' + (' ' + p).slice(-a) + ' | ';
                        if (p === this.line) {
                            let d =
                                u(h.replace(/\d/g, ' ')) +
                                c
                                    .slice(0, this.column - 1)
                                    .replace(/[^\t]/g, ' ');
                            return (
                                o('>') +
                                u(h) +
                                c +
                                `
 ` +
                                d +
                                o('^')
                            );
                        }
                        return ' ' + u(h) + c;
                    }).join(`
`);
                }
                toString() {
                    let e = this.showSourceCode();
                    return (
                        e &&
                            (e =
                                `

` +
                                e +
                                `
`),
                        this.name + ': ' + this.message + e
                    );
                }
            };
        Hf.exports = Ct;
        Ct.default = Ct;
    });
    var Pi = v((JE, ea) => {
        l();
        ('use strict');
        ea.exports.isClean = Symbol('isClean');
        ea.exports.my = Symbol('my');
    });
    var ta = v((XE, Qf) => {
        l();
        ('use strict');
        var Yf = {
            colon: ': ',
            indent: '    ',
            beforeDecl: `
`,
            beforeRule: `
`,
            beforeOpen: ' ',
            beforeClose: `
`,
            beforeComment: `
`,
            after: `
`,
            emptyBody: '',
            commentLeft: ' ',
            commentRight: ' ',
            semicolon: !1,
        };
        function a1(r) {
            return r[0].toUpperCase() + r.slice(1);
        }
        var Di = 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'),
                    i = this.raw(e, 'right', 'commentRight');
                this.builder('/*' + t + e.text + i + '*/', e);
            }
            decl(e, t) {
                let i = this.raw(e, 'between', 'colon'),
                    n = e.prop + i + 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 i = '@' + e.name,
                    n = e.params ? this.rawValue(e, 'params') : '';
                if (
                    (typeof e.raws.afterName != 'undefined'
                        ? (i += e.raws.afterName)
                        : n && (i += ' '),
                    e.nodes)
                )
                    this.block(e, i + n);
                else {
                    let s = (e.raws.between || '') + (t ? ';' : '');
                    this.builder(i + n + s, e);
                }
            }
            body(e) {
                let t = e.nodes.length - 1;
                for (; t > 0 && e.nodes[t].type === 'comment'; ) t -= 1;
                let i = this.raw(e, 'semicolon');
                for (let n = 0; n < e.nodes.length; n++) {
                    let s = e.nodes[n],
                        a = this.raw(s, 'before');
                    a && this.builder(a), this.stringify(s, t !== n || i);
                }
            }
            block(e, t) {
                let i = this.raw(e, 'between', 'beforeOpen');
                this.builder(t + i + '{', 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, i) {
                let n;
                if (
                    (i || (i = t),
                    t && ((n = e.raws[t]), typeof n != 'undefined'))
                )
                    return n;
                let s = e.parent;
                if (
                    i === 'before' &&
                    (!s ||
                        (s.type === 'root' && s.first === e) ||
                        (s && s.type === 'document'))
                )
                    return '';
                if (!s) return Yf[i];
                let a = e.root();
                if (
                    (a.rawCache || (a.rawCache = {}),
                    typeof a.rawCache[i] != 'undefined')
                )
                    return a.rawCache[i];
                if (i === 'before' || i === 'after')
                    return this.beforeAfter(e, i);
                {
                    let o = 'raw' + a1(i);
                    this[o]
                        ? (n = this[o](a, e))
                        : a.walk(u => {
                              if (((n = u.raws[t]), typeof n != 'undefined'))
                                  return !1;
                          });
                }
                return (
                    typeof n == 'undefined' && (n = Yf[i]),
                    (a.rawCache[i] = n),
                    n
                );
            }
            rawSemicolon(e) {
                let t;
                return (
                    e.walk(i => {
                        if (
                            i.nodes &&
                            i.nodes.length &&
                            i.last.type === 'decl' &&
                            ((t = i.raws.semicolon), typeof t != 'undefined')
                        )
                            return !1;
                    }),
                    t
                );
            }
            rawEmptyBody(e) {
                let t;
                return (
                    e.walk(i => {
                        if (
                            i.nodes &&
                            i.nodes.length === 0 &&
                            ((t = i.raws.after), typeof t != 'undefined')
                        )
                            return !1;
                    }),
                    t
                );
            }
            rawIndent(e) {
                if (e.raws.indent) return e.raws.indent;
                let t;
                return (
                    e.walk(i => {
                        let n = i.parent;
                        if (
                            n &&
                            n !== e &&
                            n.parent &&
                            n.parent === e &&
                            typeof i.raws.before != 'undefined'
                        ) {
                            let s = i.raws.before.split(`
`);
                            return (
                                (t = s[s.length - 1]),
                                (t = t.replace(/\S/g, '')),
                                !1
                            );
                        }
                    }),
                    t
                );
            }
            rawBeforeComment(e, t) {
                let i;
                return (
                    e.walkComments(n => {
                        if (typeof n.raws.before != 'undefined')
                            return (
                                (i = n.raws.before),
                                i.includes(`
`) && (i = i.replace(/[^\n]+$/, '')),
                                !1
                            );
                    }),
                    typeof i == 'undefined'
                        ? (i = this.raw(t, null, 'beforeDecl'))
                        : i && (i = i.replace(/\S/g, '')),
                    i
                );
            }
            rawBeforeDecl(e, t) {
                let i;
                return (
                    e.walkDecls(n => {
                        if (typeof n.raws.before != 'undefined')
                            return (
                                (i = n.raws.before),
                                i.includes(`
`) && (i = i.replace(/[^\n]+$/, '')),
                                !1
                            );
                    }),
                    typeof i == 'undefined'
                        ? (i = this.raw(t, null, 'beforeRule'))
                        : i && (i = i.replace(/\S/g, '')),
                    i
                );
            }
            rawBeforeRule(e) {
                let t;
                return (
                    e.walk(i => {
                        if (
                            i.nodes &&
                            (i.parent !== e || e.first !== i) &&
                            typeof i.raws.before != 'undefined'
                        )
                            return (
                                (t = i.raws.before),
                                t.includes(`
`) && (t = t.replace(/[^\n]+$/, '')),
                                !1
                            );
                    }),
                    t && (t = t.replace(/\S/g, '')),
                    t
                );
            }
            rawBeforeClose(e) {
                let t;
                return (
                    e.walk(i => {
                        if (
                            i.nodes &&
                            i.nodes.length > 0 &&
                            typeof i.raws.after != 'undefined'
                        )
                            return (
                                (t = i.raws.after),
                                t.includes(`
`) && (t = t.replace(/[^\n]+$/, '')),
                                !1
                            );
                    }),
                    t && (t = t.replace(/\S/g, '')),
                    t
                );
            }
            rawBeforeOpen(e) {
                let t;
                return (
                    e.walk(i => {
                        if (
                            i.type !== 'decl' &&
                            ((t = i.raws.between), typeof t != 'undefined')
                        )
                            return !1;
                    }),
                    t
                );
            }
            rawColon(e) {
                let t;
                return (
                    e.walkDecls(i => {
                        if (typeof i.raws.between != 'undefined')
                            return (
                                (t = i.raws.between.replace(/[^\s:]/g, '')), !1
                            );
                    }),
                    t
                );
            }
            beforeAfter(e, t) {
                let i;
                e.type === 'decl'
                    ? (i = this.raw(e, null, 'beforeDecl'))
                    : e.type === 'comment'
                    ? (i = this.raw(e, null, 'beforeComment'))
                    : t === 'before'
                    ? (i = this.raw(e, null, 'beforeRule'))
                    : (i = this.raw(e, null, 'beforeClose'));
                let n = e.parent,
                    s = 0;
                for (; n && n.type !== 'root'; ) (s += 1), (n = n.parent);
                if (
                    i.includes(`
`)
                ) {
                    let a = this.raw(e, null, 'indent');
                    if (a.length) for (let o = 0; o < s; o++) i += a;
                }
                return i;
            }
            rawValue(e, t) {
                let i = e[t],
                    n = e.raws[t];
                return n && n.value === i ? n.raw : i;
            }
        };
        Qf.exports = Di;
        Di.default = Di;
    });
    var Ir = v((KE, Jf) => {
        l();
        ('use strict');
        var o1 = ta();
        function ra(r, e) {
            new o1(e).stringify(r);
        }
        Jf.exports = ra;
        ra.default = ra;
    });
    var Rr = v((ZE, Xf) => {
        l();
        ('use strict');
        var { isClean: qi, my: l1 } = Pi(),
            u1 = Ti(),
            f1 = ta(),
            c1 = Ir();
        function ia(r, e) {
            let t = new r.constructor();
            for (let i in r) {
                if (
                    !Object.prototype.hasOwnProperty.call(r, i) ||
                    i === 'proxyCache'
                )
                    continue;
                let n = r[i],
                    s = typeof n;
                i === 'parent' && s === 'object'
                    ? e && (t[i] = e)
                    : i === 'source'
                    ? (t[i] = n)
                    : Array.isArray(n)
                    ? (t[i] = n.map(a => ia(a, t)))
                    : (s === 'object' && n !== null && (n = ia(n)), (t[i] = n));
            }
            return t;
        }
        var Ii = class {
            constructor(e = {}) {
                (this.raws = {}), (this[qi] = !1), (this[l1] = !0);
                for (let t in e)
                    if (t === 'nodes') {
                        this.nodes = [];
                        for (let i of e[t])
                            typeof i.clone == 'function'
                                ? this.append(i.clone())
                                : this.append(i);
                    } else this[t] = e[t];
            }
            error(e, t = {}) {
                if (this.source) {
                    let { start: i, end: n } = this.rangeBy(t);
                    return this.source.input.error(
                        e,
                        { line: i.line, column: i.column },
                        { line: n.line, column: n.column },
                        t
                    );
                }
                return new u1(e);
            }
            warn(e, t, i) {
                let n = { node: this };
                for (let s in i) n[s] = i[s];
                return e.warn(t, n);
            }
            remove() {
                return (
                    this.parent && this.parent.removeChild(this),
                    (this.parent = void 0),
                    this
                );
            }
            toString(e = c1) {
                e.stringify && (e = e.stringify);
                let t = '';
                return (
                    e(this, i => {
                        t += i;
                    }),
                    t
                );
            }
            assign(e = {}) {
                for (let t in e) this[t] = e[t];
                return this;
            }
            clone(e = {}) {
                let t = ia(this);
                for (let i in e) t[i] = e[i];
                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,
                        i = !1;
                    for (let n of e)
                        n === this
                            ? (i = !0)
                            : i
                            ? (this.parent.insertAfter(t, n), (t = n))
                            : this.parent.insertBefore(t, n);
                    i || 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 f1().raw(this, e, t);
            }
            cleanRaws(e) {
                delete this.raws.before,
                    delete this.raws.after,
                    e || delete this.raws.between;
            }
            toJSON(e, t) {
                let i = {},
                    n = t == null;
                t = t || new Map();
                let s = 0;
                for (let a in this) {
                    if (
                        !Object.prototype.hasOwnProperty.call(this, a) ||
                        a === 'parent' ||
                        a === 'proxyCache'
                    )
                        continue;
                    let o = this[a];
                    if (Array.isArray(o))
                        i[a] = o.map(u =>
                            typeof u == 'object' && u.toJSON
                                ? u.toJSON(null, t)
                                : u
                        );
                    else if (typeof o == 'object' && o.toJSON)
                        i[a] = o.toJSON(null, t);
                    else if (a === 'source') {
                        let u = t.get(o.input);
                        u == null && ((u = s), t.set(o.input, s), s++),
                            (i[a] = { inputId: u, start: o.start, end: o.end });
                    } else i[a] = o;
                }
                return n && (i.inputs = [...t.keys()].map(a => a.toJSON())), i;
            }
            positionInside(e) {
                let t = this.toString(),
                    i = this.source.start.column,
                    n = this.source.start.line;
                for (let s = 0; s < e; s++)
                    t[s] ===
                    `
`
                        ? ((i = 1), (n += 1))
                        : (i += 1);
                return { line: n, column: i };
            }
            positionBy(e) {
                let t = this.source.start;
                if (e.index) t = this.positionInside(e.index);
                else if (e.word) {
                    let i = this.toString().indexOf(e.word);
                    i !== -1 && (t = this.positionInside(i));
                }
                return t;
            }
            rangeBy(e) {
                let t = {
                        line: this.source.start.line,
                        column: this.source.start.column,
                    },
                    i = 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)),
                        (i = 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
                            ? (i = { line: e.end.line, column: e.end.column })
                            : e.endIndex
                            ? (i = this.positionInside(e.endIndex))
                            : e.index && (i = this.positionInside(e.index + 1));
                return (
                    (i.line < t.line ||
                        (i.line === t.line && i.column <= t.column)) &&
                        (i = { line: t.line, column: t.column + 1 }),
                    { start: t, end: i }
                );
            }
            getProxyProcessor() {
                return {
                    set(e, t, i) {
                        return (
                            e[t] === i ||
                                ((e[t] = i),
                                (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[qi]) {
                    this[qi] = !1;
                    let e = this;
                    for (; (e = e.parent); ) e[qi] = !1;
                }
            }
            get proxyOf() {
                return this;
            }
        };
        Xf.exports = Ii;
        Ii.default = Ii;
    });
    var Mr = v((eT, Kf) => {
        l();
        ('use strict');
        var p1 = Rr(),
            Ri = class extends p1 {
                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] === '$';
                }
            };
        Kf.exports = Ri;
        Ri.default = Ri;
    });
    var na = v((tT, Zf) => {
        l();
        Zf.exports = function (r, e) {
            return {
                generate: () => {
                    let t = '';
                    return (
                        r(e, i => {
                            t += i;
                        }),
                        [t]
                    );
                },
            };
        };
    });
    var Fr = v((rT, ec) => {
        l();
        ('use strict');
        var d1 = Rr(),
            Mi = class extends d1 {
                constructor(e) {
                    super(e);
                    this.type = 'comment';
                }
            };
        ec.exports = Mi;
        Mi.default = Mi;
    });
    var Ke = v((iT, uc) => {
        l();
        ('use strict');
        var { isClean: tc, my: rc } = Pi(),
            ic = Mr(),
            nc = Fr(),
            h1 = Rr(),
            sc,
            sa,
            aa,
            ac;
        function oc(r) {
            return r.map(
                e => (e.nodes && (e.nodes = oc(e.nodes)), delete e.source, e)
            );
        }
        function lc(r) {
            if (((r[tc] = !1), r.proxyOf.nodes))
                for (let e of r.proxyOf.nodes) lc(e);
        }
        var be = class extends h1 {
            push(e) {
                return (e.parent = this), this.proxyOf.nodes.push(e), this;
            }
            each(e) {
                if (!this.proxyOf.nodes) return;
                let t = this.getIterator(),
                    i,
                    n;
                for (
                    ;
                    this.indexes[t] < this.proxyOf.nodes.length &&
                    ((i = this.indexes[t]),
                    (n = e(this.proxyOf.nodes[i], i)),
                    n !== !1);

                )
                    this.indexes[t] += 1;
                return delete this.indexes[t], n;
            }
            walk(e) {
                return this.each((t, i) => {
                    let n;
                    try {
                        n = e(t, i);
                    } catch (s) {
                        throw t.addToError(s);
                    }
                    return n !== !1 && t.walk && (n = t.walk(e)), n;
                });
            }
            walkDecls(e, t) {
                return t
                    ? e instanceof RegExp
                        ? this.walk((i, n) => {
                              if (i.type === 'decl' && e.test(i.prop))
                                  return t(i, n);
                          })
                        : this.walk((i, n) => {
                              if (i.type === 'decl' && i.prop === e)
                                  return t(i, n);
                          })
                    : ((t = e),
                      this.walk((i, n) => {
                          if (i.type === 'decl') return t(i, n);
                      }));
            }
            walkRules(e, t) {
                return t
                    ? e instanceof RegExp
                        ? this.walk((i, n) => {
                              if (i.type === 'rule' && e.test(i.selector))
                                  return t(i, n);
                          })
                        : this.walk((i, n) => {
                              if (i.type === 'rule' && i.selector === e)
                                  return t(i, n);
                          })
                    : ((t = e),
                      this.walk((i, n) => {
                          if (i.type === 'rule') return t(i, n);
                      }));
            }
            walkAtRules(e, t) {
                return t
                    ? e instanceof RegExp
                        ? this.walk((i, n) => {
                              if (i.type === 'atrule' && e.test(i.name))
                                  return t(i, n);
                          })
                        : this.walk((i, n) => {
                              if (i.type === 'atrule' && i.name === e)
                                  return t(i, n);
                          })
                    : ((t = e),
                      this.walk((i, n) => {
                          if (i.type === 'atrule') return t(i, n);
                      }));
            }
            walkComments(e) {
                return this.walk((t, i) => {
                    if (t.type === 'comment') return e(t, i);
                });
            }
            append(...e) {
                for (let t of e) {
                    let i = this.normalize(t, this.last);
                    for (let n of i) this.proxyOf.nodes.push(n);
                }
                return this.markDirty(), this;
            }
            prepend(...e) {
                e = e.reverse();
                for (let t of e) {
                    let i = this.normalize(t, this.first, 'prepend').reverse();
                    for (let n of i) this.proxyOf.nodes.unshift(n);
                    for (let n in this.indexes)
                        this.indexes[n] = this.indexes[n] + i.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 i = this.index(e),
                    n = e === 0 ? 'prepend' : !1,
                    s = this.normalize(t, this.proxyOf.nodes[i], n).reverse();
                i = this.index(e);
                for (let o of s) this.proxyOf.nodes.splice(i, 0, o);
                let a;
                for (let o in this.indexes)
                    (a = this.indexes[o]),
                        i <= a && (this.indexes[o] = a + s.length);
                return this.markDirty(), this;
            }
            insertAfter(e, t) {
                let i = this.index(e),
                    n = this.normalize(t, this.proxyOf.nodes[i]).reverse();
                i = this.index(e);
                for (let a of n) this.proxyOf.nodes.splice(i + 1, 0, a);
                let s;
                for (let a in this.indexes)
                    (s = this.indexes[a]),
                        i < s && (this.indexes[a] = s + 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 i in this.indexes)
                    (t = this.indexes[i]), t >= e && (this.indexes[i] = 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, i) {
                return (
                    i || ((i = 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, i));
                    }),
                    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 = oc(sc(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 ic(e)]);
                } else if (e.selector) e = [new sa(e)];
                else if (e.name) e = [new aa(e)];
                else if (e.text) e = [new nc(e)];
                else throw new Error('Unknown node type in node creation');
                return e.map(
                    n => (
                        n[rc] || be.rebuild(n),
                        (n = n.proxyOf),
                        n.parent && n.parent.removeChild(n),
                        n[tc] && lc(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, i) {
                        return (
                            e[t] === i ||
                                ((e[t] = i),
                                (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'))
                                ? (...i) =>
                                      e[t](
                                          ...i.map(n =>
                                              typeof n == 'function'
                                                  ? (s, a) => n(s.toProxy(), a)
                                                  : n
                                          )
                                      )
                                : t === 'every' || t === 'some'
                                ? i => e[t]((n, ...s) => i(n.toProxy(), ...s))
                                : t === 'root'
                                ? () => e.root().toProxy()
                                : t === 'nodes'
                                ? e.nodes.map(i => i.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;
            }
        };
        be.registerParse = r => {
            sc = r;
        };
        be.registerRule = r => {
            sa = r;
        };
        be.registerAtRule = r => {
            aa = r;
        };
        be.registerRoot = r => {
            ac = r;
        };
        uc.exports = be;
        be.default = be;
        be.rebuild = r => {
            r.type === 'atrule'
                ? Object.setPrototypeOf(r, aa.prototype)
                : r.type === 'rule'
                ? Object.setPrototypeOf(r, sa.prototype)
                : r.type === 'decl'
                ? Object.setPrototypeOf(r, ic.prototype)
                : r.type === 'comment'
                ? Object.setPrototypeOf(r, nc.prototype)
                : r.type === 'root' && Object.setPrototypeOf(r, ac.prototype),
                (r[rc] = !0),
                r.nodes &&
                    r.nodes.forEach(e => {
                        be.rebuild(e);
                    });
        };
    });
    var Fi = v((nT, pc) => {
        l();
        ('use strict');
        var m1 = Ke(),
            fc,
            cc,
            _t = class extends m1 {
                constructor(e) {
                    super({ type: 'document', ...e });
                    this.nodes || (this.nodes = []);
                }
                toResult(e = {}) {
                    return new fc(new cc(), this, e).stringify();
                }
            };
        _t.registerLazyResult = r => {
            fc = r;
        };
        _t.registerProcessor = r => {
            cc = r;
        };
        pc.exports = _t;
        _t.default = _t;
    });
    var oa = v((sT, hc) => {
        l();
        ('use strict');
        var dc = {};
        hc.exports = function (e) {
            dc[e] ||
                ((dc[e] = !0),
                typeof console != 'undefined' &&
                    console.warn &&
                    console.warn(e));
        };
    });
    var la = v((aT, mc) => {
        l();
        ('use strict');
        var Ni = class {
            constructor(e, t = {}) {
                if (
                    ((this.type = 'warning'),
                    (this.text = e),
                    t.node && t.node.source)
                ) {
                    let i = t.node.rangeBy(t);
                    (this.line = i.start.line),
                        (this.column = i.start.column),
                        (this.endLine = i.end.line),
                        (this.endColumn = i.end.column);
                }
                for (let i in t) this[i] = t[i];
            }
            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;
            }
        };
        mc.exports = Ni;
        Ni.default = Ni;
    });
    var Bi = v((oT, gc) => {
        l();
        ('use strict');
        var g1 = la(),
            Li = class {
                constructor(e, t, i) {
                    (this.processor = e),
                        (this.messages = []),
                        (this.root = t),
                        (this.opts = i),
                        (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 i = new g1(e, t);
                    return this.messages.push(i), i;
                }
                warnings() {
                    return this.messages.filter(e => e.type === 'warning');
                }
                get content() {
                    return this.css;
                }
            };
        gc.exports = Li;
        Li.default = Li;
    });
    var xc = v((lT, vc) => {
        l();
        ('use strict');
        var ua = "'".charCodeAt(0),
            yc = '"'.charCodeAt(0),
            $i = '\\'.charCodeAt(0),
            wc = '/'.charCodeAt(0),
            zi = `
`.charCodeAt(0),
            Nr = ' '.charCodeAt(0),
            ji = '\f'.charCodeAt(0),
            Vi = '	'.charCodeAt(0),
            Ui = '\r'.charCodeAt(0),
            y1 = '['.charCodeAt(0),
            w1 = ']'.charCodeAt(0),
            b1 = '('.charCodeAt(0),
            v1 = ')'.charCodeAt(0),
            x1 = '{'.charCodeAt(0),
            k1 = '}'.charCodeAt(0),
            S1 = ';'.charCodeAt(0),
            C1 = '*'.charCodeAt(0),
            _1 = ':'.charCodeAt(0),
            A1 = '@'.charCodeAt(0),
            Wi = /[\t\n\f\r "#'()/;[\\\]{}]/g,
            Gi = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g,
            O1 = /.[\n"'(/\\]/,
            bc = /[\da-f]/i;
        vc.exports = function (e, t = {}) {
            let i = e.css.valueOf(),
                n = t.ignoreErrors,
                s,
                a,
                o,
                u,
                c,
                f,
                p,
                h,
                d,
                y,
                k = i.length,
                w = 0,
                b = [],
                x = [];
            function S() {
                return w;
            }
            function _(q) {
                throw e.error('Unclosed ' + q, w);
            }
            function D() {
                return x.length === 0 && w >= k;
            }
            function M(q) {
                if (x.length) return x.pop();
                if (w >= k) return;
                let F = q ? q.ignoreUnclosed : !1;
                switch (((s = i.charCodeAt(w)), s)) {
                    case zi:
                    case Nr:
                    case Vi:
                    case Ui:
                    case ji: {
                        a = w;
                        do (a += 1), (s = i.charCodeAt(a));
                        while (
                            s === Nr ||
                            s === zi ||
                            s === Vi ||
                            s === Ui ||
                            s === ji
                        );
                        (y = ['space', i.slice(w, a)]), (w = a - 1);
                        break;
                    }
                    case y1:
                    case w1:
                    case x1:
                    case k1:
                    case _1:
                    case S1:
                    case v1: {
                        let X = String.fromCharCode(s);
                        y = [X, X, w];
                        break;
                    }
                    case b1: {
                        if (
                            ((h = b.length ? b.pop()[1] : ''),
                            (d = i.charCodeAt(w + 1)),
                            h === 'url' &&
                                d !== ua &&
                                d !== yc &&
                                d !== Nr &&
                                d !== zi &&
                                d !== Vi &&
                                d !== ji &&
                                d !== Ui)
                        ) {
                            a = w;
                            do {
                                if (
                                    ((f = !1),
                                    (a = i.indexOf(')', a + 1)),
                                    a === -1)
                                )
                                    if (n || F) {
                                        a = w;
                                        break;
                                    } else _('bracket');
                                for (p = a; i.charCodeAt(p - 1) === $i; )
                                    (p -= 1), (f = !f);
                            } while (f);
                            (y = ['brackets', i.slice(w, a + 1), w, a]),
                                (w = a);
                        } else
                            (a = i.indexOf(')', w + 1)),
                                (u = i.slice(w, a + 1)),
                                a === -1 || O1.test(u)
                                    ? (y = ['(', '(', w])
                                    : ((y = ['brackets', u, w, a]), (w = a));
                        break;
                    }
                    case ua:
                    case yc: {
                        (o = s === ua ? "'" : '"'), (a = w);
                        do {
                            if (((f = !1), (a = i.indexOf(o, a + 1)), a === -1))
                                if (n || F) {
                                    a = w + 1;
                                    break;
                                } else _('string');
                            for (p = a; i.charCodeAt(p - 1) === $i; )
                                (p -= 1), (f = !f);
                        } while (f);
                        (y = ['string', i.slice(w, a + 1), w, a]), (w = a);
                        break;
                    }
                    case A1: {
                        (Wi.lastIndex = w + 1),
                            Wi.test(i),
                            Wi.lastIndex === 0
                                ? (a = i.length - 1)
                                : (a = Wi.lastIndex - 2),
                            (y = ['at-word', i.slice(w, a + 1), w, a]),
                            (w = a);
                        break;
                    }
                    case $i: {
                        for (a = w, c = !0; i.charCodeAt(a + 1) === $i; )
                            (a += 1), (c = !c);
                        if (
                            ((s = i.charCodeAt(a + 1)),
                            c &&
                                s !== wc &&
                                s !== Nr &&
                                s !== zi &&
                                s !== Vi &&
                                s !== Ui &&
                                s !== ji &&
                                ((a += 1), bc.test(i.charAt(a))))
                        ) {
                            for (; bc.test(i.charAt(a + 1)); ) a += 1;
                            i.charCodeAt(a + 1) === Nr && (a += 1);
                        }
                        (y = ['word', i.slice(w, a + 1), w, a]), (w = a);
                        break;
                    }
                    default: {
                        s === wc && i.charCodeAt(w + 1) === C1
                            ? ((a = i.indexOf('*/', w + 2) + 1),
                              a === 0 &&
                                  (n || F ? (a = i.length) : _('comment')),
                              (y = ['comment', i.slice(w, a + 1), w, a]),
                              (w = a))
                            : ((Gi.lastIndex = w + 1),
                              Gi.test(i),
                              Gi.lastIndex === 0
                                  ? (a = i.length - 1)
                                  : (a = Gi.lastIndex - 2),
                              (y = ['word', i.slice(w, a + 1), w, a]),
                              b.push(y),
                              (w = a));
                        break;
                    }
                }
                return w++, y;
            }
            function B(q) {
                x.push(q);
            }
            return { back: B, nextToken: M, endOfFile: D, position: S };
        };
    });
    var Hi = v((uT, Sc) => {
        l();
        ('use strict');
        var kc = Ke(),
            Lr = class extends kc {
                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)
                    );
                }
            };
        Sc.exports = Lr;
        Lr.default = Lr;
        kc.registerAtRule(Lr);
    });
    var At = v((fT, Oc) => {
        l();
        ('use strict');
        var Cc = Ke(),
            _c,
            Ac,
            dt = class extends Cc {
                constructor(e) {
                    super(e);
                    (this.type = 'root'), this.nodes || (this.nodes = []);
                }
                removeChild(e, t) {
                    let i = this.index(e);
                    return (
                        !t &&
                            i === 0 &&
                            this.nodes.length > 1 &&
                            (this.nodes[1].raws.before =
                                this.nodes[i].raws.before),
                        super.removeChild(e)
                    );
                }
                normalize(e, t, i) {
                    let n = super.normalize(e);
                    if (t) {
                        if (i === 'prepend')
                            this.nodes.length > 1
                                ? (t.raws.before = this.nodes[1].raws.before)
                                : delete t.raws.before;
                        else if (this.first !== t)
                            for (let s of n) s.raws.before = t.raws.before;
                    }
                    return n;
                }
                toResult(e = {}) {
                    return new _c(new Ac(), this, e).stringify();
                }
            };
        dt.registerLazyResult = r => {
            _c = r;
        };
        dt.registerProcessor = r => {
            Ac = r;
        };
        Oc.exports = dt;
        dt.default = dt;
        Cc.registerRoot(dt);
    });
    var fa = v((cT, Ec) => {
        l();
        ('use strict');
        var Br = {
            split(r, e, t) {
                let i = [],
                    n = '',
                    s = !1,
                    a = 0,
                    o = !1,
                    u = '',
                    c = !1;
                for (let f of r)
                    c
                        ? (c = !1)
                        : f === '\\'
                        ? (c = !0)
                        : o
                        ? f === u && (o = !1)
                        : f === '"' || f === "'"
                        ? ((o = !0), (u = f))
                        : f === '('
                        ? (a += 1)
                        : f === ')'
                        ? a > 0 && (a -= 1)
                        : a === 0 && e.includes(f) && (s = !0),
                        s
                            ? (n !== '' && i.push(n.trim()), (n = ''), (s = !1))
                            : (n += f);
                return (t || n !== '') && i.push(n.trim()), i;
            },
            space(r) {
                let e = [
                    ' ',
                    `
`,
                    '	',
                ];
                return Br.split(r, e);
            },
            comma(r) {
                return Br.split(r, [','], !0);
            },
        };
        Ec.exports = Br;
        Br.default = Br;
    });
    var Yi = v((pT, Pc) => {
        l();
        ('use strict');
        var Tc = Ke(),
            E1 = fa(),
            $r = class extends Tc {
                constructor(e) {
                    super(e);
                    (this.type = 'rule'), this.nodes || (this.nodes = []);
                }
                get selectors() {
                    return E1.comma(this.selector);
                }
                set selectors(e) {
                    let t = this.selector ? this.selector.match(/,\s*/) : null,
                        i = t ? t[0] : ',' + this.raw('between', 'beforeOpen');
                    this.selector = e.join(i);
                }
            };
        Pc.exports = $r;
        $r.default = $r;
        Tc.registerRule($r);
    });
    var Mc = v((dT, Rc) => {
        l();
        ('use strict');
        var T1 = Mr(),
            P1 = xc(),
            D1 = Fr(),
            q1 = Hi(),
            I1 = At(),
            Dc = Yi(),
            qc = { empty: !0, space: !0 };
        function R1(r) {
            for (let e = r.length - 1; e >= 0; e--) {
                let t = r[e],
                    i = t[3] || t[2];
                if (i) return i;
            }
        }
        var Ic = class {
            constructor(e) {
                (this.input = e),
                    (this.root = new I1()),
                    (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 = P1(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 D1();
                this.init(t, e[2]),
                    (t.source.end = this.getPosition(e[3] || e[2]));
                let i = e[1].slice(2, -2);
                if (/^\s*$/.test(i))
                    (t.text = ''), (t.raws.left = i), (t.raws.right = '');
                else {
                    let n = i.match(/^(\s*)([^]*\S)(\s*)$/);
                    (t.text = n[2]),
                        (t.raws.left = n[1]),
                        (t.raws.right = n[3]);
                }
            }
            emptyRule(e) {
                let t = new Dc();
                this.init(t, e[2]),
                    (t.selector = ''),
                    (t.raws.between = ''),
                    (this.current = t);
            }
            other(e) {
                let t = !1,
                    i = null,
                    n = !1,
                    s = null,
                    a = [],
                    o = e[1].startsWith('--'),
                    u = [],
                    c = e;
                for (; c; ) {
                    if (((i = c[0]), u.push(c), i === '(' || i === '['))
                        s || (s = c), a.push(i === '(' ? ')' : ']');
                    else if (o && n && i === '{') s || (s = c), a.push('}');
                    else if (a.length === 0)
                        if (i === ';')
                            if (n) {
                                this.decl(u, o);
                                return;
                            } else break;
                        else if (i === '{') {
                            this.rule(u);
                            return;
                        } else if (i === '}') {
                            this.tokenizer.back(u.pop()), (t = !0);
                            break;
                        } else i === ':' && (n = !0);
                    else
                        i === a[a.length - 1] &&
                            (a.pop(), a.length === 0 && (s = null));
                    c = this.tokenizer.nextToken();
                }
                if (
                    (this.tokenizer.endOfFile() && (t = !0),
                    a.length > 0 && this.unclosedBracket(s),
                    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 Dc();
                this.init(t, e[0][2]),
                    (t.raws.between = this.spacesAndCommentsFromEnd(e)),
                    this.raw(t, 'selector', e),
                    (this.current = t);
            }
            decl(e, t) {
                let i = new T1();
                this.init(i, e[0][2]);
                let n = e[e.length - 1];
                for (
                    n[0] === ';' && ((this.semicolon = !0), e.pop()),
                        i.source.end = this.getPosition(n[3] || n[2] || R1(e));
                    e[0][0] !== 'word';

                )
                    e.length === 1 && this.unknownWord(e),
                        (i.raws.before += e.shift()[1]);
                for (
                    i.source.start = this.getPosition(e[0][2]), i.prop = '';
                    e.length;

                ) {
                    let c = e[0][0];
                    if (c === ':' || c === 'space' || c === 'comment') break;
                    i.prop += e.shift()[1];
                }
                i.raws.between = '';
                let s;
                for (; e.length; )
                    if (((s = e.shift()), s[0] === ':')) {
                        i.raws.between += s[1];
                        break;
                    } else
                        s[0] === 'word' &&
                            /\w/.test(s[1]) &&
                            this.unknownWord([s]),
                            (i.raws.between += s[1]);
                (i.prop[0] === '_' || i.prop[0] === '*') &&
                    ((i.raws.before += i.prop[0]), (i.prop = i.prop.slice(1)));
                let a = [],
                    o;
                for (
                    ;
                    e.length &&
                    ((o = e[0][0]), !(o !== 'space' && o !== 'comment'));

                )
                    a.push(e.shift());
                this.precheckMissedSemicolon(e);
                for (let c = e.length - 1; c >= 0; c--) {
                    if (((s = e[c]), s[1].toLowerCase() === '!important')) {
                        i.important = !0;
                        let f = this.stringFrom(e, c);
                        (f = this.spacesFromEnd(e) + f),
                            f !== ' !important' && (i.raws.important = f);
                        break;
                    } else if (s[1].toLowerCase() === 'important') {
                        let f = e.slice(0),
                            p = '';
                        for (let h = c; h > 0; h--) {
                            let d = f[h][0];
                            if (p.trim().indexOf('!') === 0 && d !== 'space')
                                break;
                            p = f.pop()[1] + p;
                        }
                        p.trim().indexOf('!') === 0 &&
                            ((i.important = !0),
                            (i.raws.important = p),
                            (e = f));
                    }
                    if (s[0] !== 'space' && s[0] !== 'comment') break;
                }
                e.some(c => c[0] !== 'space' && c[0] !== 'comment') &&
                    ((i.raws.between += a.map(c => c[1]).join('')), (a = [])),
                    this.raw(i, 'value', a.concat(e), t),
                    i.value.includes(':') && !t && this.checkMissedSemicolon(e);
            }
            atrule(e) {
                let t = new q1();
                (t.name = e[1].slice(1)),
                    t.name === '' && this.unnamedAtrule(t, e),
                    this.init(t, e[2]);
                let i,
                    n,
                    s,
                    a = !1,
                    o = !1,
                    u = [],
                    c = [];
                for (; !this.tokenizer.endOfFile(); ) {
                    if (
                        ((e = this.tokenizer.nextToken()),
                        (i = e[0]),
                        i === '(' || i === '['
                            ? c.push(i === '(' ? ')' : ']')
                            : i === '{' && c.length > 0
                            ? c.push('}')
                            : i === c[c.length - 1] && c.pop(),
                        c.length === 0)
                    )
                        if (i === ';') {
                            (t.source.end = this.getPosition(e[2])),
                                (this.semicolon = !0);
                            break;
                        } else if (i === '{') {
                            o = !0;
                            break;
                        } else if (i === '}') {
                            if (u.length > 0) {
                                for (
                                    s = u.length - 1, n = u[s];
                                    n && n[0] === 'space';

                                )
                                    n = u[--s];
                                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()) {
                        a = !0;
                        break;
                    }
                }
                (t.raws.between = this.spacesAndCommentsFromEnd(u)),
                    u.length
                        ? ((t.raws.afterName =
                              this.spacesAndCommentsFromStart(u)),
                          this.raw(t, 'params', u),
                          a &&
                              ((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, i, n) {
                let s,
                    a,
                    o = i.length,
                    u = '',
                    c = !0,
                    f,
                    p;
                for (let h = 0; h < o; h += 1)
                    (s = i[h]),
                        (a = s[0]),
                        a === 'space' && h === o - 1 && !n
                            ? (c = !1)
                            : a === 'comment'
                            ? ((p = i[h - 1] ? i[h - 1][0] : 'empty'),
                              (f = i[h + 1] ? i[h + 1][0] : 'empty'),
                              !qc[p] && !qc[f]
                                  ? u.slice(-1) === ','
                                      ? (c = !1)
                                      : (u += s[1])
                                  : (c = !1))
                            : (u += s[1]);
                if (!c) {
                    let h = i.reduce((d, y) => d + y[1], '');
                    e.raws[t] = { value: u, raw: h };
                }
                e[t] = u;
            }
            spacesAndCommentsFromEnd(e) {
                let t,
                    i = '';
                for (
                    ;
                    e.length &&
                    ((t = e[e.length - 1][0]),
                    !(t !== 'space' && t !== 'comment'));

                )
                    i = e.pop()[1] + i;
                return i;
            }
            spacesAndCommentsFromStart(e) {
                let t,
                    i = '';
                for (
                    ;
                    e.length &&
                    ((t = e[0][0]), !(t !== 'space' && t !== 'comment'));

                )
                    i += e.shift()[1];
                return i;
            }
            spacesFromEnd(e) {
                let t,
                    i = '';
                for (; e.length && ((t = e[e.length - 1][0]), t === 'space'); )
                    i = e.pop()[1] + i;
                return i;
            }
            stringFrom(e, t) {
                let i = '';
                for (let n = t; n < e.length; n++) i += e[n][1];
                return e.splice(t, e.length - t), i;
            }
            colon(e) {
                let t = 0,
                    i,
                    n,
                    s;
                for (let [a, o] of e.entries()) {
                    if (
                        ((i = o),
                        (n = i[0]),
                        n === '(' && (t += 1),
                        n === ')' && (t -= 1),
                        t === 0 && n === ':')
                    )
                        if (!s) this.doubleColon(i);
                        else {
                            if (s[0] === 'word' && s[1] === 'progid') continue;
                            return a;
                        }
                    s = i;
                }
                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 i = 0,
                    n;
                for (
                    let s = t - 1;
                    s >= 0 &&
                    ((n = e[s]), !(n[0] !== 'space' && ((i += 1), i === 2)));
                    s--
                );
                throw this.input.error(
                    'Missed semicolon',
                    n[0] === 'word' ? n[3] + 1 : n[2]
                );
            }
        };
        Rc.exports = Ic;
    });
    var Fc = v(() => {
        l();
    });
    var Lc = v((gT, Nc) => {
        l();
        var M1 =
                'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict',
            F1 =
                (r, e = 21) =>
                (t = e) => {
                    let i = '',
                        n = t;
                    for (; n--; ) i += r[(Math.random() * r.length) | 0];
                    return i;
                },
            N1 = (r = 21) => {
                let e = '',
                    t = r;
                for (; t--; ) e += M1[(Math.random() * 64) | 0];
                return e;
            };
        Nc.exports = { nanoid: N1, customAlphabet: F1 };
    });
    var ca = v((yT, Bc) => {
        l();
        Bc.exports = {};
    });
    var Ji = v((wT, Vc) => {
        l();
        ('use strict');
        var { SourceMapConsumer: L1, SourceMapGenerator: B1 } = Fc(),
            { fileURLToPath: $c, pathToFileURL: Qi } = (Ks(), Uf),
            { resolve: pa, isAbsolute: da } = (lt(), zl),
            { nanoid: $1 } = Lc(),
            ha = Zs(),
            zc = Ti(),
            z1 = ca(),
            ma = Symbol('fromOffsetCache'),
            j1 = Boolean(L1 && B1),
            jc = Boolean(pa && da),
            zr = 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 &&
                            (!jc || /^\w+:\/\//.test(t.from) || da(t.from)
                                ? (this.file = t.from)
                                : (this.file = pa(t.from))),
                        jc && j1)
                    ) {
                        let i = new z1(this.css, t);
                        if (i.text) {
                            this.map = i;
                            let n = i.consumer().file;
                            !this.file && n && (this.file = this.mapResolve(n));
                        }
                    }
                    this.file || (this.id = '<input css ' + $1(6) + '>'),
                        this.map && (this.map.file = this.from);
                }
                fromOffset(e) {
                    let t, i;
                    if (this[ma]) i = this[ma];
                    else {
                        let s = this.css.split(`
`);
                        i = new Array(s.length);
                        let a = 0;
                        for (let o = 0, u = s.length; o < u; o++)
                            (i[o] = a), (a += s[o].length + 1);
                        this[ma] = i;
                    }
                    t = i[i.length - 1];
                    let n = 0;
                    if (e >= t) n = i.length - 1;
                    else {
                        let s = i.length - 2,
                            a;
                        for (; n < s; )
                            if (((a = n + ((s - n) >> 1)), e < i[a])) s = a - 1;
                            else if (e >= i[a + 1]) n = a + 1;
                            else {
                                n = a;
                                break;
                            }
                    }
                    return { line: n + 1, col: e - i[n] + 1 };
                }
                error(e, t, i, n = {}) {
                    let s, a, o;
                    if (t && typeof t == 'object') {
                        let c = t,
                            f = i;
                        if (typeof t.offset == 'number') {
                            let p = this.fromOffset(c.offset);
                            (t = p.line), (i = p.col);
                        } else (t = c.line), (i = c.column);
                        if (typeof f.offset == 'number') {
                            let p = this.fromOffset(f.offset);
                            (a = p.line), (o = p.col);
                        } else (a = f.line), (o = f.column);
                    } else if (!i) {
                        let c = this.fromOffset(t);
                        (t = c.line), (i = c.col);
                    }
                    let u = this.origin(t, i, a, o);
                    return (
                        u
                            ? (s = new zc(
                                  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
                              ))
                            : (s = new zc(
                                  e,
                                  a === void 0 ? t : { line: t, column: i },
                                  a === void 0 ? i : { line: a, column: o },
                                  this.css,
                                  this.file,
                                  n.plugin
                              )),
                        (s.input = {
                            line: t,
                            column: i,
                            endLine: a,
                            endColumn: o,
                            source: this.css,
                        }),
                        this.file &&
                            (Qi && (s.input.url = Qi(this.file).toString()),
                            (s.input.file = this.file)),
                        s
                    );
                }
                origin(e, t, i, n) {
                    if (!this.map) return !1;
                    let s = this.map.consumer(),
                        a = s.originalPositionFor({ line: e, column: t });
                    if (!a.source) return !1;
                    let o;
                    typeof i == 'number' &&
                        (o = s.originalPositionFor({ line: i, column: n }));
                    let u;
                    da(a.source)
                        ? (u = Qi(a.source))
                        : (u = new URL(
                              a.source,
                              this.map.consumer().sourceRoot ||
                                  Qi(this.map.mapFile)
                          ));
                    let c = {
                        url: u.toString(),
                        line: a.line,
                        column: a.column,
                        endLine: o && o.line,
                        endColumn: o && o.column,
                    };
                    if (u.protocol === 'file:')
                        if ($c) c.file = $c(u);
                        else
                            throw new Error(
                                'file: protocol is not available in this PostCSS build'
                            );
                    let f = s.sourceContentFor(a.source);
                    return f && (c.source = f), c;
                }
                mapResolve(e) {
                    return /^\w+:\/\//.test(e)
                        ? e
                        : pa(
                              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
                    );
                }
            };
        Vc.exports = zr;
        zr.default = zr;
        ha && ha.registerInput && ha.registerInput(zr);
    });
    var Ki = v((bT, Uc) => {
        l();
        ('use strict');
        var V1 = Ke(),
            U1 = Mc(),
            W1 = Ji();
        function Xi(r, e) {
            let t = new W1(r, e),
                i = new U1(t);
            try {
                i.parse();
            } catch (n) {
                throw n;
            }
            return i.root;
        }
        Uc.exports = Xi;
        Xi.default = Xi;
        V1.registerParse(Xi);
    });
    var wa = v((xT, Yc) => {
        l();
        ('use strict');
        var { isClean: Ie, my: G1 } = Pi(),
            H1 = na(),
            Y1 = Ir(),
            Q1 = Ke(),
            J1 = Fi(),
            vT = oa(),
            Wc = Bi(),
            X1 = Ki(),
            K1 = At(),
            Z1 = {
                document: 'Document',
                root: 'Root',
                atrule: 'AtRule',
                rule: 'Rule',
                decl: 'Declaration',
                comment: 'Comment',
            },
            ek = {
                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,
            },
            tk = { postcssPlugin: !0, prepare: !0, Once: !0 },
            Ot = 0;
        function jr(r) {
            return typeof r == 'object' && typeof r.then == 'function';
        }
        function Gc(r) {
            let e = !1,
                t = Z1[r.type];
            return (
                r.type === 'decl'
                    ? (e = r.prop.toLowerCase())
                    : r.type === 'atrule' && (e = r.name.toLowerCase()),
                e && r.append
                    ? [t, t + '-' + e, Ot, t + 'Exit', t + 'Exit-' + e]
                    : e
                    ? [t, t + '-' + e, t + 'Exit', t + 'Exit-' + e]
                    : r.append
                    ? [t, Ot, t + 'Exit']
                    : [t, t + 'Exit']
            );
        }
        function Hc(r) {
            let e;
            return (
                r.type === 'document'
                    ? (e = ['Document', Ot, 'DocumentExit'])
                    : r.type === 'root'
                    ? (e = ['Root', Ot, 'RootExit'])
                    : (e = Gc(r)),
                {
                    node: r,
                    events: e,
                    eventIndex: 0,
                    visitors: [],
                    visitorIndex: 0,
                    iterator: 0,
                }
            );
        }
        function ga(r) {
            return (r[Ie] = !1), r.nodes && r.nodes.forEach(e => ga(e)), r;
        }
        var ya = {},
            ze = class {
                constructor(e, t, i) {
                    (this.stringified = !1), (this.processed = !1);
                    let n;
                    if (
                        typeof t == 'object' &&
                        t !== null &&
                        (t.type === 'root' || t.type === 'document')
                    )
                        n = ga(t);
                    else if (t instanceof ze || t instanceof Wc)
                        (n = ga(t.root)),
                            t.map &&
                                (typeof i.map == 'undefined' && (i.map = {}),
                                i.map.inline || (i.map.inline = !1),
                                (i.map.prev = t.map));
                    else {
                        let s = X1;
                        i.syntax && (s = i.syntax.parse),
                            i.parser && (s = i.parser),
                            s.parse && (s = s.parse);
                        try {
                            n = s(t, i);
                        } catch (a) {
                            (this.processed = !0), (this.error = a);
                        }
                        n && !n[G1] && Q1.rebuild(n);
                    }
                    (this.result = new Wc(e, n, i)),
                        (this.helpers = {
                            ...ya,
                            result: this.result,
                            postcss: ya,
                        }),
                        (this.plugins = this.processor.plugins.map(s =>
                            typeof s == 'object' && s.prepare
                                ? { ...s, ...s.prepare(this.result) }
                                : s
                        ));
                }
                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 (jr(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 = Y1;
                    e.syntax && (t = e.syntax.stringify),
                        e.stringifier && (t = e.stringifier),
                        t.stringify && (t = t.stringify);
                    let n = new H1(
                        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 = Gc(e);
                    for (let i of t)
                        if (i === Ot)
                            e.nodes &&
                                e.each(n => {
                                    n[Ie] || this.walkSync(n);
                                });
                        else {
                            let n = this.listeners[i];
                            if (n && this.visitSync(n, e.toProxy())) return;
                        }
                }
                visitSync(e, t) {
                    for (let [i, n] of e) {
                        this.result.lastPlugin = i;
                        let s;
                        try {
                            s = n(t, this.helpers);
                        } catch (a) {
                            throw this.handleError(a, t.proxyOf);
                        }
                        if (
                            t.type !== 'root' &&
                            t.type !== 'document' &&
                            !t.parent
                        )
                            return !0;
                        if (jr(s)) 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(i =>
                                    e.Once(i, this.helpers)
                                );
                                return jr(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 i = this.result.lastPlugin;
                    try {
                        t && t.addToError(e),
                            (this.error = e),
                            e.name === 'CssSyntaxError' && !e.plugin
                                ? ((e.plugin = i.postcssPlugin), e.setMessage())
                                : i.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],
                            i = this.runOnRoot(t);
                        if (jr(i))
                            try {
                                await i;
                            } catch (n) {
                                throw this.handleError(n);
                            }
                    }
                    if ((this.prepareVisitors(), this.hasListener)) {
                        let e = this.result.root;
                        for (; !e[Ie]; ) {
                            e[Ie] = !0;
                            let t = [Hc(e)];
                            for (; t.length > 0; ) {
                                let i = this.visitTick(t);
                                if (jr(i))
                                    try {
                                        await i;
                                    } catch (n) {
                                        let s = t[t.length - 1].node;
                                        throw this.handleError(n, s);
                                    }
                            }
                        }
                        if (this.listeners.OnceExit)
                            for (let [t, i] of this.listeners.OnceExit) {
                                this.result.lastPlugin = t;
                                try {
                                    if (e.type === 'document') {
                                        let n = e.nodes.map(s =>
                                            i(s, this.helpers)
                                        );
                                        await Promise.all(n);
                                    } else await i(e, this.helpers);
                                } catch (n) {
                                    throw this.handleError(n);
                                }
                            }
                    }
                    return (this.processed = !0), this.stringify();
                }
                prepareVisitors() {
                    this.listeners = {};
                    let e = (t, i, n) => {
                        this.listeners[i] || (this.listeners[i] = []),
                            this.listeners[i].push([t, n]);
                    };
                    for (let t of this.plugins)
                        if (typeof t == 'object')
                            for (let i in t) {
                                if (!ek[i] && /^[A-Z]/.test(i))
                                    throw new Error(
                                        `Unknown event ${i} in ${t.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
                                    );
                                if (!tk[i])
                                    if (typeof t[i] == 'object')
                                        for (let n in t[i])
                                            n === '*'
                                                ? e(t, i, t[i][n])
                                                : e(
                                                      t,
                                                      i + '-' + n.toLowerCase(),
                                                      t[i][n]
                                                  );
                                    else
                                        typeof t[i] == 'function' &&
                                            e(t, i, t[i]);
                            }
                    this.hasListener = Object.keys(this.listeners).length > 0;
                }
                visitTick(e) {
                    let t = e[e.length - 1],
                        { node: i, visitors: n } = t;
                    if (
                        i.type !== 'root' &&
                        i.type !== 'document' &&
                        !i.parent
                    ) {
                        e.pop();
                        return;
                    }
                    if (n.length > 0 && t.visitorIndex < n.length) {
                        let [a, o] = n[t.visitorIndex];
                        (t.visitorIndex += 1),
                            t.visitorIndex === n.length &&
                                ((t.visitors = []), (t.visitorIndex = 0)),
                            (this.result.lastPlugin = a);
                        try {
                            return o(i.toProxy(), this.helpers);
                        } catch (u) {
                            throw this.handleError(u, i);
                        }
                    }
                    if (t.iterator !== 0) {
                        let a = t.iterator,
                            o;
                        for (; (o = i.nodes[i.indexes[a]]); )
                            if (((i.indexes[a] += 1), !o[Ie])) {
                                (o[Ie] = !0), e.push(Hc(o));
                                return;
                            }
                        (t.iterator = 0), delete i.indexes[a];
                    }
                    let s = t.events;
                    for (; t.eventIndex < s.length; ) {
                        let a = s[t.eventIndex];
                        if (((t.eventIndex += 1), a === Ot)) {
                            i.nodes &&
                                i.nodes.length &&
                                ((i[Ie] = !0), (t.iterator = i.getIterator()));
                            return;
                        } else if (this.listeners[a]) {
                            t.visitors = this.listeners[a];
                            return;
                        }
                    }
                    e.pop();
                }
            };
        ze.registerPostcss = r => {
            ya = r;
        };
        Yc.exports = ze;
        ze.default = ze;
        K1.registerLazyResult(ze);
        J1.registerLazyResult(ze);
    });
    var Jc = v((ST, Qc) => {
        l();
        ('use strict');
        var rk = na(),
            ik = Ir(),
            kT = oa(),
            nk = Ki(),
            sk = Bi(),
            Zi = class {
                constructor(e, t, i) {
                    (t = t.toString()),
                        (this.stringified = !1),
                        (this._processor = e),
                        (this._css = t),
                        (this._opts = i),
                        (this._map = void 0);
                    let n,
                        s = ik;
                    (this.result = new sk(this._processor, n, this._opts)),
                        (this.result.css = t);
                    let a = this;
                    Object.defineProperty(this.result, 'root', {
                        get() {
                            return a.root;
                        },
                    });
                    let o = new rk(s, 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 = nk;
                    try {
                        e = t(this._css, this._opts);
                    } catch (i) {
                        this.error = i;
                    }
                    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;
                }
            };
        Qc.exports = Zi;
        Zi.default = Zi;
    });
    var Kc = v((CT, Xc) => {
        l();
        ('use strict');
        var ak = Jc(),
            ok = wa(),
            lk = Fi(),
            uk = At(),
            Et = class {
                constructor(e = []) {
                    (this.version = '8.4.18'),
                        (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 ak(this, e, t)
                        : new ok(this, e, t);
                }
                normalize(e) {
                    let t = [];
                    for (let i of e)
                        if (
                            (i.postcss === !0
                                ? (i = i())
                                : i.postcss && (i = i.postcss),
                            typeof i == 'object' && Array.isArray(i.plugins))
                        )
                            t = t.concat(i.plugins);
                        else if (typeof i == 'object' && i.postcssPlugin)
                            t.push(i);
                        else if (typeof i == 'function') t.push(i);
                        else if (
                            !(typeof i == 'object' && (i.parse || i.stringify))
                        )
                            throw new Error(i + ' is not a PostCSS plugin');
                    return t;
                }
            };
        Xc.exports = Et;
        Et.default = Et;
        uk.registerProcessor(Et);
        lk.registerProcessor(Et);
    });
    var ep = v((_T, Zc) => {
        l();
        ('use strict');
        var fk = Mr(),
            ck = ca(),
            pk = Fr(),
            dk = Hi(),
            hk = Ji(),
            mk = At(),
            gk = Yi();
        function Vr(r, e) {
            if (Array.isArray(r)) return r.map(n => Vr(n));
            let { inputs: t, ...i } = r;
            if (t) {
                e = [];
                for (let n of t) {
                    let s = { ...n, __proto__: hk.prototype };
                    s.map && (s.map = { ...s.map, __proto__: ck.prototype }),
                        e.push(s);
                }
            }
            if ((i.nodes && (i.nodes = r.nodes.map(n => Vr(n, e))), i.source)) {
                let { inputId: n, ...s } = i.source;
                (i.source = s), n != null && (i.source.input = e[n]);
            }
            if (i.type === 'root') return new mk(i);
            if (i.type === 'decl') return new fk(i);
            if (i.type === 'rule') return new gk(i);
            if (i.type === 'comment') return new pk(i);
            if (i.type === 'atrule') return new dk(i);
            throw new Error('Unknown node type: ' + r.type);
        }
        Zc.exports = Vr;
        Vr.default = Vr;
    });
    var me = v((AT, op) => {
        l();
        ('use strict');
        var yk = Ti(),
            tp = Mr(),
            wk = wa(),
            bk = Ke(),
            ba = Kc(),
            vk = Ir(),
            xk = ep(),
            rp = Fi(),
            kk = la(),
            ip = Fr(),
            np = Hi(),
            Sk = Bi(),
            Ck = Ji(),
            _k = Ki(),
            Ak = fa(),
            sp = Yi(),
            ap = At(),
            Ok = Rr();
        function z(...r) {
            return (
                r.length === 1 && Array.isArray(r[0]) && (r = r[0]), new ba(r)
            );
        }
        z.plugin = function (e, t) {
            let i = !1;
            function n(...a) {
                console &&
                    console.warn &&
                    !i &&
                    ((i = !0),
                    console.warn(
                        e +
                            `: postcss.plugin was deprecated. Migration guide:
https://evilmartians.com/chronicles/postcss-8-plugin-migration`
                    ),
                    m.env.LANG &&
                        m.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(...a);
                return (
                    (o.postcssPlugin = e),
                    (o.postcssVersion = new ba().version),
                    o
                );
            }
            let s;
            return (
                Object.defineProperty(n, 'postcss', {
                    get() {
                        return s || (s = n()), s;
                    },
                }),
                (n.process = function (a, o, u) {
                    return z([n(u)]).process(a, o);
                }),
                n
            );
        };
        z.stringify = vk;
        z.parse = _k;
        z.fromJSON = xk;
        z.list = Ak;
        z.comment = r => new ip(r);
        z.atRule = r => new np(r);
        z.decl = r => new tp(r);
        z.rule = r => new sp(r);
        z.root = r => new ap(r);
        z.document = r => new rp(r);
        z.CssSyntaxError = yk;
        z.Declaration = tp;
        z.Container = bk;
        z.Processor = ba;
        z.Document = rp;
        z.Comment = ip;
        z.Warning = kk;
        z.AtRule = np;
        z.Result = Sk;
        z.Input = Ck;
        z.Rule = sp;
        z.Root = ap;
        z.Node = Ok;
        wk.registerPostcss(z);
        op.exports = z;
        z.default = z;
    });
    var G,
        j,
        OT,
        ET,
        TT,
        PT,
        DT,
        qT,
        IT,
        RT,
        MT,
        FT,
        NT,
        LT,
        BT,
        $T,
        zT,
        jT,
        VT,
        UT,
        WT,
        GT,
        HT,
        YT,
        QT,
        JT,
        Ze = A(() => {
            l();
            (G = J(me())),
                (j = G.default),
                (OT = G.default.stringify),
                (ET = G.default.fromJSON),
                (TT = G.default.plugin),
                (PT = G.default.parse),
                (DT = G.default.list),
                (qT = G.default.document),
                (IT = G.default.comment),
                (RT = G.default.atRule),
                (MT = G.default.rule),
                (FT = G.default.decl),
                (NT = G.default.root),
                (LT = G.default.CssSyntaxError),
                (BT = G.default.Declaration),
                ($T = G.default.Container),
                (zT = G.default.Processor),
                (jT = G.default.Document),
                (VT = G.default.Comment),
                (UT = G.default.Warning),
                (WT = G.default.AtRule),
                (GT = G.default.Result),
                (HT = G.default.Input),
                (YT = G.default.Rule),
                (QT = G.default.Root),
                (JT = G.default.Node);
        });
    var va = v((KT, lp) => {
        l();
        lp.exports = function (r, e, t, i, n) {
            for (e = e.split ? e.split('.') : e, i = 0; i < e.length; i++)
                r = r ? r[e[i]] : n;
            return r === n ? t : r;
        };
    });
    function je(r) {
        return ['fontSize', 'outline'].includes(r)
            ? e => (
                  typeof e == 'function' && (e = e({})),
                  Array.isArray(e) && (e = e[0]),
                  e
              )
            : r === 'fontFamily'
            ? e => {
                  typeof e == 'function' && (e = e({}));
                  let t = Array.isArray(e) && ee(e[1]) ? e[0] : e;
                  return Array.isArray(t) ? t.join(', ') : t;
              }
            : [
                  'boxShadow',
                  'transitionProperty',
                  'transitionDuration',
                  'transitionDelay',
                  'transitionTimingFunction',
                  'backgroundImage',
                  'backgroundSize',
                  'backgroundColor',
                  'cursor',
                  'animation',
              ].includes(r)
            ? e => (
                  typeof e == 'function' && (e = e({})),
                  Array.isArray(e) && (e = e.join(', ')),
                  e
              )
            : [
                  'gridTemplateColumns',
                  'gridTemplateRows',
                  'objectPosition',
              ].includes(r)
            ? e => (
                  typeof e == 'function' && (e = e({})),
                  typeof e == 'string' && (e = j.list.comma(e).join(' ')),
                  e
              )
            : (e, t = {}) => (typeof e == 'function' && (e = e(t)), e);
    }
    var Ur = A(() => {
        l();
        Ze();
        wt();
    });
    var mp = v((r5, _a) => {
        l();
        var { Rule: up, AtRule: Ek } = me(),
            fp = De();
        function xa(r, e) {
            let t;
            try {
                fp(i => {
                    t = i;
                }).processSync(r);
            } catch (i) {
                throw r.includes(':')
                    ? e
                        ? e.error('Missed semicolon')
                        : i
                    : e
                    ? e.error(i.message)
                    : i;
            }
            return t.at(0);
        }
        function cp(r, e) {
            let t = !1;
            return (
                r.each(i => {
                    if (i.type === 'nesting') {
                        let n = e.clone({});
                        i.value !== '&'
                            ? i.replaceWith(
                                  xa(i.value.replace('&', n.toString()))
                              )
                            : i.replaceWith(n),
                            (t = !0);
                    } else 'nodes' in i && i.nodes && cp(i, e) && (t = !0);
                }),
                t
            );
        }
        function pp(r, e) {
            let t = [];
            return (
                r.selectors.forEach(i => {
                    let n = xa(i, r);
                    e.selectors.forEach(s => {
                        if (!s) return;
                        let a = xa(s, e);
                        cp(a, n) ||
                            (a.prepend(fp.combinator({ value: ' ' })),
                            a.prepend(n.clone({}))),
                            t.push(a.toString());
                    });
                }),
                t
            );
        }
        function en(r, e) {
            let t = r.prev();
            for (e.after(r); t && t.type === 'comment'; ) {
                let i = t.prev();
                e.after(t), (t = i);
            }
            return r;
        }
        function Tk(r) {
            return function e(t, i, n, s = n) {
                let a = [];
                if (
                    (i.each(o => {
                        o.type === 'rule' && n
                            ? s && (o.selectors = pp(t, o))
                            : o.type === 'atrule' && o.nodes
                            ? r[o.name]
                                ? e(t, o, s)
                                : i[Sa] !== !1 && a.push(o)
                            : a.push(o);
                    }),
                    n && a.length)
                ) {
                    let o = t.clone({ nodes: [] });
                    for (let u of a) o.append(u);
                    i.prepend(o);
                }
            };
        }
        function ka(r, e, t) {
            let i = new up({ selector: r, nodes: [] });
            return i.append(e), t.after(i), i;
        }
        function dp(r, e) {
            let t = {};
            for (let i of r) t[i] = !0;
            if (e) for (let i of e) t[i.replace(/^@/, '')] = !0;
            return t;
        }
        function Pk(r) {
            r = r.trim();
            let e = r.match(/^\((.*)\)$/);
            if (!e) return { type: 'basic', selector: r };
            let t = e[1].match(/^(with(?:out)?):(.+)$/);
            if (t) {
                let i = t[1] === 'with',
                    n = Object.fromEntries(
                        t[2]
                            .trim()
                            .split(/\s+/)
                            .map(a => [a, !0])
                    );
                if (i && n.all) return { type: 'noop' };
                let s = a => !!n[a];
                return (
                    n.all
                        ? (s = () => !0)
                        : i && (s = a => (a === 'all' ? !1 : !n[a])),
                    { type: 'withrules', escapes: s }
                );
            }
            return { type: 'unknown' };
        }
        function Dk(r) {
            let e = [],
                t = r.parent;
            for (; t && t instanceof Ek; ) e.push(t), (t = t.parent);
            return e;
        }
        function qk(r) {
            let e = r[hp];
            if (!e) r.after(r.nodes);
            else {
                let t = r.nodes,
                    i,
                    n = -1,
                    s,
                    a,
                    o,
                    u = Dk(r);
                if (
                    (u.forEach((c, f) => {
                        if (e(c.name)) (i = c), (n = f), (a = o);
                        else {
                            let p = o;
                            (o = c.clone({ nodes: [] })),
                                p && o.append(p),
                                (s = s || o);
                        }
                    }),
                    i
                        ? a
                            ? (s.append(t), i.after(a))
                            : i.after(t)
                        : r.after(t),
                    r.next() && i)
                ) {
                    let c;
                    u.slice(0, n + 1).forEach((f, p, h) => {
                        let d = c;
                        (c = f.clone({ nodes: [] })), d && c.append(d);
                        let y = [],
                            w = (h[p - 1] || r).next();
                        for (; w; ) y.push(w), (w = w.next());
                        c.append(y);
                    }),
                        c && (a || t[t.length - 1]).after(c);
                }
            }
            r.remove();
        }
        var Sa = Symbol('rootRuleMergeSel'),
            hp = Symbol('rootRuleEscapes');
        function Ik(r) {
            let { params: e } = r,
                { type: t, selector: i, escapes: n } = Pk(e);
            if (t === 'unknown')
                throw r.error(
                    `Unknown @${r.name} parameter ${JSON.stringify(e)}`
                );
            if (t === 'basic' && i) {
                let s = new up({ selector: i, nodes: r.nodes });
                r.removeAll(), r.append(s);
            }
            (r[hp] = n), (r[Sa] = n ? !n('all') : t === 'noop');
        }
        var Ca = Symbol('hasRootRule');
        _a.exports = (r = {}) => {
            let e = dp(['media', 'supports', 'layer'], r.bubble),
                t = Tk(e),
                i = dp(
                    [
                        'document',
                        'font-face',
                        'keyframes',
                        '-webkit-keyframes',
                        '-moz-keyframes',
                    ],
                    r.unwrap
                ),
                n = (r.rootRuleName || 'at-root').replace(/^@/, ''),
                s = r.preserveEmpty;
            return {
                postcssPlugin: 'postcss-nested',
                Once(a) {
                    a.walkAtRules(n, o => {
                        Ik(o), (a[Ca] = !0);
                    });
                },
                Rule(a) {
                    let o = !1,
                        u = a,
                        c = !1,
                        f = [];
                    a.each(p => {
                        p.type === 'rule'
                            ? (f.length &&
                                  ((u = ka(a.selector, f, u)), (f = [])),
                              (c = !0),
                              (o = !0),
                              (p.selectors = pp(a, p)),
                              (u = en(p, u)))
                            : p.type === 'atrule'
                            ? (f.length &&
                                  ((u = ka(a.selector, f, u)), (f = [])),
                              p.name === n
                                  ? ((o = !0),
                                    t(a, p, !0, p[Sa]),
                                    (u = en(p, u)))
                                  : e[p.name]
                                  ? ((c = !0),
                                    (o = !0),
                                    t(a, p, !0),
                                    (u = en(p, u)))
                                  : i[p.name]
                                  ? ((c = !0),
                                    (o = !0),
                                    t(a, p, !1),
                                    (u = en(p, u)))
                                  : c && f.push(p))
                            : p.type === 'decl' && c && f.push(p);
                    }),
                        f.length && (u = ka(a.selector, f, u)),
                        o &&
                            s !== !0 &&
                            ((a.raws.semicolon = !0),
                            a.nodes.length === 0 && a.remove());
                },
                RootExit(a) {
                    a[Ca] && (a.walkAtRules(n, qk), (a[Ca] = !1));
                },
            };
        };
        _a.exports.postcss = !0;
    });
    var bp = v((i5, wp) => {
        l();
        ('use strict');
        var gp = /-(\w|$)/g,
            yp = (r, e) => e.toUpperCase(),
            Rk = r => (
                (r = r.toLowerCase()),
                r === 'float'
                    ? 'cssFloat'
                    : r.startsWith('-ms-')
                    ? r.substr(1).replace(gp, yp)
                    : r.replace(gp, yp)
            );
        wp.exports = Rk;
    });
    var Ea = v((n5, vp) => {
        l();
        var Mk = bp(),
            Fk = {
                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 Aa(r) {
            return typeof r.nodes == 'undefined' ? !0 : Oa(r);
        }
        function Oa(r) {
            let e,
                t = {};
            return (
                r.each(i => {
                    if (i.type === 'atrule')
                        (e = '@' + i.name),
                            i.params && (e += ' ' + i.params),
                            typeof t[e] == 'undefined'
                                ? (t[e] = Aa(i))
                                : Array.isArray(t[e])
                                ? t[e].push(Aa(i))
                                : (t[e] = [t[e], Aa(i)]);
                    else if (i.type === 'rule') {
                        let n = Oa(i);
                        if (t[i.selector])
                            for (let s in n) t[i.selector][s] = n[s];
                        else t[i.selector] = n;
                    } else if (i.type === 'decl') {
                        i.prop[0] === '-' && i.prop[1] === '-'
                            ? (e = i.prop)
                            : (e = Mk(i.prop));
                        let n = i.value;
                        !isNaN(i.value) && Fk[e] && (n = parseFloat(i.value)),
                            i.important && (n += ' !important'),
                            typeof t[e] == 'undefined'
                                ? (t[e] = n)
                                : Array.isArray(t[e])
                                ? t[e].push(n)
                                : (t[e] = [t[e], n]);
                    }
                }),
                t
            );
        }
        vp.exports = Oa;
    });
    var tn = v((s5, Cp) => {
        l();
        var Wr = me(),
            xp = /\s*!important\s*$/i,
            Nk = {
                '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 Lk(r) {
            return r
                .replace(/([A-Z])/g, '-$1')
                .replace(/^ms-/, '-ms-')
                .toLowerCase();
        }
        function kp(r, e, t) {
            t === !1 ||
                t === null ||
                (e.startsWith('--') || (e = Lk(e)),
                typeof t == 'number' &&
                    (t === 0 || Nk[e] ? (t = t.toString()) : (t += 'px')),
                e === 'css-float' && (e = 'float'),
                xp.test(t)
                    ? ((t = t.replace(xp, '')),
                      r.push(Wr.decl({ prop: e, value: t, important: !0 })))
                    : r.push(Wr.decl({ prop: e, value: t })));
        }
        function Sp(r, e, t) {
            let i = Wr.atRule({ name: e[1], params: e[3] || '' });
            typeof t == 'object' && ((i.nodes = []), Ta(t, i)), r.push(i);
        }
        function Ta(r, e) {
            let t, i, n;
            for (t in r)
                if (((i = r[t]), !(i === null || typeof i == 'undefined')))
                    if (t[0] === '@') {
                        let s = t.match(/@(\S+)(\s+([\W\w]*)\s*)?/);
                        if (Array.isArray(i)) for (let a of i) Sp(e, s, a);
                        else Sp(e, s, i);
                    } else if (Array.isArray(i)) for (let s of i) kp(e, t, s);
                    else
                        typeof i == 'object'
                            ? ((n = Wr.rule({ selector: t })),
                              Ta(i, n),
                              e.push(n))
                            : kp(e, t, i);
        }
        Cp.exports = function (r) {
            let e = Wr.root();
            return Ta(r, e), e;
        };
    });
    var Pa = v((a5, _p) => {
        l();
        var Bk = Ea();
        _p.exports = function (e) {
            return (
                console &&
                    console.warn &&
                    e.warnings().forEach(t => {
                        let i = t.plugin || 'PostCSS';
                        console.warn(i + ': ' + t.text);
                    }),
                Bk(e.root)
            );
        };
    });
    var Op = v((o5, Ap) => {
        l();
        var $k = me(),
            zk = Pa(),
            jk = tn();
        Ap.exports = function (e) {
            let t = $k(e);
            return async i => {
                let n = await t.process(i, { parser: jk, from: void 0 });
                return zk(n);
            };
        };
    });
    var Tp = v((l5, Ep) => {
        l();
        var Vk = me(),
            Uk = Pa(),
            Wk = tn();
        Ep.exports = function (r) {
            let e = Vk(r);
            return t => {
                let i = e.process(t, { parser: Wk, from: void 0 });
                return Uk(i);
            };
        };
    });
    var Dp = v((u5, Pp) => {
        l();
        var Gk = Ea(),
            Hk = tn(),
            Yk = Op(),
            Qk = Tp();
        Pp.exports = { objectify: Gk, parse: Hk, async: Yk, sync: Qk };
    });
    var Tt,
        qp,
        f5,
        c5,
        p5,
        d5,
        Ip = A(() => {
            l();
            (Tt = J(Dp())),
                (qp = Tt.default),
                (f5 = Tt.default.objectify),
                (c5 = Tt.default.parse),
                (p5 = Tt.default.async),
                (d5 = Tt.default.sync);
        });
    function Pt(r) {
        return Array.isArray(r)
            ? r.flatMap(
                  e =>
                      j([(0, Rp.default)({ bubble: ['screen'] })]).process(e, {
                          parser: qp,
                      }).root.nodes
              )
            : Pt([r]);
    }
    var Rp,
        Da = A(() => {
            l();
            Ze();
            Rp = J(mp());
            Ip();
        });
    function Dt(r, e, t = !1) {
        return (0, Mp.default)(i => {
            i.walkClasses(n => {
                let s = n.value,
                    a = t && s.startsWith('-');
                n.value = a ? `-${r}${s.slice(1)}` : `${r}${s}`;
            });
        }).processSync(e);
    }
    var Mp,
        rn = A(() => {
            l();
            Mp = J(De());
        });
    function ve(r) {
        let e = Fp.default.className();
        return (e.value = r), pt(e?.raws?.value ?? e.value);
    }
    var Fp,
        qt = A(() => {
            l();
            Fp = J(De());
            Si();
        });
    function qa(r) {
        return pt(`.${ve(r)}`);
    }
    function nn(r, e) {
        return qa(Gr(r, e));
    }
    function Gr(r, e) {
        return e === 'DEFAULT'
            ? r
            : e === '-' || e === '-DEFAULT'
            ? `-${r}`
            : e.startsWith('-')
            ? `-${r}${e}`
            : e.startsWith('/')
            ? `${r}${e}`
            : `${r}-${e}`;
    }
    var Ia = A(() => {
        l();
        qt();
        Si();
    });
    function T(r, e = [[r, [r]]], { filterDefault: t = !1, ...i } = {}) {
        let n = je(r);
        return function ({ matchUtilities: s, theme: a }) {
            for (let o of e) {
                let u = Array.isArray(o[0]) ? o : [o];
                s(
                    u.reduce(
                        (c, [f, p]) =>
                            Object.assign(c, {
                                [f]: h =>
                                    p.reduce(
                                        (d, y) =>
                                            Array.isArray(y)
                                                ? Object.assign(d, {
                                                      [y[0]]: y[1],
                                                  })
                                                : Object.assign(d, {
                                                      [y]: n(h),
                                                  }),
                                        {}
                                    ),
                            }),
                        {}
                    ),
                    {
                        ...i,
                        values: t
                            ? Object.fromEntries(
                                  Object.entries(a(r) ?? {}).filter(
                                      ([c]) => c !== 'DEFAULT'
                                  )
                              )
                            : a(r),
                    }
                );
            }
        };
    }
    var Np = A(() => {
        l();
        Ur();
    });
    function et(r) {
        return (
            (r = Array.isArray(r) ? r : [r]),
            r
                .map(e => {
                    let t = e.values.map(i =>
                        i.raw !== void 0
                            ? i.raw
                            : [
                                  i.min && `(min-width: ${i.min})`,
                                  i.max && `(max-width: ${i.max})`,
                              ]
                                  .filter(Boolean)
                                  .join(' and ')
                    );
                    return e.not ? `not all and ${t}` : t;
                })
                .join(', ')
        );
    }
    var sn = A(() => {
        l();
    });
    function Ra(r) {
        return r.split(rS).map(t => {
            let i = t.trim(),
                n = { value: i },
                s = i.split(iS),
                a = new Set();
            for (let o of s)
                !a.has('DIRECTIONS') && Jk.has(o)
                    ? ((n.direction = o), a.add('DIRECTIONS'))
                    : !a.has('PLAY_STATES') && Xk.has(o)
                    ? ((n.playState = o), a.add('PLAY_STATES'))
                    : !a.has('FILL_MODES') && Kk.has(o)
                    ? ((n.fillMode = o), a.add('FILL_MODES'))
                    : !a.has('ITERATION_COUNTS') && (Zk.has(o) || nS.test(o))
                    ? ((n.iterationCount = o), a.add('ITERATION_COUNTS'))
                    : (!a.has('TIMING_FUNCTION') && eS.has(o)) ||
                      (!a.has('TIMING_FUNCTION') &&
                          tS.some(u => o.startsWith(`${u}(`)))
                    ? ((n.timingFunction = o), a.add('TIMING_FUNCTION'))
                    : !a.has('DURATION') && Lp.test(o)
                    ? ((n.duration = o), a.add('DURATION'))
                    : !a.has('DELAY') && Lp.test(o)
                    ? ((n.delay = o), a.add('DELAY'))
                    : a.has('NAME')
                    ? (n.unknown || (n.unknown = []), n.unknown.push(o))
                    : ((n.name = o), a.add('NAME'));
            return n;
        });
    }
    var Jk,
        Xk,
        Kk,
        Zk,
        eS,
        tS,
        rS,
        iS,
        Lp,
        nS,
        Bp = A(() => {
            l();
            (Jk = new Set([
                'normal',
                'reverse',
                'alternate',
                'alternate-reverse',
            ])),
                (Xk = new Set(['running', 'paused'])),
                (Kk = new Set(['none', 'forwards', 'backwards', 'both'])),
                (Zk = new Set(['infinite'])),
                (eS = new Set([
                    'linear',
                    'ease',
                    'ease-in',
                    'ease-out',
                    'ease-in-out',
                    'step-start',
                    'step-end',
                ])),
                (tS = ['cubic-bezier', 'steps']),
                (rS = /\,(?![^(]*\))/g),
                (iS = /\ +(?![^(]*\))/g),
                (Lp = /^(-?[\d.]+m?s)$/),
                (nS = /^(\d+)$/);
        });
    var $p,
        Z,
        zp = A(() => {
            l();
            ($p = r =>
                Object.assign(
                    {},
                    ...Object.entries(r ?? {}).flatMap(([e, t]) =>
                        typeof t == 'object'
                            ? Object.entries($p(t)).map(([i, n]) => ({
                                  [e + (i === 'DEFAULT' ? '' : `-${i}`)]: n,
                              }))
                            : [{ [`${e}`]: t }]
                    )
                )),
                (Z = $p);
        });
    var Vp,
        jp = A(() => {
            Vp = '3.2.4';
        });
    function tt(r, e = !0) {
        return Array.isArray(r)
            ? r.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 [i, n] = t;
                  return (
                      (i = i.toString()),
                      typeof n == 'string'
                          ? {
                                name: i,
                                not: !1,
                                values: [{ min: n, max: void 0 }],
                            }
                          : Array.isArray(n)
                          ? { name: i, not: !1, values: n.map(s => Wp(s)) }
                          : { name: i, not: !1, values: [Wp(n)] }
                  );
              })
            : tt(Object.entries(r ?? {}), !1);
    }
    function an(r) {
        return r.values.length !== 1
            ? { result: !1, reason: 'multiple-values' }
            : r.values[0].raw !== void 0
            ? { result: !1, reason: 'raw-values' }
            : r.values[0].min !== void 0 && r.values[0].max !== void 0
            ? { result: !1, reason: 'min-and-max' }
            : { result: !0, reason: null };
    }
    function Up(r, e, t) {
        let i = on(e, r),
            n = on(t, r),
            s = an(i),
            a = an(n);
        if (s.reason === 'multiple-values' || a.reason === 'multiple-values')
            throw new Error(
                'Attempted to sort a screen with multiple values. This should never happen. Please open a bug report.'
            );
        if (s.reason === 'raw-values' || a.reason === 'raw-values')
            throw new Error(
                'Attempted to sort a screen with raw values. This should never happen. Please open a bug report.'
            );
        if (s.reason === 'min-and-max' || a.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 } = i.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 [p, h] = r === 'min' ? [o, c] : [f, u];
        return p - h;
    }
    function on(r, e) {
        return typeof r == 'object'
            ? r
            : { name: 'arbitrary-screen', values: [{ [e]: r }] };
    }
    function Wp({ 'min-width': r, min: e = r, max: t, raw: i } = {}) {
        return { min: e, max: t, raw: i };
    }
    var ln = A(() => {
        l();
    });
    function un(r, e) {
        r.walkDecls(t => {
            if (e.includes(t.prop)) {
                t.remove();
                return;
            }
            for (let i of e)
                t.value.includes(`/ var(${i})`) &&
                    (t.value = t.value.replace(`/ var(${i})`, ''));
        });
    }
    var Gp = A(() => {
        l();
    });
    var ue,
        Ee,
        Re,
        Me,
        Hp,
        Yp = A(() => {
            l();
            Ge();
            lt();
            Ze();
            Np();
            sn();
            qt();
            Bp();
            zp();
            Cr();
            Gs();
            wt();
            Ur();
            jp();
            Ae();
            ln();
            Bs();
            Gp();
            $e();
            Er();
            (ue = {
                pseudoElementVariants: ({ addVariant: r }) => {
                    r('first-letter', '&::first-letter'),
                        r('first-line', '&::first-line'),
                        r('marker', [
                            ({ container: e }) => (
                                un(e, ['--tw-text-opacity']), '& *::marker'
                            ),
                            ({ container: e }) => (
                                un(e, ['--tw-text-opacity']), '&::marker'
                            ),
                        ]),
                        r('selection', ['& *::selection', '&::selection']),
                        r('file', '&::file-selector-button'),
                        r('placeholder', '&::placeholder'),
                        r('backdrop', '&::backdrop'),
                        r(
                            'before',
                            ({ container: e }) => (
                                e.walkRules(t => {
                                    let i = !1;
                                    t.walkDecls('content', () => {
                                        i = !0;
                                    }),
                                        i ||
                                            t.prepend(
                                                j.decl({
                                                    prop: 'content',
                                                    value: 'var(--tw-content)',
                                                })
                                            );
                                }),
                                '&::before'
                            )
                        ),
                        r(
                            'after',
                            ({ container: e }) => (
                                e.walkRules(t => {
                                    let i = !1;
                                    t.walkDecls('content', () => {
                                        i = !0;
                                    }),
                                        i ||
                                            t.prepend(
                                                j.decl({
                                                    prop: 'content',
                                                    value: 'var(--tw-content)',
                                                })
                                            );
                                }),
                                '&::after'
                            )
                        );
                },
                pseudoClassVariants: ({
                    addVariant: r,
                    matchVariant: e,
                    config: t,
                }) => {
                    let i = [
                        ['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 }) => (
                                un(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',
                            K(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, a] of i)
                        r(s, o => (typeof a == 'function' ? a(o) : a));
                    let n = {
                        group: (s, { modifier: a }) =>
                            a
                                ? [`:merge(.group\\/${a})`, ' &']
                                : [':merge(.group)', ' &'],
                        peer: (s, { modifier: a }) =>
                            a
                                ? [`:merge(.peer\\/${a})`, ' ~ &']
                                : [':merge(.peer)', ' ~ &'],
                    };
                    for (let [s, a] of Object.entries(n))
                        e(
                            s,
                            (o = '', u) => {
                                let c = H(typeof o == 'function' ? o(u) : o);
                                c.includes('&') || (c = '&' + c);
                                let [f, p] = a('', u);
                                return c.replace(
                                    /&(\S+)?/g,
                                    (h, d = '') => f + d + p
                                );
                            },
                            { values: Object.fromEntries(i) }
                        );
                },
                directionVariants: ({ addVariant: r }) => {
                    r(
                        'ltr',
                        () => (
                            N.warn('rtl-experimental', [
                                'The RTL features in Tailwind CSS are currently in preview.',
                                'Preview features are not covered by semver, and may be improved in breaking ways at any time.',
                            ]),
                            '[dir="ltr"] &'
                        )
                    ),
                        r(
                            'rtl',
                            () => (
                                N.warn('rtl-experimental', [
                                    'The RTL features in Tailwind CSS are currently in preview.',
                                    'Preview features are not covered by semver, and may be improved in breaking ways at any time.',
                                ]),
                                '[dir="rtl"] &'
                            )
                        );
                },
                reducedMotionVariants: ({ addVariant: r }) => {
                    r(
                        'motion-safe',
                        '@media (prefers-reduced-motion: no-preference)'
                    ),
                        r(
                            'motion-reduce',
                            '@media (prefers-reduced-motion: reduce)'
                        );
                },
                darkVariants: ({ config: r, addVariant: e }) => {
                    let [t, i = '.dark'] = [].concat(r('darkMode', 'media'));
                    t === !1 &&
                        ((t = 'media'),
                        N.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 === 'class'
                            ? e('dark', `${i} &`)
                            : t === 'media' &&
                              e('dark', '@media (prefers-color-scheme: dark)');
                },
                printVariant: ({ addVariant: r }) => {
                    r('print', '@media print');
                },
                screenVariants: ({
                    theme: r,
                    addVariant: e,
                    matchVariant: t,
                }) => {
                    let i = r('screens') ?? {},
                        n = Object.values(i).every(b => typeof b == 'string'),
                        s = tt(r('screens')),
                        a = new Set([]);
                    function o(b) {
                        return b.match(/(\D+)$/)?.[1] ?? '(none)';
                    }
                    function u(b) {
                        b !== void 0 && a.add(o(b));
                    }
                    function c(b) {
                        return u(b), a.size === 1;
                    }
                    for (let b of s) for (let x of b.values) u(x.min), u(x.max);
                    let f = a.size <= 1;
                    function p(b) {
                        return Object.fromEntries(
                            s
                                .filter(x => an(x).result)
                                .map(x => {
                                    let { min: S, max: _ } = x.values[0];
                                    if (b === 'min' && S !== void 0) return x;
                                    if (b === 'min' && _ !== void 0)
                                        return { ...x, not: !x.not };
                                    if (b === 'max' && _ !== void 0) return x;
                                    if (b === 'max' && S !== void 0)
                                        return { ...x, not: !x.not };
                                })
                                .map(x => [x.name, x])
                        );
                    }
                    function h(b) {
                        return (x, S) => Up(b, x.value, S.value);
                    }
                    let d = h('max'),
                        y = h('min');
                    function k(b) {
                        return x => {
                            if (n)
                                if (f) {
                                    if (typeof x == 'string' && !c(x))
                                        return (
                                            N.warn('minmax-have-mixed-units', [
                                                'The `min-*` and `max-*` variants are not supported with a `screens` configuration containing mixed units.',
                                            ]),
                                            []
                                        );
                                } else
                                    return (
                                        N.warn('mixed-screen-units', [
                                            'The `min-*` and `max-*` variants are not supported with a `screens` configuration containing mixed units.',
                                        ]),
                                        []
                                    );
                            else
                                return (
                                    N.warn('complex-screen-config', [
                                        'The `min-*` and `max-*` variants are not supported with a `screens` configuration containing objects.',
                                    ]),
                                    []
                                );
                            return [`@media ${et(on(x, b))}`];
                        };
                    }
                    t('max', k('max'), { sort: d, values: n ? p('max') : {} });
                    let w = 'min-screens';
                    for (let b of s)
                        e(b.name, `@media ${et(b)}`, {
                            id: w,
                            sort: n && f ? y : void 0,
                            value: b,
                        });
                    t('min', k('min'), { id: w, sort: y });
                },
                supportsVariants: ({ matchVariant: r, theme: e }) => {
                    r(
                        'supports',
                        (t = '') => {
                            let i = H(t),
                                n = /^\w*\s*\(/.test(i);
                            return (
                                (i = n
                                    ? i.replace(/\b(and|or|not)\b/g, ' $1 ')
                                    : i),
                                n
                                    ? `@supports ${i}`
                                    : (i.includes(':') ||
                                          (i = `${i}: var(--tw)`),
                                      (i.startsWith('(') && i.endsWith(')')) ||
                                          (i = `(${i})`),
                                      `@supports ${i}`)
                            );
                        },
                        { values: e('supports') ?? {} }
                    );
                },
                ariaVariants: ({ matchVariant: r, theme: e }) => {
                    r('aria', t => `&[aria-${H(t)}]`, {
                        values: e('aria') ?? {},
                    }),
                        r(
                            'group-aria',
                            (t, { modifier: i }) =>
                                i
                                    ? `:merge(.group\\/${i})[aria-${H(t)}] &`
                                    : `:merge(.group)[aria-${H(t)}] &`,
                            { values: e('aria') ?? {} }
                        ),
                        r(
                            'peer-aria',
                            (t, { modifier: i }) =>
                                i
                                    ? `:merge(.peer\\/${i})[aria-${H(t)}] ~ &`
                                    : `:merge(.peer)[aria-${H(t)}] ~ &`,
                            { values: e('aria') ?? {} }
                        );
                },
                dataVariants: ({ matchVariant: r, theme: e }) => {
                    r('data', t => `&[data-${H(t)}]`, {
                        values: e('data') ?? {},
                    }),
                        r(
                            'group-data',
                            (t, { modifier: i }) =>
                                i
                                    ? `:merge(.group\\/${i})[data-${H(t)}] &`
                                    : `:merge(.group)[data-${H(t)}] &`,
                            { values: e('data') ?? {} }
                        ),
                        r(
                            'peer-data',
                            (t, { modifier: i }) =>
                                i
                                    ? `:merge(.peer\\/${i})[data-${H(t)}] ~ &`
                                    : `:merge(.peer)[data-${H(t)}] ~ &`,
                            { values: e('data') ?? {} }
                        );
                },
                orientationVariants: ({ addVariant: r }) => {
                    r('portrait', '@media (orientation: portrait)'),
                        r('landscape', '@media (orientation: landscape)');
                },
                prefersContrastVariants: ({ addVariant: r }) => {
                    r('contrast-more', '@media (prefers-contrast: more)'),
                        r('contrast-less', '@media (prefers-contrast: less)');
                },
            }),
                (Ee = [
                    '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(' ')),
                (Re = [
                    '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(' ')),
                (Me = [
                    '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(' ')),
                (Hp = {
                    preflight: ({ addBase: r }) => {
                        let e = j.parse(
                            `*,::after,::before{box-sizing:border-box;border-width:0;border-style:solid;border-color:theme('borderColor.DEFAULT', currentColor)}::after,::before{--tw-content:''}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, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:theme('fontFamily.sans[1].fontFeatureSettings', normal)}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-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-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}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}`
                        );
                        r([
                            j.comment({
                                text: `! tailwindcss v${Vp} | MIT License | https://tailwindcss.com`,
                            }),
                            ...e.nodes,
                        ]);
                    },
                    container: (() => {
                        function r(t = []) {
                            return t
                                .flatMap(i => i.values.map(n => n.min))
                                .filter(i => i !== void 0);
                        }
                        function e(t, i, n) {
                            if (typeof n == 'undefined') return [];
                            if (!(typeof n == 'object' && n !== null))
                                return [
                                    {
                                        screen: 'DEFAULT',
                                        minWidth: 0,
                                        padding: n,
                                    },
                                ];
                            let s = [];
                            n.DEFAULT &&
                                s.push({
                                    screen: 'DEFAULT',
                                    minWidth: 0,
                                    padding: n.DEFAULT,
                                });
                            for (let a of t)
                                for (let o of i)
                                    for (let { min: u } of o.values)
                                        u === a &&
                                            s.push({
                                                minWidth: a,
                                                padding: n[o.name],
                                            });
                            return s;
                        }
                        return function ({ addComponents: t, theme: i }) {
                            let n = tt(i('container.screens', i('screens'))),
                                s = r(n),
                                a = e(s, n, i('container.padding')),
                                o = c => {
                                    let f = a.find(p => p.minWidth === c);
                                    return f
                                        ? {
                                              paddingRight: f.padding,
                                              paddingLeft: f.padding,
                                          }
                                        : {};
                                },
                                u = Array.from(
                                    new Set(
                                        s
                                            .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%' },
                                        i('container.center', !1)
                                            ? {
                                                  marginRight: 'auto',
                                                  marginLeft: 'auto',
                                              }
                                            : {},
                                        o(0)
                                    ),
                                },
                                ...u,
                            ]);
                        };
                    })(),
                    accessibility: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.pointer-events-none': {
                                'pointer-events': 'none',
                            },
                            '.pointer-events-auto': {
                                'pointer-events': 'auto',
                            },
                        });
                    },
                    visibility: ({ addUtilities: r }) => {
                        r({
                            '.visible': { visibility: 'visible' },
                            '.invisible': { visibility: 'hidden' },
                            '.collapse': { visibility: 'collapse' },
                        });
                    },
                    position: ({ addUtilities: r }) => {
                        r({
                            '.static': { position: 'static' },
                            '.fixed': { position: 'fixed' },
                            '.absolute': { position: 'absolute' },
                            '.relative': { position: 'relative' },
                            '.sticky': { position: 'sticky' },
                        });
                    },
                    inset: T(
                        'inset',
                        [
                            ['inset', ['top', 'right', 'bottom', 'left']],
                            [
                                ['inset-x', ['left', 'right']],
                                ['inset-y', ['top', 'bottom']],
                            ],
                            [
                                ['top', ['top']],
                                ['right', ['right']],
                                ['bottom', ['bottom']],
                                ['left', ['left']],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    isolation: ({ addUtilities: r }) => {
                        r({
                            '.isolate': { isolation: 'isolate' },
                            '.isolation-auto': { isolation: 'auto' },
                        });
                    },
                    zIndex: T('zIndex', [['z', ['zIndex']]], {
                        supportsNegativeValues: !0,
                    }),
                    order: T('order', void 0, { supportsNegativeValues: !0 }),
                    gridColumn: T('gridColumn', [['col', ['gridColumn']]]),
                    gridColumnStart: T('gridColumnStart', [
                        ['col-start', ['gridColumnStart']],
                    ]),
                    gridColumnEnd: T('gridColumnEnd', [
                        ['col-end', ['gridColumnEnd']],
                    ]),
                    gridRow: T('gridRow', [['row', ['gridRow']]]),
                    gridRowStart: T('gridRowStart', [
                        ['row-start', ['gridRowStart']],
                    ]),
                    gridRowEnd: T('gridRowEnd', [['row-end', ['gridRowEnd']]]),
                    float: ({ addUtilities: r }) => {
                        r({
                            '.float-right': { float: 'right' },
                            '.float-left': { float: 'left' },
                            '.float-none': { float: 'none' },
                        });
                    },
                    clear: ({ addUtilities: r }) => {
                        r({
                            '.clear-left': { clear: 'left' },
                            '.clear-right': { clear: 'right' },
                            '.clear-both': { clear: 'both' },
                            '.clear-none': { clear: 'none' },
                        });
                    },
                    margin: T(
                        'margin',
                        [
                            ['m', ['margin']],
                            [
                                ['mx', ['margin-left', 'margin-right']],
                                ['my', ['margin-top', 'margin-bottom']],
                            ],
                            [
                                ['mt', ['margin-top']],
                                ['mr', ['margin-right']],
                                ['mb', ['margin-bottom']],
                                ['ml', ['margin-left']],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    boxSizing: ({ addUtilities: r }) => {
                        r({
                            '.box-border': { 'box-sizing': 'border-box' },
                            '.box-content': { 'box-sizing': 'content-box' },
                        });
                    },
                    display: ({ addUtilities: r }) => {
                        r({
                            '.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: T('aspectRatio', [
                        ['aspect', ['aspect-ratio']],
                    ]),
                    height: T('height', [['h', ['height']]]),
                    maxHeight: T('maxHeight', [['max-h', ['maxHeight']]]),
                    minHeight: T('minHeight', [['min-h', ['minHeight']]]),
                    width: T('width', [['w', ['width']]]),
                    minWidth: T('minWidth', [['min-w', ['minWidth']]]),
                    maxWidth: T('maxWidth', [['max-w', ['maxWidth']]]),
                    flex: T('flex'),
                    flexShrink: T('flexShrink', [
                        ['flex-shrink', ['flex-shrink']],
                        ['shrink', ['flex-shrink']],
                    ]),
                    flexGrow: T('flexGrow', [
                        ['flex-grow', ['flex-grow']],
                        ['grow', ['flex-grow']],
                    ]),
                    flexBasis: T('flexBasis', [['basis', ['flex-basis']]]),
                    tableLayout: ({ addUtilities: r }) => {
                        r({
                            '.table-auto': { 'table-layout': 'auto' },
                            '.table-fixed': { 'table-layout': 'fixed' },
                        });
                    },
                    borderCollapse: ({ addUtilities: r }) => {
                        r({
                            '.border-collapse': {
                                'border-collapse': 'collapse',
                            },
                            '.border-separate': {
                                'border-collapse': 'separate',
                            },
                        });
                    },
                    borderSpacing: ({
                        addDefaults: r,
                        matchUtilities: e,
                        theme: t,
                    }) => {
                        r('border-spacing', {
                            '--tw-border-spacing-x': 0,
                            '--tw-border-spacing-y': 0,
                        }),
                            e(
                                {
                                    'border-spacing': i => ({
                                        '--tw-border-spacing-x': i,
                                        '--tw-border-spacing-y': i,
                                        '@defaults border-spacing': {},
                                        'border-spacing':
                                            'var(--tw-border-spacing-x) var(--tw-border-spacing-y)',
                                    }),
                                    'border-spacing-x': i => ({
                                        '--tw-border-spacing-x': i,
                                        '@defaults border-spacing': {},
                                        'border-spacing':
                                            'var(--tw-border-spacing-x) var(--tw-border-spacing-y)',
                                    }),
                                    'border-spacing-y': i => ({
                                        '--tw-border-spacing-y': i,
                                        '@defaults border-spacing': {},
                                        'border-spacing':
                                            'var(--tw-border-spacing-x) var(--tw-border-spacing-y)',
                                    }),
                                },
                                { values: t('borderSpacing') }
                            );
                    },
                    transformOrigin: T('transformOrigin', [
                        ['origin', ['transformOrigin']],
                    ]),
                    translate: T(
                        'translate',
                        [
                            [
                                [
                                    'translate-x',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-translate-x',
                                        ['transform', Ee],
                                    ],
                                ],
                                [
                                    'translate-y',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-translate-y',
                                        ['transform', Ee],
                                    ],
                                ],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    rotate: T(
                        'rotate',
                        [
                            [
                                'rotate',
                                [
                                    ['@defaults transform', {}],
                                    '--tw-rotate',
                                    ['transform', Ee],
                                ],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    skew: T(
                        'skew',
                        [
                            [
                                [
                                    'skew-x',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-skew-x',
                                        ['transform', Ee],
                                    ],
                                ],
                                [
                                    'skew-y',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-skew-y',
                                        ['transform', Ee],
                                    ],
                                ],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    scale: T(
                        'scale',
                        [
                            [
                                'scale',
                                [
                                    ['@defaults transform', {}],
                                    '--tw-scale-x',
                                    '--tw-scale-y',
                                    ['transform', Ee],
                                ],
                            ],
                            [
                                [
                                    'scale-x',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-scale-x',
                                        ['transform', Ee],
                                    ],
                                ],
                                [
                                    'scale-y',
                                    [
                                        ['@defaults transform', {}],
                                        '--tw-scale-y',
                                        ['transform', Ee],
                                    ],
                                ],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    transform: ({ addDefaults: r, addUtilities: e }) => {
                        r('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: Ee,
                                },
                                '.transform-cpu': { transform: Ee },
                                '.transform-gpu': {
                                    transform: Ee.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: r, theme: e, config: t }) => {
                        let i = s => `${t('prefix')}${ve(s)}`,
                            n = Object.fromEntries(
                                Object.entries(e('keyframes') ?? {}).map(
                                    ([s, a]) => [
                                        s,
                                        { [`@keyframes ${i(s)}`]: a },
                                    ]
                                )
                            );
                        r(
                            {
                                animate: s => {
                                    let a = Ra(s);
                                    return [
                                        ...a.flatMap(o => n[o.name]),
                                        {
                                            animation: a
                                                .map(({ name: o, value: u }) =>
                                                    o === void 0 ||
                                                    n[o] === void 0
                                                        ? u
                                                        : u.replace(o, i(o))
                                                )
                                                .join(', '),
                                        },
                                    ];
                                },
                            },
                            { values: e('animation') }
                        );
                    },
                    cursor: T('cursor'),
                    touchAction: ({ addDefaults: r, addUtilities: e }) => {
                        r('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: r }) => {
                        r({
                            '.select-none': { 'user-select': 'none' },
                            '.select-text': { 'user-select': 'text' },
                            '.select-all': { 'user-select': 'all' },
                            '.select-auto': { 'user-select': 'auto' },
                        });
                    },
                    resize: ({ addUtilities: r }) => {
                        r({
                            '.resize-none': { resize: 'none' },
                            '.resize-y': { resize: 'vertical' },
                            '.resize-x': { resize: 'horizontal' },
                            '.resize': { resize: 'both' },
                        });
                    },
                    scrollSnapType: ({ addDefaults: r, addUtilities: e }) => {
                        r('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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.snap-normal': { 'scroll-snap-stop': 'normal' },
                            '.snap-always': { 'scroll-snap-stop': 'always' },
                        });
                    },
                    scrollMargin: T(
                        'scrollMargin',
                        [
                            ['scroll-m', ['scroll-margin']],
                            [
                                [
                                    'scroll-mx',
                                    [
                                        'scroll-margin-left',
                                        'scroll-margin-right',
                                    ],
                                ],
                                [
                                    'scroll-my',
                                    [
                                        'scroll-margin-top',
                                        'scroll-margin-bottom',
                                    ],
                                ],
                            ],
                            [
                                ['scroll-mt', ['scroll-margin-top']],
                                ['scroll-mr', ['scroll-margin-right']],
                                ['scroll-mb', ['scroll-margin-bottom']],
                                ['scroll-ml', ['scroll-margin-left']],
                            ],
                        ],
                        { supportsNegativeValues: !0 }
                    ),
                    scrollPadding: T('scrollPadding', [
                        ['scroll-p', ['scroll-padding']],
                        [
                            [
                                'scroll-px',
                                ['scroll-padding-left', 'scroll-padding-right'],
                            ],
                            [
                                'scroll-py',
                                ['scroll-padding-top', 'scroll-padding-bottom'],
                            ],
                        ],
                        [
                            ['scroll-pt', ['scroll-padding-top']],
                            ['scroll-pr', ['scroll-padding-right']],
                            ['scroll-pb', ['scroll-padding-bottom']],
                            ['scroll-pl', ['scroll-padding-left']],
                        ],
                    ]),
                    listStylePosition: ({ addUtilities: r }) => {
                        r({
                            '.list-inside': { 'list-style-position': 'inside' },
                            '.list-outside': {
                                'list-style-position': 'outside',
                            },
                        });
                    },
                    listStyleType: T('listStyleType', [
                        ['list', ['listStyleType']],
                    ]),
                    appearance: ({ addUtilities: r }) => {
                        r({ '.appearance-none': { appearance: 'none' } });
                    },
                    columns: T('columns', [['columns', ['columns']]]),
                    breakBefore: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: T('gridAutoColumns', [
                        ['auto-cols', ['gridAutoColumns']],
                    ]),
                    gridAutoFlow: ({ addUtilities: r }) => {
                        r({
                            '.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: T('gridAutoRows', [
                        ['auto-rows', ['gridAutoRows']],
                    ]),
                    gridTemplateColumns: T('gridTemplateColumns', [
                        ['grid-cols', ['gridTemplateColumns']],
                    ]),
                    gridTemplateRows: T('gridTemplateRows', [
                        ['grid-rows', ['gridTemplateRows']],
                    ]),
                    flexDirection: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.flex-wrap': { 'flex-wrap': 'wrap' },
                            '.flex-wrap-reverse': {
                                'flex-wrap': 'wrap-reverse',
                            },
                            '.flex-nowrap': { 'flex-wrap': 'nowrap' },
                        });
                    },
                    placeContent: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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',
                            },
                        });
                    },
                    alignItems: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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',
                            },
                        });
                    },
                    justifyItems: ({ addUtilities: r }) => {
                        r({
                            '.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: T('gap', [
                        ['gap', ['gap']],
                        [
                            ['gap-x', ['columnGap']],
                            ['gap-y', ['rowGap']],
                        ],
                    ]),
                    space: ({
                        matchUtilities: r,
                        addUtilities: e,
                        theme: t,
                    }) => {
                        r(
                            {
                                'space-x': i => (
                                    (i = i === '0' ? '0px' : i),
                                    {
                                        '& > :not([hidden]) ~ :not([hidden])': {
                                            '--tw-space-x-reverse': '0',
                                            'margin-right': `calc(${i} * var(--tw-space-x-reverse))`,
                                            'margin-left': `calc(${i} * calc(1 - var(--tw-space-x-reverse)))`,
                                        },
                                    }
                                ),
                                'space-y': i => (
                                    (i = i === '0' ? '0px' : i),
                                    {
                                        '& > :not([hidden]) ~ :not([hidden])': {
                                            '--tw-space-y-reverse': '0',
                                            'margin-top': `calc(${i} * calc(1 - var(--tw-space-y-reverse)))`,
                                            'margin-bottom': `calc(${i} * 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: r,
                        addUtilities: e,
                        theme: t,
                    }) => {
                        r(
                            {
                                'divide-x': i => (
                                    (i = i === '0' ? '0px' : i),
                                    {
                                        '& > :not([hidden]) ~ :not([hidden])': {
                                            '@defaults border-width': {},
                                            '--tw-divide-x-reverse': '0',
                                            'border-right-width': `calc(${i} * var(--tw-divide-x-reverse))`,
                                            'border-left-width': `calc(${i} * calc(1 - var(--tw-divide-x-reverse)))`,
                                        },
                                    }
                                ),
                                'divide-y': i => (
                                    (i = i === '0' ? '0px' : i),
                                    {
                                        '& > :not([hidden]) ~ :not([hidden])': {
                                            '@defaults border-width': {},
                                            '--tw-divide-y-reverse': '0',
                                            'border-top-width': `calc(${i} * calc(1 - var(--tw-divide-y-reverse)))`,
                                            'border-bottom-width': `calc(${i} * 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: r }) => {
                        r({
                            '.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: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                divide: i =>
                                    t('divideOpacity')
                                        ? {
                                              ['& > :not([hidden]) ~ :not([hidden])']:
                                                  le({
                                                      color: i,
                                                      property: 'border-color',
                                                      variable:
                                                          '--tw-divide-opacity',
                                                  }),
                                          }
                                        : {
                                              ['& > :not([hidden]) ~ :not([hidden])']:
                                                  { 'border-color': $(i) },
                                          },
                            },
                            {
                                values: (({ DEFAULT: i, ...n }) => n)(
                                    Z(e('divideColor'))
                                ),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    divideOpacity: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'divide-opacity': t => ({
                                    ['& > :not([hidden]) ~ :not([hidden])']: {
                                        '--tw-divide-opacity': t,
                                    },
                                }),
                            },
                            { values: e('divideOpacity') }
                        );
                    },
                    placeSelf: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.scroll-auto': { 'scroll-behavior': 'auto' },
                            '.scroll-smooth': { 'scroll-behavior': 'smooth' },
                        });
                    },
                    textOverflow: ({ addUtilities: r }) => {
                        r({
                            '.truncate': {
                                overflow: 'hidden',
                                'text-overflow': 'ellipsis',
                                'white-space': 'nowrap',
                            },
                            '.overflow-ellipsis': {
                                'text-overflow': 'ellipsis',
                            },
                            '.text-ellipsis': { 'text-overflow': 'ellipsis' },
                            '.text-clip': { 'text-overflow': 'clip' },
                        });
                    },
                    whitespace: ({ addUtilities: r }) => {
                        r({
                            '.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',
                            },
                        });
                    },
                    wordBreak: ({ addUtilities: r }) => {
                        r({
                            '.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: T('borderRadius', [
                        ['rounded', ['border-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-tl', ['border-top-left-radius']],
                            ['rounded-tr', ['border-top-right-radius']],
                            ['rounded-br', ['border-bottom-right-radius']],
                            ['rounded-bl', ['border-bottom-left-radius']],
                        ],
                    ]),
                    borderWidth: T(
                        '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-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: r }) => {
                        r({
                            '.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: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                border: i =>
                                    t('borderOpacity')
                                        ? le({
                                              color: i,
                                              property: 'border-color',
                                              variable: '--tw-border-opacity',
                                          })
                                        : { 'border-color': $(i) },
                            },
                            {
                                values: (({ DEFAULT: i, ...n }) => n)(
                                    Z(e('borderColor'))
                                ),
                                type: ['color', 'any'],
                            }
                        ),
                            r(
                                {
                                    'border-x': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property: [
                                                      'border-left-color',
                                                      'border-right-color',
                                                  ],
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : {
                                                  'border-left-color': $(i),
                                                  'border-right-color': $(i),
                                              },
                                    'border-y': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property: [
                                                      'border-top-color',
                                                      'border-bottom-color',
                                                  ],
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : {
                                                  'border-top-color': $(i),
                                                  'border-bottom-color': $(i),
                                              },
                                },
                                {
                                    values: (({ DEFAULT: i, ...n }) => n)(
                                        Z(e('borderColor'))
                                    ),
                                    type: ['color', 'any'],
                                }
                            ),
                            r(
                                {
                                    'border-t': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property: 'border-top-color',
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : { 'border-top-color': $(i) },
                                    'border-r': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property:
                                                      'border-right-color',
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : { 'border-right-color': $(i) },
                                    'border-b': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property:
                                                      'border-bottom-color',
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : { 'border-bottom-color': $(i) },
                                    'border-l': i =>
                                        t('borderOpacity')
                                            ? le({
                                                  color: i,
                                                  property: 'border-left-color',
                                                  variable:
                                                      '--tw-border-opacity',
                                              })
                                            : { 'border-left-color': $(i) },
                                },
                                {
                                    values: (({ DEFAULT: i, ...n }) => n)(
                                        Z(e('borderColor'))
                                    ),
                                    type: ['color', 'any'],
                                }
                            );
                    },
                    borderOpacity: T('borderOpacity', [
                        ['border-opacity', ['--tw-border-opacity']],
                    ]),
                    backgroundColor: ({
                        matchUtilities: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                bg: i =>
                                    t('backgroundOpacity')
                                        ? le({
                                              color: i,
                                              property: 'background-color',
                                              variable: '--tw-bg-opacity',
                                          })
                                        : { 'background-color': $(i) },
                            },
                            {
                                values: Z(e('backgroundColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    backgroundOpacity: T('backgroundOpacity', [
                        ['bg-opacity', ['--tw-bg-opacity']],
                    ]),
                    backgroundImage: T(
                        'backgroundImage',
                        [['bg', ['background-image']]],
                        { type: ['lookup', 'image', 'url'] }
                    ),
                    gradientColorStops: (() => {
                        function r(e) {
                            return qe(e, 0, 'rgb(255 255 255 / 0)');
                        }
                        return function ({ matchUtilities: e, theme: t }) {
                            let i = {
                                values: Z(t('gradientColorStops')),
                                type: ['color', 'any'],
                            };
                            e(
                                {
                                    from: n => {
                                        let s = r(n);
                                        return {
                                            '--tw-gradient-from': $(n, 'from'),
                                            '--tw-gradient-to': s,
                                            '--tw-gradient-stops':
                                                'var(--tw-gradient-from), var(--tw-gradient-to)',
                                        };
                                    },
                                },
                                i
                            ),
                                e(
                                    {
                                        via: n => ({
                                            '--tw-gradient-to': r(n),
                                            '--tw-gradient-stops': `var(--tw-gradient-from), ${$(
                                                n,
                                                'via'
                                            )}, var(--tw-gradient-to)`,
                                        }),
                                    },
                                    i
                                ),
                                e(
                                    {
                                        to: n => ({
                                            '--tw-gradient-to': $(n, 'to'),
                                        }),
                                    },
                                    i
                                );
                        };
                    })(),
                    boxDecorationBreak: ({ addUtilities: r }) => {
                        r({
                            '.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: T(
                        'backgroundSize',
                        [['bg', ['background-size']]],
                        { type: ['lookup', 'length', 'percentage', 'size'] }
                    ),
                    backgroundAttachment: ({ addUtilities: r }) => {
                        r({
                            '.bg-fixed': { 'background-attachment': 'fixed' },
                            '.bg-local': { 'background-attachment': 'local' },
                            '.bg-scroll': { 'background-attachment': 'scroll' },
                        });
                    },
                    backgroundClip: ({ addUtilities: r }) => {
                        r({
                            '.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: T(
                        'backgroundPosition',
                        [['bg', ['background-position']]],
                        {
                            type: [
                                'lookup',
                                ['position', { preferOnConflict: !0 }],
                            ],
                        }
                    ),
                    backgroundRepeat: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.bg-origin-border': {
                                'background-origin': 'border-box',
                            },
                            '.bg-origin-padding': {
                                'background-origin': 'padding-box',
                            },
                            '.bg-origin-content': {
                                'background-origin': 'content-box',
                            },
                        });
                    },
                    fill: ({ matchUtilities: r, theme: e }) => {
                        r(
                            { fill: t => ({ fill: $(t) }) },
                            { values: Z(e('fill')), type: ['color', 'any'] }
                        );
                    },
                    stroke: ({ matchUtilities: r, theme: e }) => {
                        r(
                            { stroke: t => ({ stroke: $(t) }) },
                            {
                                values: Z(e('stroke')),
                                type: ['color', 'url', 'any'],
                            }
                        );
                    },
                    strokeWidth: T(
                        'strokeWidth',
                        [['stroke', ['stroke-width']]],
                        { type: ['length', 'number', 'percentage'] }
                    ),
                    objectFit: ({ addUtilities: r }) => {
                        r({
                            '.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: T('objectPosition', [
                        ['object', ['object-position']],
                    ]),
                    padding: T('padding', [
                        ['p', ['padding']],
                        [
                            ['px', ['padding-left', 'padding-right']],
                            ['py', ['padding-top', 'padding-bottom']],
                        ],
                        [
                            ['pt', ['padding-top']],
                            ['pr', ['padding-right']],
                            ['pb', ['padding-bottom']],
                            ['pl', ['padding-left']],
                        ],
                    ]),
                    textAlign: ({ addUtilities: r }) => {
                        r({
                            '.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: T('textIndent', [['indent', ['text-indent']]], {
                        supportsNegativeValues: !0,
                    }),
                    verticalAlign: ({ addUtilities: r, matchUtilities: e }) => {
                        r({
                            '.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: r, theme: e }) => {
                        r(
                            {
                                font: t => {
                                    let [i, n = {}] =
                                            Array.isArray(t) && ee(t[1])
                                                ? t
                                                : [t],
                                        { fontFeatureSettings: s } = n;
                                    return {
                                        'font-family': Array.isArray(i)
                                            ? i.join(', ')
                                            : i,
                                        ...(s === void 0
                                            ? {}
                                            : { 'font-feature-settings': s }),
                                    };
                                },
                            },
                            {
                                values: e('fontFamily'),
                                type: ['lookup', 'generic-name', 'family-name'],
                            }
                        );
                    },
                    fontSize: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                text: t => {
                                    let [i, n] = Array.isArray(t) ? t : [t],
                                        {
                                            lineHeight: s,
                                            letterSpacing: a,
                                            fontWeight: o,
                                        } = ee(n) ? n : { lineHeight: n };
                                    return {
                                        'font-size': i,
                                        ...(s === void 0
                                            ? {}
                                            : { 'line-height': s }),
                                        ...(a === void 0
                                            ? {}
                                            : { 'letter-spacing': a }),
                                        ...(o === void 0
                                            ? {}
                                            : { 'font-weight': o }),
                                    };
                                },
                            },
                            {
                                values: e('fontSize'),
                                type: [
                                    'absolute-size',
                                    'relative-size',
                                    'length',
                                    'percentage',
                                ],
                            }
                        );
                    },
                    fontWeight: T('fontWeight', [['font', ['fontWeight']]], {
                        type: ['lookup', 'number', 'any'],
                    }),
                    textTransform: ({ addUtilities: r }) => {
                        r({
                            '.uppercase': { 'text-transform': 'uppercase' },
                            '.lowercase': { 'text-transform': 'lowercase' },
                            '.capitalize': { 'text-transform': 'capitalize' },
                            '.normal-case': { 'text-transform': 'none' },
                        });
                    },
                    fontStyle: ({ addUtilities: r }) => {
                        r({
                            '.italic': { 'font-style': 'italic' },
                            '.not-italic': { 'font-style': 'normal' },
                        });
                    },
                    fontVariantNumeric: ({
                        addDefaults: r,
                        addUtilities: e,
                    }) => {
                        let t =
                            'var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)';
                        r('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: T('lineHeight', [['leading', ['lineHeight']]]),
                    letterSpacing: T(
                        'letterSpacing',
                        [['tracking', ['letterSpacing']]],
                        { supportsNegativeValues: !0 }
                    ),
                    textColor: ({
                        matchUtilities: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                text: i =>
                                    t('textOpacity')
                                        ? le({
                                              color: i,
                                              property: 'color',
                                              variable: '--tw-text-opacity',
                                          })
                                        : { color: $(i) },
                            },
                            {
                                values: Z(e('textColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    textOpacity: T('textOpacity', [
                        ['text-opacity', ['--tw-text-opacity']],
                    ]),
                    textDecoration: ({ addUtilities: r }) => {
                        r({
                            '.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: r, theme: e }) => {
                        r(
                            {
                                decoration: t => ({
                                    'text-decoration-color': $(t),
                                }),
                            },
                            {
                                values: Z(e('textDecorationColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    textDecorationStyle: ({ addUtilities: r }) => {
                        r({
                            '.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: T(
                        'textDecorationThickness',
                        [['decoration', ['text-decoration-thickness']]],
                        { type: ['length', 'percentage'] }
                    ),
                    textUnderlineOffset: T(
                        'textUnderlineOffset',
                        [['underline-offset', ['text-underline-offset']]],
                        { type: ['length', 'percentage', 'any'] }
                    ),
                    fontSmoothing: ({ addUtilities: r }) => {
                        r({
                            '.antialiased': {
                                '-webkit-font-smoothing': 'antialiased',
                                '-moz-osx-font-smoothing': 'grayscale',
                            },
                            '.subpixel-antialiased': {
                                '-webkit-font-smoothing': 'auto',
                                '-moz-osx-font-smoothing': 'auto',
                            },
                        });
                    },
                    placeholderColor: ({
                        matchUtilities: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                placeholder: i =>
                                    t('placeholderOpacity')
                                        ? {
                                              '&::placeholder': le({
                                                  color: i,
                                                  property: 'color',
                                                  variable:
                                                      '--tw-placeholder-opacity',
                                              }),
                                          }
                                        : { '&::placeholder': { color: $(i) } },
                            },
                            {
                                values: Z(e('placeholderColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    placeholderOpacity: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'placeholder-opacity': t => ({
                                    ['&::placeholder']: {
                                        '--tw-placeholder-opacity': t,
                                    },
                                }),
                            },
                            { values: e('placeholderOpacity') }
                        );
                    },
                    caretColor: ({ matchUtilities: r, theme: e }) => {
                        r(
                            { caret: t => ({ 'caret-color': $(t) }) },
                            {
                                values: Z(e('caretColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    accentColor: ({ matchUtilities: r, theme: e }) => {
                        r(
                            { accent: t => ({ 'accent-color': $(t) }) },
                            {
                                values: Z(e('accentColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    opacity: T('opacity', [['opacity', ['opacity']]]),
                    backgroundBlendMode: ({ addUtilities: r }) => {
                        r({
                            '.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: r }) => {
                        r({
                            '.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 r = je('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: i,
                            theme: n,
                        }) {
                            i(' 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: s => {
                                            s = r(s);
                                            let a = _i(s);
                                            for (let o of a)
                                                !o.valid ||
                                                    (o.color =
                                                        'var(--tw-shadow-color)');
                                            return {
                                                '@defaults box-shadow': {},
                                                '--tw-shadow':
                                                    s === 'none'
                                                        ? '0 0 #0000'
                                                        : s,
                                                '--tw-shadow-colored':
                                                    s === 'none'
                                                        ? '0 0 #0000'
                                                        : hf(a),
                                                'box-shadow': e,
                                            };
                                        },
                                    },
                                    { values: n('boxShadow'), type: ['shadow'] }
                                );
                        };
                    })(),
                    boxShadowColor: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                shadow: t => ({
                                    '--tw-shadow-color': $(t),
                                    '--tw-shadow': 'var(--tw-shadow-colored)',
                                }),
                            },
                            {
                                values: Z(e('boxShadowColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    outlineStyle: ({ addUtilities: r }) => {
                        r({
                            '.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: T(
                        'outlineWidth',
                        [['outline', ['outline-width']]],
                        { type: ['length', 'number', 'percentage'] }
                    ),
                    outlineOffset: T(
                        'outlineOffset',
                        [['outline-offset', ['outline-offset']]],
                        {
                            type: ['length', 'number', 'percentage', 'any'],
                            supportsNegativeValues: !0,
                        }
                    ),
                    outlineColor: ({ matchUtilities: r, theme: e }) => {
                        r(
                            { outline: t => ({ 'outline-color': $(t) }) },
                            {
                                values: Z(e('outlineColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    ringWidth: ({
                        matchUtilities: r,
                        addDefaults: e,
                        addUtilities: t,
                        theme: i,
                        config: n,
                    }) => {
                        let s = (() => {
                            if (K(n(), 'respectDefaultRingColorOpacity'))
                                return i('ringColor.DEFAULT');
                            let a = i('ringOpacity.DEFAULT', '0.5');
                            return i('ringColor')?.DEFAULT
                                ? qe(
                                      i('ringColor')?.DEFAULT,
                                      a,
                                      `rgb(147 197 253 / ${a})`
                                  )
                                : `rgb(147 197 253 / ${a})`;
                        })();
                        e('ring-width', {
                            '--tw-ring-inset': ' ',
                            '--tw-ring-offset-width': i(
                                'ringOffsetWidth.DEFAULT',
                                '0px'
                            ),
                            '--tw-ring-offset-color': i(
                                'ringOffsetColor.DEFAULT',
                                '#fff'
                            ),
                            '--tw-ring-color': s,
                            '--tw-ring-offset-shadow': '0 0 #0000',
                            '--tw-ring-shadow': '0 0 #0000',
                            '--tw-shadow': '0 0 #0000',
                            '--tw-shadow-colored': '0 0 #0000',
                        }),
                            r(
                                {
                                    ring: a => ({
                                        '@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(${a} + 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: i('ringWidth'), type: 'length' }
                            ),
                            t({
                                '.ring-inset': {
                                    '@defaults ring-width': {},
                                    '--tw-ring-inset': 'inset',
                                },
                            });
                    },
                    ringColor: ({
                        matchUtilities: r,
                        theme: e,
                        corePlugins: t,
                    }) => {
                        r(
                            {
                                ring: i =>
                                    t('ringOpacity')
                                        ? le({
                                              color: i,
                                              property: '--tw-ring-color',
                                              variable: '--tw-ring-opacity',
                                          })
                                        : { '--tw-ring-color': $(i) },
                            },
                            {
                                values: Object.fromEntries(
                                    Object.entries(Z(e('ringColor'))).filter(
                                        ([i]) => i !== 'DEFAULT'
                                    )
                                ),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    ringOpacity: r => {
                        let { config: e } = r;
                        return T(
                            'ringOpacity',
                            [['ring-opacity', ['--tw-ring-opacity']]],
                            {
                                filterDefault: !K(
                                    e(),
                                    'respectDefaultRingColorOpacity'
                                ),
                            }
                        )(r);
                    },
                    ringOffsetWidth: T(
                        'ringOffsetWidth',
                        [['ring-offset', ['--tw-ring-offset-width']]],
                        { type: 'length' }
                    ),
                    ringOffsetColor: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'ring-offset': t => ({
                                    '--tw-ring-offset-color': $(t),
                                }),
                            },
                            {
                                values: Z(e('ringOffsetColor')),
                                type: ['color', 'any'],
                            }
                        );
                    },
                    blur: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                blur: t => ({
                                    '--tw-blur': `blur(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('blur') }
                        );
                    },
                    brightness: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                brightness: t => ({
                                    '--tw-brightness': `brightness(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('brightness') }
                        );
                    },
                    contrast: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                contrast: t => ({
                                    '--tw-contrast': `contrast(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('contrast') }
                        );
                    },
                    dropShadow: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'drop-shadow': t => ({
                                    '--tw-drop-shadow': Array.isArray(t)
                                        ? t
                                              .map(i => `drop-shadow(${i})`)
                                              .join(' ')
                                        : `drop-shadow(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('dropShadow') }
                        );
                    },
                    grayscale: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                grayscale: t => ({
                                    '--tw-grayscale': `grayscale(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('grayscale') }
                        );
                    },
                    hueRotate: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'hue-rotate': t => ({
                                    '--tw-hue-rotate': `hue-rotate(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            {
                                values: e('hueRotate'),
                                supportsNegativeValues: !0,
                            }
                        );
                    },
                    invert: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                invert: t => ({
                                    '--tw-invert': `invert(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('invert') }
                        );
                    },
                    saturate: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                saturate: t => ({
                                    '--tw-saturate': `saturate(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('saturate') }
                        );
                    },
                    sepia: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                sepia: t => ({
                                    '--tw-sepia': `sepia(${t})`,
                                    '@defaults filter': {},
                                    filter: Re,
                                }),
                            },
                            { values: e('sepia') }
                        );
                    },
                    filter: ({ addDefaults: r, addUtilities: e }) => {
                        r('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: Re,
                                },
                                '.filter-none': { filter: 'none' },
                            });
                    },
                    backdropBlur: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-blur': t => ({
                                    '--tw-backdrop-blur': `blur(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropBlur') }
                        );
                    },
                    backdropBrightness: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-brightness': t => ({
                                    '--tw-backdrop-brightness': `brightness(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropBrightness') }
                        );
                    },
                    backdropContrast: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-contrast': t => ({
                                    '--tw-backdrop-contrast': `contrast(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropContrast') }
                        );
                    },
                    backdropGrayscale: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-grayscale': t => ({
                                    '--tw-backdrop-grayscale': `grayscale(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropGrayscale') }
                        );
                    },
                    backdropHueRotate: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-hue-rotate': t => ({
                                    '--tw-backdrop-hue-rotate': `hue-rotate(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            {
                                values: e('backdropHueRotate'),
                                supportsNegativeValues: !0,
                            }
                        );
                    },
                    backdropInvert: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-invert': t => ({
                                    '--tw-backdrop-invert': `invert(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropInvert') }
                        );
                    },
                    backdropOpacity: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-opacity': t => ({
                                    '--tw-backdrop-opacity': `opacity(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropOpacity') }
                        );
                    },
                    backdropSaturate: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-saturate': t => ({
                                    '--tw-backdrop-saturate': `saturate(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropSaturate') }
                        );
                    },
                    backdropSepia: ({ matchUtilities: r, theme: e }) => {
                        r(
                            {
                                'backdrop-sepia': t => ({
                                    '--tw-backdrop-sepia': `sepia(${t})`,
                                    '@defaults backdrop-filter': {},
                                    'backdrop-filter': Me,
                                }),
                            },
                            { values: e('backdropSepia') }
                        );
                    },
                    backdropFilter: ({ addDefaults: r, addUtilities: e }) => {
                        r('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': Me,
                                },
                                '.backdrop-filter-none': {
                                    'backdrop-filter': 'none',
                                },
                            });
                    },
                    transitionProperty: ({ matchUtilities: r, theme: e }) => {
                        let t = e('transitionTimingFunction.DEFAULT'),
                            i = e('transitionDuration.DEFAULT');
                        r(
                            {
                                transition: n => ({
                                    'transition-property': n,
                                    ...(n === 'none'
                                        ? {}
                                        : {
                                              'transition-timing-function': t,
                                              'transition-duration': i,
                                          }),
                                }),
                            },
                            { values: e('transitionProperty') }
                        );
                    },
                    transitionDelay: T('transitionDelay', [
                        ['delay', ['transitionDelay']],
                    ]),
                    transitionDuration: T(
                        'transitionDuration',
                        [['duration', ['transitionDuration']]],
                        { filterDefault: !0 }
                    ),
                    transitionTimingFunction: T(
                        'transitionTimingFunction',
                        [['ease', ['transitionTimingFunction']]],
                        { filterDefault: !0 }
                    ),
                    willChange: T('willChange', [
                        ['will-change', ['will-change']],
                    ]),
                    content: T('content', [
                        [
                            'content',
                            ['--tw-content', ['content', 'var(--tw-content)']],
                        ],
                    ]),
                });
        });
    function aS(r) {
        if (r === void 0) return !1;
        if (r === 'true' || r === '1') return !0;
        if (r === 'false' || r === '0') return !1;
        if (r === '*') return !0;
        let e = r.split(',').map(t => t.split(':')[0]);
        return e.includes('-tailwindcss') ? !1 : !!e.includes('tailwindcss');
    }
    var Te,
        Qp,
        Jp,
        fn,
        Ma,
        Ve,
        Hr,
        rt = A(() => {
            l();
            (Te = { NODE_ENV: 'production', DEBUG: aS(m.env.DEBUG) }),
                (Qp = new Map()),
                (Jp = new Map()),
                (fn = new Map()),
                (Ma = new Map()),
                (Ve = new String('*')),
                (Hr = Symbol('__NONE__'));
        });
    function It(r) {
        let e = [],
            t = !1;
        for (let i = 0; i < r.length; i++) {
            let n = r[i];
            if (n === ':' && !t && e.length === 0) return !1;
            if (
                (oS.has(n) && r[i - 1] !== '\\' && (t = !t),
                !t && r[i - 1] !== '\\')
            ) {
                if (Xp.has(n)) e.push(n);
                else if (Kp.has(n)) {
                    let s = Kp.get(n);
                    if (e.length <= 0 || e.pop() !== s) return !1;
                }
            }
        }
        return !(e.length > 0);
    }
    var Xp,
        Kp,
        oS,
        Fa = A(() => {
            l();
            (Xp = new Map([
                ['{', '}'],
                ['[', ']'],
                ['(', ')'],
            ])),
                (Kp = new Map(
                    Array.from(Xp.entries()).map(([r, e]) => [e, r])
                )),
                (oS = new Set(['"', "'", '`']));
        });
    function Yr(r, ...e) {
        for (let t of e) {
            let i = rd(t, cn);
            if (i !== null && rd(r, cn, i) !== null) {
                let s = `${cn}(${i})`,
                    a = t.indexOf(s),
                    o = t.slice(a + s.length).split(' ')[0];
                r = r.replace(s, s + o);
                continue;
            }
            r = t.replace(ed, r);
        }
        return r;
    }
    function td(r) {
        let e = [];
        for (; r.prev() && r.prev().type !== 'combinator'; ) r = r.prev();
        for (; r && r.type !== 'combinator'; ) e.push(r), (r = r.next());
        return e;
    }
    function uS(r) {
        return (
            r.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
                    : r.index(e) - r.index(t)
            ),
            r
        );
    }
    function fS(r, e) {
        let t = !1;
        r.walk(i => {
            if (i.type === 'class' && i.value === e) return (t = !0), !1;
        }),
            t || r.remove();
    }
    function pn(
        r,
        {
            selector: e,
            candidate: t,
            context: i,
            isArbitraryVariant: n,
            base: s = t
                .split(
                    new RegExp(
                        `\\${i?.tailwindConfig?.separator ?? ':'}(?![^[]*\\])`
                    )
                )
                .pop(),
        }
    ) {
        let a = (0, Rt.default)().astSync(e);
        i?.tailwindConfig?.prefix && !n && (r = Dt(i.tailwindConfig.prefix, r)),
            (r = r.replace(ed, `.${ve(t)}`));
        let o = (0, Rt.default)().astSync(r);
        a.each(p => fS(p, s)),
            a.walkClasses(p => {
                p.raws &&
                    p.value.includes(s) &&
                    (p.raws.value = ve((0, Zp.default)(p.raws.value)));
            });
        let u = Rt.default.comment({ value: '/*__simple__*/' }),
            c = Rt.default.comment({ value: '/*__simple__*/' });
        a.walkClasses(p => {
            if (p.value !== s) return;
            let h = p.parent,
                d = o.nodes[0].nodes;
            if (h.nodes.length === 1) {
                p.replaceWith(...d);
                return;
            }
            let y = td(p);
            h.insertBefore(y[0], u), h.insertAfter(y[y.length - 1], c);
            for (let w of d) h.insertBefore(y[0], w);
            p.remove(), (y = td(u));
            let k = h.index(u);
            h.nodes.splice(
                k,
                y.length,
                ...uS(Rt.default.selector({ nodes: y })).nodes
            ),
                u.remove(),
                c.remove();
        });
        function f(p) {
            let h = [];
            for (let d of p.nodes)
                Na(d) && (h.push(d), p.removeChild(d)),
                    d?.nodes && h.push(...f(d));
            return h;
        }
        return (
            a.each(p => {
                p.walkPseudos(d => {
                    lS.has(d.value) && d.replaceWith(d.nodes);
                });
                let h = f(p);
                h.length > 0 && p.nodes.push(h.sort(dS));
            }),
            a.toString()
        );
    }
    function dS(r, e) {
        return (r.type !== 'pseudo' && e.type !== 'pseudo') ||
            (r.type === 'combinator') ^ (e.type === 'combinator')
            ? 0
            : (r.type === 'pseudo') ^ (e.type === 'pseudo')
            ? (r.type === 'pseudo') - (e.type === 'pseudo')
            : Na(r) - Na(e);
    }
    function Na(r) {
        return r.type !== 'pseudo' || pS.includes(r.value)
            ? !1
            : r.value.startsWith('::') || cS.includes(r.value);
    }
    function rd(r, e, t) {
        let i = r.indexOf(t ? `${e}(${t})` : e);
        if (i === -1) return null;
        i += e.length + 1;
        let n = '',
            s = 0;
        for (let a of r.slice(i))
            if (a !== '(' && a !== ')') n += a;
            else if (a === '(') (n += a), s++;
            else if (a === ')') {
                if (--s < 0) break;
                n += a;
            }
        return n;
    }
    var Rt,
        Zp,
        cn,
        ed,
        lS,
        cS,
        pS,
        La = A(() => {
            l();
            (Rt = J(De())), (Zp = J(ci()));
            qt();
            rn();
            (cn = ':merge'), (ed = '&'), (lS = new Set([cn]));
            (cS = [':before', ':after', ':first-line', ':first-letter']),
                (pS = ['::file-selector-button']);
        });
    function $a(r) {
        return hS.transformSync(r);
    }
    function* mS(r) {
        let e = 1 / 0;
        for (; e >= 0; ) {
            let t,
                i = !1;
            if (e === 1 / 0 && r.endsWith(']')) {
                let a = r.indexOf('[');
                r[a - 1] === '-'
                    ? (t = a - 1)
                    : r[a - 1] === '/'
                    ? ((t = a - 1), (i = !0))
                    : (t = -1);
            } else
                e === 1 / 0 && r.includes('/')
                    ? ((t = r.lastIndexOf('/')), (i = !0))
                    : (t = r.lastIndexOf('-', e));
            if (t < 0) break;
            let n = r.slice(0, t),
                s = r.slice(i ? t : t + 1);
            (e = t - 1), !(n === '' || s === '/') && (yield [n, s]);
        }
    }
    function gS(r, e) {
        if (r.length === 0 || e.tailwindConfig.prefix === '') return r;
        for (let t of r) {
            let [i] = t;
            if (i.options.respectPrefix) {
                let n = j.root({ nodes: [t[1].clone()] }),
                    s = t[1].raws.tailwind.classCandidate;
                n.walkRules(a => {
                    let o = s.startsWith('-');
                    a.selector = Dt(e.tailwindConfig.prefix, a.selector, o);
                }),
                    (t[1] = n.nodes[0]);
            }
        }
        return r;
    }
    function yS(r, e) {
        if (r.length === 0) return r;
        let t = [];
        for (let [i, n] of r) {
            let s = j.root({ nodes: [n.clone()] });
            s.walkRules(a => {
                (a.selector = Tf(Pf(a.selector, e), o =>
                    o === e ? `!${o}` : o
                )),
                    a.walkDecls(o => (o.important = !0));
            }),
                t.push([{ ...i, important: !0 }, s.nodes[0]]);
        }
        return t;
    }
    function wS(r, e, t) {
        if (e.length === 0) return e;
        let i = { modifier: null, value: Hr };
        {
            let n = /(.*)\/(.*)$/g.exec(r);
            if (
                n &&
                ((r = n[1]),
                (i.modifier = n[2]),
                !K(t.tailwindConfig, 'generalizedModifiers'))
            )
                return [];
        }
        if (r.endsWith(']') && !r.startsWith('[')) {
            let n = /(.)(-?)\[(.*)\]/g.exec(r);
            if (n) {
                let [, s, a, o] = n;
                if (s === '@' && a === '-') return [];
                if (s !== '@' && a === '') return [];
                (r = r.replace(`${a}[${o}]`, '')), (i.value = o);
            }
        }
        if (ja(r) && !t.variantMap.has(r)) {
            let n = H(r.slice(1, -1));
            if (!yn(n)) return [];
            let s = Qr(n),
                a = t.offsets.recordVariant(r);
            t.variantMap.set(r, [[a, s]]);
        }
        if (t.variantMap.has(r)) {
            let n = t.variantMap.get(r).slice(),
                s = [];
            for (let [a, o] of e) {
                if (a.layer === 'user') continue;
                let u = j.root({ nodes: [o.clone()] });
                for (let [c, f, p] of n) {
                    let y = function () {
                            h.raws.neededBackup ||
                                ((h.raws.neededBackup = !0),
                                h.walkRules(
                                    x => (x.raws.originalSelector = x.selector)
                                ));
                        },
                        k = function (x) {
                            return (
                                y(),
                                h.each(S => {
                                    S.type === 'rule' &&
                                        (S.selectors = S.selectors.map(_ =>
                                            x({
                                                get className() {
                                                    return $a(_);
                                                },
                                                selector: _,
                                            })
                                        ));
                                }),
                                h
                            );
                        },
                        h = (p ?? u).clone(),
                        d = [],
                        w = f({
                            get container() {
                                return y(), h;
                            },
                            separator: t.tailwindConfig.separator,
                            modifySelectors: k,
                            wrap(x) {
                                let S = h.nodes;
                                h.removeAll(), x.append(S), h.append(x);
                            },
                            format(x) {
                                d.push(x);
                            },
                            args: i,
                        });
                    if (Array.isArray(w)) {
                        for (let [x, S] of w.entries())
                            n.push([
                                t.offsets.applyParallelOffset(c, x),
                                S,
                                h.clone(),
                            ]);
                        continue;
                    }
                    if ((typeof w == 'string' && d.push(w), w === null))
                        continue;
                    h.raws.neededBackup &&
                        (delete h.raws.neededBackup,
                        h.walkRules(x => {
                            let S = x.raws.originalSelector;
                            if (
                                !S ||
                                (delete x.raws.originalSelector,
                                S === x.selector)
                            )
                                return;
                            let _ = x.selector,
                                D = (0, Ba.default)(M => {
                                    M.walkClasses(B => {
                                        B.value = `${r}${t.tailwindConfig.separator}${B.value}`;
                                    });
                                }).processSync(S);
                            d.push(_.replace(D, '&')), (x.selector = S);
                        })),
                        (h.nodes[0].raws.tailwind = {
                            ...h.nodes[0].raws.tailwind,
                            parentLayer: a.layer,
                        });
                    let b = [
                        {
                            ...a,
                            sort: t.offsets.applyVariantOffset(
                                a.sort,
                                c,
                                Object.assign(i, t.variantOptions.get(r))
                            ),
                            collectedFormats: (a.collectedFormats ?? []).concat(
                                d
                            ),
                            isArbitraryVariant: ja(r),
                        },
                        h.nodes[0],
                    ];
                    s.push(b);
                }
            }
            return s;
        }
        return [];
    }
    function za(r, e, t = {}) {
        return !ee(r) && !Array.isArray(r)
            ? [[r], t]
            : Array.isArray(r)
            ? za(r[0], e, r[1])
            : (e.has(r) || e.set(r, Pt(r)), [e.get(r), t]);
    }
    function vS(r) {
        return bS.test(r);
    }
    function xS(r) {
        if (!r.includes('://')) return !1;
        try {
            let e = new URL(r);
            return e.scheme !== '' && e.host !== '';
        } catch (e) {
            return !1;
        }
    }
    function id(r) {
        let e = !0;
        return (
            r.walkDecls(t => {
                if (!nd(t.name, t.value)) return (e = !1), !1;
            }),
            e
        );
    }
    function nd(r, e) {
        if (xS(`${r}:${e}`)) return !1;
        try {
            return j.parse(`a{${r}:${e}}`).toResult(), !0;
        } catch (t) {
            return !1;
        }
    }
    function kS(r, e) {
        let [, t, i] = r.match(/^\[([a-zA-Z0-9-_]+):(\S+)\]$/) ?? [];
        if (i === void 0 || !vS(t) || !It(i)) return null;
        let n = H(i);
        return nd(t, n)
            ? [
                  [
                      {
                          sort: e.offsets.arbitraryProperty(),
                          layer: 'utilities',
                      },
                      () => ({ [qa(r)]: { [t]: n } }),
                  ],
              ]
            : null;
    }
    function* SS(r, e) {
        e.candidateRuleMap.has(r) &&
            (yield [e.candidateRuleMap.get(r), 'DEFAULT']),
            yield* (function* (o) {
                o !== null && (yield [o, 'DEFAULT']);
            })(kS(r, e));
        let t = r,
            i = !1,
            n = e.tailwindConfig.prefix,
            s = n.length,
            a = t.startsWith(n) || t.startsWith(`-${n}`);
        t[s] === '-' && a && ((i = !0), (t = n + t.slice(s + 1))),
            i &&
                e.candidateRuleMap.has(t) &&
                (yield [e.candidateRuleMap.get(t), '-DEFAULT']);
        for (let [o, u] of mS(t))
            e.candidateRuleMap.has(o) &&
                (yield [e.candidateRuleMap.get(o), i ? `-${u}` : u]);
    }
    function CS(r, e) {
        return r === Ve ? [Ve] : de(r, e);
    }
    function* _S(r, e) {
        for (let t of r)
            (t[1].raws.tailwind = {
                ...t[1].raws.tailwind,
                classCandidate: e,
                preserveSource: t[0].options?.preserveSource ?? !1,
            }),
                yield t;
    }
    function* dn(r, e, t = r) {
        let i = e.tailwindConfig.separator,
            [n, ...s] = CS(r, i).reverse(),
            a = !1;
        if (
            (n.startsWith('!') && ((a = !0), (n = n.slice(1))),
            K(e.tailwindConfig, 'variantGrouping') &&
                n.startsWith('(') &&
                n.endsWith(')'))
        ) {
            let o = s.slice().reverse().join(i);
            for (let u of de(n.slice(1, -1), ',')) yield* dn(o + i + u, e, t);
        }
        for (let o of SS(n, e)) {
            let u = [],
                c = new Map(),
                [f, p] = o,
                h = f.length === 1;
            for (let [d, y] of f) {
                let k = [];
                if (typeof y == 'function')
                    for (let w of [].concat(y(p, { isOnlyPlugin: h }))) {
                        let [b, x] = za(w, e.postCssNodeCache);
                        for (let S of b)
                            k.push([
                                { ...d, options: { ...d.options, ...x } },
                                S,
                            ]);
                    }
                else if (p === 'DEFAULT' || p === '-DEFAULT') {
                    let w = y,
                        [b, x] = za(w, e.postCssNodeCache);
                    for (let S of b)
                        k.push([{ ...d, options: { ...d.options, ...x } }, S]);
                }
                if (k.length > 0) {
                    let w = Array.from(
                        Ws(
                            d.options?.types ?? [],
                            p,
                            d.options ?? {},
                            e.tailwindConfig
                        )
                    ).map(([b, x]) => x);
                    w.length > 0 && c.set(k, w), u.push(k);
                }
            }
            if (ja(p)) {
                if (u.length > 1) {
                    let k = function (b) {
                            return b.length === 1
                                ? b[0]
                                : b.find(x => {
                                      let S = c.get(x);
                                      return x.some(([{ options: _ }, D]) =>
                                          id(D)
                                              ? _.types.some(
                                                    ({
                                                        type: M,
                                                        preferOnConflict: B,
                                                    }) => S.includes(M) && B
                                                )
                                              : !1
                                      );
                                  });
                        },
                        [d, y] = u.reduce(
                            (b, x) => (
                                x.some(([{ options: _ }]) =>
                                    _.types.some(({ type: D }) => D === 'any')
                                )
                                    ? b[0].push(x)
                                    : b[1].push(x),
                                b
                            ),
                            [[], []]
                        ),
                        w = k(y) ?? k(d);
                    if (w) u = [w];
                    else {
                        let b = u.map(S => new Set([...(c.get(S) ?? [])]));
                        for (let S of b)
                            for (let _ of S) {
                                let D = !1;
                                for (let M of b)
                                    S !== M &&
                                        M.has(_) &&
                                        (M.delete(_), (D = !0));
                                D && S.delete(_);
                            }
                        let x = [];
                        for (let [S, _] of b.entries())
                            for (let D of _) {
                                let M = u[S].map(([, B]) => B)
                                    .flat()
                                    .map(B =>
                                        B.toString()
                                            .split(
                                                `
`
                                            )
                                            .slice(1, -1)
                                            .map(q => q.trim())
                                            .map(q => `      ${q}`).join(`
`)
                                    ).join(`

`);
                                x.push(
                                    `  Use \`${r.replace(
                                        '[',
                                        `[${D}:`
                                    )}\` for \`${M.trim()}\``
                                );
                                break;
                            }
                        N.warn([
                            `The class \`${r}\` is ambiguous and matches multiple utilities.`,
                            ...x,
                            `If this is content and not a class, replace it with \`${r
                                .replace('[', '&lsqb;')
                                .replace(
                                    ']',
                                    '&rsqb;'
                                )}\` to silence this warning.`,
                        ]);
                        continue;
                    }
                }
                u = u.map(d => d.filter(y => id(y[1])));
            }
            (u = u.flat()),
                (u = Array.from(_S(u, n))),
                (u = gS(u, e)),
                a && (u = yS(u, n));
            for (let d of s) u = wS(d, u, e);
            for (let d of u) {
                if (
                    ((d[1].raws.tailwind = {
                        ...d[1].raws.tailwind,
                        candidate: r,
                    }),
                    d[0].collectedFormats)
                ) {
                    let y = Yr('&', ...d[0].collectedFormats),
                        k = j.root({ nodes: [d[1].clone()] });
                    k.walkRules(w => {
                        hn(w) ||
                            (w.selector = pn(y, {
                                selector: w.selector,
                                candidate: t,
                                base: r
                                    .split(
                                        new RegExp(
                                            `\\${
                                                e?.tailwindConfig?.separator ??
                                                ':'
                                            }(?![^[]*\\])`
                                        )
                                    )
                                    .pop(),
                                isArbitraryVariant: d[0].isArbitraryVariant,
                                context: e,
                            }));
                    }),
                        (d[1] = k.nodes[0]);
                }
                yield d;
            }
        }
    }
    function hn(r) {
        return (
            r.parent &&
            r.parent.type === 'atrule' &&
            r.parent.name === 'keyframes'
        );
    }
    function AS(r) {
        if (r === !0)
            return e => {
                hn(e) ||
                    e.walkDecls(t => {
                        t.parent.type === 'rule' &&
                            !hn(t.parent) &&
                            (t.important = !0);
                    });
            };
        if (typeof r == 'string')
            return e => {
                hn(e) || (e.selectors = e.selectors.map(t => `${r} ${t}`));
            };
    }
    function mn(r, e) {
        let t = [],
            i = AS(e.tailwindConfig.important);
        for (let n of r) {
            if (e.notClassCache.has(n)) continue;
            if (e.candidateRuleCache.has(n)) {
                t = t.concat(Array.from(e.candidateRuleCache.get(n)));
                continue;
            }
            let s = Array.from(dn(n, e));
            if (s.length === 0) {
                e.notClassCache.add(n);
                continue;
            }
            e.classCache.set(n, s);
            let a = e.candidateRuleCache.get(n) ?? new Set();
            e.candidateRuleCache.set(n, a);
            for (let o of s) {
                let [{ sort: u, options: c }, f] = o;
                if (c.respectImportant && i) {
                    let h = j.root({ nodes: [f.clone()] });
                    h.walkRules(i), (f = h.nodes[0]);
                }
                let p = [u, f];
                a.add(p), e.ruleCache.add(p), t.push(p);
            }
        }
        return t;
    }
    function ja(r) {
        return r.startsWith('[') && r.endsWith(']');
    }
    var Ba,
        hS,
        bS,
        gn = A(() => {
            l();
            Ze();
            Ba = J(De());
            Da();
            wt();
            rn();
            Pr();
            Ae();
            rt();
            La();
            Ia();
            Er();
            wn();
            Fa();
            _r();
            $e();
            hS = (0, Ba.default)(
                r => r.first.filter(({ type: e }) => e === 'class').pop().value
            );
            bS = /^[a-z_-]/;
        });
    function OS(r) {
        try {
            return yt.createHash('md5').update(r, 'utf-8').digest('binary');
        } catch (e) {
            return '';
        }
    }
    function sd(r, e) {
        let t = e.toString();
        if (!t.includes('@tailwind')) return !1;
        let i = Ma.get(r),
            n = OS(t),
            s = i !== n;
        return Ma.set(r, n), s;
    }
    var ad = A(() => {
        l();
        si();
        rt();
    });
    function Va(r) {
        return (r > 0n) - (r < 0n);
    }
    var od = A(() => {
        l();
    });
    function ES(r) {
        let e = null;
        for (let t of r) (e = e ?? t), (e = e > t ? e : t);
        return e;
    }
    var Ua,
        ld = A(() => {
            l();
            od();
            Ua = 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 i = this.variantOffsets.get(e);
                    if (i === void 0)
                        throw new Error(
                            `Cannot find offset for unknown variant ${e}`
                        );
                    return {
                        ...this.create('variants'),
                        variants: i << BigInt(t),
                    };
                }
                applyVariantOffset(e, t, i) {
                    return {
                        ...e,
                        layer: 'variants',
                        parentLayer:
                            e.layer === 'variants' ? e.parentLayer : e.layer,
                        variants: e.variants | t.variants,
                        options: i.sort ? [].concat(i, e.options) : e.options,
                        parallelIndex: ES([e.parallelIndex, t.parallelIndex]),
                    };
                }
                applyParallelOffset(e, t) {
                    return { ...e, parallelIndex: BigInt(t) };
                }
                recordVariants(e, t) {
                    for (let i of e) this.recordVariant(i, t(i));
                }
                recordVariant(e, t = 1) {
                    return (
                        this.variantOffsets.set(
                            e,
                            1n << this.reservedVariantBits
                        ),
                        (this.reservedVariantBits += BigInt(t)),
                        {
                            ...this.create('variants'),
                            variants: 1n << this.reservedVariantBits,
                        }
                    );
                }
                compare(e, t) {
                    if (e.layer !== t.layer)
                        return (
                            this.layerPositions[e.layer] -
                            this.layerPositions[t.layer]
                        );
                    for (let i of e.options)
                        for (let n of t.options) {
                            if (i.id !== n.id || !i.sort || !n.sort) continue;
                            let s = i.sort(
                                { value: i.value, modifier: i.modifier },
                                { value: n.value, modifier: n.modifier }
                            );
                            if (s !== 0) return s;
                        }
                    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;
                }
                sort(e) {
                    return e.sort(([t], [i]) => Va(this.compare(t, i)));
                }
            };
        });
    function Ya(r, e) {
        let t = r.tailwindConfig.prefix;
        return typeof t == 'function' ? t(e) : t + e;
    }
    function fd({ type: r = 'any', ...e }) {
        let t = [].concat(r);
        return {
            ...e,
            types: t.map(i =>
                Array.isArray(i)
                    ? { type: i[0], ...i[1] }
                    : { type: i, preferOnConflict: !1 }
            ),
        };
    }
    function cd(r) {
        if (r.includes('{')) {
            if (!TS(r)) throw new Error('Your { and } are unbalanced.');
            return r
                .split(/{(.*)}/gim)
                .flatMap(e => cd(e))
                .filter(Boolean);
        }
        return [r.trim()];
    }
    function TS(r) {
        let e = 0;
        for (let t of r)
            if (t === '{') e++;
            else if (t === '}' && --e < 0) return !1;
        return e === 0;
    }
    function PS(r, e, { before: t = [] } = {}) {
        if (((t = [].concat(t)), t.length <= 0)) {
            r.push(e);
            return;
        }
        let i = r.length - 1;
        for (let n of t) {
            let s = r.indexOf(n);
            s !== -1 && (i = Math.min(i, s));
        }
        r.splice(i, 0, e);
    }
    function pd(r) {
        return Array.isArray(r)
            ? r.flatMap(e => (!Array.isArray(e) && !ee(e) ? e : Pt(e)))
            : pd([r]);
    }
    function dd(r, e) {
        return (0, Wa.default)(i => {
            let n = [];
            return (
                e && e(i),
                i.walkClasses(s => {
                    n.push(s.value);
                }),
                n
            );
        }).transformSync(r);
    }
    function DS(r, e = { containsNonOnDemandable: !1 }, t = 0) {
        let i = [];
        if (r.type === 'rule') {
            let n = function (s) {
                s.walkPseudos(a => {
                    a.value === ':not' && a.remove();
                });
            };
            for (let s of r.selectors) {
                let a = dd(s, n);
                a.length === 0 && (e.containsNonOnDemandable = !0);
                for (let o of a) i.push(o);
            }
        } else
            r.type === 'atrule' &&
                r.walkRules(n => {
                    for (let s of n.selectors.flatMap(a => dd(a))) i.push(s);
                });
        return t === 0 ? [e.containsNonOnDemandable || i.length === 0, i] : i;
    }
    function bn(r) {
        return pd(r).flatMap(e => {
            let t = new Map(),
                [i, n] = DS(e);
            return (
                i && n.unshift(Ve),
                n.map(s => (t.has(e) || t.set(e, e), [s, t.get(e)]))
            );
        });
    }
    function yn(r) {
        return r.startsWith('@') || r.includes('&');
    }
    function Qr(r) {
        r = r
            .replace(/\n+/g, '')
            .replace(/\s{1,}/g, ' ')
            .trim();
        let e = cd(r)
            .map(t => {
                if (!t.startsWith('@')) return ({ format: s }) => s(t);
                let [, i, n] = /@(.*?)( .+|[({].*)/g.exec(t);
                return ({ wrap: s }) =>
                    s(j.atRule({ name: i, params: n.trim() }));
            })
            .reverse();
        return t => {
            for (let i of e) i(t);
        };
    }
    function qS(
        r,
        e,
        { variantList: t, variantMap: i, offsets: n, classList: s }
    ) {
        function a(d, y) {
            return d ? (0, ud.default)(r, d, y) : r;
        }
        function o(d) {
            return Dt(r.prefix, d);
        }
        function u(d, y) {
            return d === Ve
                ? Ve
                : y.respectPrefix
                ? e.tailwindConfig.prefix + d
                : d;
        }
        function c(d, y, k = {}) {
            let [w, ...b] = He(d),
                x = a(['theme', w, ...b], y);
            return je(w)(x, k);
        }
        let f = Object.assign((d, y = void 0) => c(d, y), {
                withAlpha: (d, y) => c(d, void 0, { opacityValue: y }),
            }),
            p = 0,
            h = {
                postcss: j,
                prefix: o,
                e: ve,
                config: a,
                theme: f,
                corePlugins: d =>
                    Array.isArray(r.corePlugins)
                        ? r.corePlugins.includes(d)
                        : a(['corePlugins', d], !0),
                variants: () => [],
                addBase(d) {
                    for (let [y, k] of bn(d)) {
                        let w = u(y, {}),
                            b = n.create('base');
                        e.candidateRuleMap.has(w) ||
                            e.candidateRuleMap.set(w, []),
                            e.candidateRuleMap
                                .get(w)
                                .push([{ sort: b, layer: 'base' }, k]);
                    }
                },
                addDefaults(d, y) {
                    let k = { [`@defaults ${d}`]: y };
                    for (let [w, b] of bn(k)) {
                        let x = u(w, {});
                        e.candidateRuleMap.has(x) ||
                            e.candidateRuleMap.set(x, []),
                            e.candidateRuleMap
                                .get(x)
                                .push([
                                    {
                                        sort: n.create('defaults'),
                                        layer: 'defaults',
                                    },
                                    b,
                                ]);
                    }
                },
                addComponents(d, y) {
                    y = Object.assign(
                        {},
                        {
                            preserveSource: !1,
                            respectPrefix: !0,
                            respectImportant: !1,
                        },
                        Array.isArray(y) ? {} : y
                    );
                    for (let [w, b] of bn(d)) {
                        let x = u(w, y);
                        s.add(x),
                            e.candidateRuleMap.has(x) ||
                                e.candidateRuleMap.set(x, []),
                            e.candidateRuleMap
                                .get(x)
                                .push([
                                    {
                                        sort: n.create('components'),
                                        layer: 'components',
                                        options: y,
                                    },
                                    b,
                                ]);
                    }
                },
                addUtilities(d, y) {
                    y = Object.assign(
                        {},
                        {
                            preserveSource: !1,
                            respectPrefix: !0,
                            respectImportant: !0,
                        },
                        Array.isArray(y) ? {} : y
                    );
                    for (let [w, b] of bn(d)) {
                        let x = u(w, y);
                        s.add(x),
                            e.candidateRuleMap.has(x) ||
                                e.candidateRuleMap.set(x, []),
                            e.candidateRuleMap
                                .get(x)
                                .push([
                                    {
                                        sort: n.create('utilities'),
                                        layer: 'utilities',
                                        options: y,
                                    },
                                    b,
                                ]);
                    }
                },
                matchUtilities: function (d, y) {
                    y = fd({
                        ...{
                            respectPrefix: !0,
                            respectImportant: !0,
                            modifiers: !1,
                        },
                        ...y,
                    });
                    let w = n.create('utilities');
                    for (let b in d) {
                        let _ = function (M, { isOnlyPlugin: B }) {
                                let [q, F, X] = Us(y.types, M, y, r);
                                if (q === void 0) return [];
                                if (!y.types.some(({ type: pe }) => pe === F))
                                    if (B)
                                        N.warn([
                                            `Unnecessary typehint \`${F}\` in \`${b}-${M}\`.`,
                                            `You can safely update it to \`${b}-${M.replace(
                                                F + ':',
                                                ''
                                            )}\`.`,
                                        ]);
                                    else return [];
                                if (!It(q)) return [];
                                let ce = {
                                        get modifier() {
                                            return (
                                                y.modifiers ||
                                                    N.warn(
                                                        `modifier-used-without-options-for-${b}`,
                                                        [
                                                            'Your plugin must set `modifiers: true` in its options to support modifiers.',
                                                        ]
                                                    ),
                                                X
                                            );
                                        },
                                    },
                                    se = K(r, 'generalizedModifiers');
                                return []
                                    .concat(se ? S(q, ce) : S(q))
                                    .filter(Boolean)
                                    .map(pe => ({ [nn(b, M)]: pe }));
                            },
                            x = u(b, y),
                            S = d[b];
                        s.add([x, y]);
                        let D = [
                            { sort: w, layer: 'utilities', options: y },
                            _,
                        ];
                        e.candidateRuleMap.has(x) ||
                            e.candidateRuleMap.set(x, []),
                            e.candidateRuleMap.get(x).push(D);
                    }
                },
                matchComponents: function (d, y) {
                    y = fd({
                        ...{
                            respectPrefix: !0,
                            respectImportant: !1,
                            modifiers: !1,
                        },
                        ...y,
                    });
                    let w = n.create('components');
                    for (let b in d) {
                        let _ = function (M, { isOnlyPlugin: B }) {
                                let [q, F, X] = Us(y.types, M, y, r);
                                if (q === void 0) return [];
                                if (!y.types.some(({ type: pe }) => pe === F))
                                    if (B)
                                        N.warn([
                                            `Unnecessary typehint \`${F}\` in \`${b}-${M}\`.`,
                                            `You can safely update it to \`${b}-${M.replace(
                                                F + ':',
                                                ''
                                            )}\`.`,
                                        ]);
                                    else return [];
                                if (!It(q)) return [];
                                let ce = {
                                        get modifier() {
                                            return (
                                                y.modifiers ||
                                                    N.warn(
                                                        `modifier-used-without-options-for-${b}`,
                                                        [
                                                            'Your plugin must set `modifiers: true` in its options to support modifiers.',
                                                        ]
                                                    ),
                                                X
                                            );
                                        },
                                    },
                                    se = K(r, 'generalizedModifiers');
                                return []
                                    .concat(se ? S(q, ce) : S(q))
                                    .filter(Boolean)
                                    .map(pe => ({ [nn(b, M)]: pe }));
                            },
                            x = u(b, y),
                            S = d[b];
                        s.add([x, y]);
                        let D = [
                            { sort: w, layer: 'components', options: y },
                            _,
                        ];
                        e.candidateRuleMap.has(x) ||
                            e.candidateRuleMap.set(x, []),
                            e.candidateRuleMap.get(x).push(D);
                    }
                },
                addVariant(d, y, k = {}) {
                    (y = [].concat(y).map(w => {
                        if (typeof w != 'string')
                            return (b = {}) => {
                                let {
                                        args: x,
                                        modifySelectors: S,
                                        container: _,
                                        separator: D,
                                        wrap: M,
                                        format: B,
                                    } = b,
                                    q = w(
                                        Object.assign(
                                            {
                                                modifySelectors: S,
                                                container: _,
                                                separator: D,
                                            },
                                            k.type === Ga.MatchVariant && {
                                                args: x,
                                                wrap: M,
                                                format: B,
                                            }
                                        )
                                    );
                                if (typeof q == 'string' && !yn(q))
                                    throw new Error(
                                        `Your custom variant \`${d}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`
                                    );
                                return Array.isArray(q)
                                    ? q
                                          .filter(F => typeof F == 'string')
                                          .map(F => Qr(F))
                                    : q && typeof q == 'string' && Qr(q)(b);
                            };
                        if (!yn(w))
                            throw new Error(
                                `Your custom variant \`${d}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`
                            );
                        return Qr(w);
                    })),
                        PS(t, d, k),
                        i.set(d, y),
                        e.variantOptions.set(d, k);
                },
                matchVariant(d, y, k) {
                    let w = k?.id ?? ++p,
                        b = d === '@',
                        x = K(r, 'generalizedModifiers');
                    for (let [_, D] of Object.entries(k?.values ?? {}))
                        _ !== 'DEFAULT' &&
                            h.addVariant(
                                b ? `${d}${_}` : `${d}-${_}`,
                                ({ args: M, container: B }) =>
                                    y(
                                        D,
                                        x
                                            ? {
                                                  modifier: M?.modifier,
                                                  container: B,
                                              }
                                            : { container: B }
                                    ),
                                {
                                    ...k,
                                    value: D,
                                    id: w,
                                    type: Ga.MatchVariant,
                                    variantInfo: Ha.Base,
                                }
                            );
                    let S = 'DEFAULT' in (k?.values ?? {});
                    h.addVariant(
                        d,
                        ({ args: _, container: D }) =>
                            _?.value === Hr && !S
                                ? null
                                : y(
                                      _?.value === Hr
                                          ? k.values.DEFAULT
                                          : _?.value ??
                                                (typeof _ == 'string' ? _ : ''),
                                      x
                                          ? {
                                                modifier: _?.modifier,
                                                container: D,
                                            }
                                          : { container: D }
                                  ),
                        {
                            ...k,
                            id: w,
                            type: Ga.MatchVariant,
                            variantInfo: Ha.Dynamic,
                        }
                    );
                },
            };
        return h;
    }
    function vn(r) {
        return Qa.has(r) || Qa.set(r, new Map()), Qa.get(r);
    }
    function hd(r, e) {
        let t = !1;
        for (let i of r) {
            if (!i) continue;
            let n = Xs.parse(i),
                s = n.hash ? n.href.replace(n.hash, '') : n.href;
            s = n.search ? s.replace(n.search, '') : s;
            let a = ae.statSync(decodeURIComponent(s), {
                throwIfNoEntry: !1,
            })?.mtimeMs;
            !a || ((!e.has(i) || a > e.get(i)) && (t = !0), e.set(i, a));
        }
        return t;
    }
    function md(r) {
        r.walkAtRules(e => {
            ['responsive', 'variants'].includes(e.name) &&
                (md(e), e.before(e.nodes), e.remove());
        });
    }
    function IS(r) {
        let e = [];
        return (
            r.each(t => {
                t.type === 'atrule' &&
                    ['responsive', 'variants'].includes(t.name) &&
                    ((t.name = 'layer'), (t.params = 'utilities'));
            }),
            r.walkAtRules('layer', t => {
                if ((md(t), t.params === 'base')) {
                    for (let i of t.nodes)
                        e.push(function ({ addBase: n }) {
                            n(i, { respectPrefix: !1 });
                        });
                    t.remove();
                } else if (t.params === 'components') {
                    for (let i of t.nodes)
                        e.push(function ({ addComponents: n }) {
                            n(i, { respectPrefix: !1, preserveSource: !0 });
                        });
                    t.remove();
                } else if (t.params === 'utilities') {
                    for (let i of t.nodes)
                        e.push(function ({ addUtilities: n }) {
                            n(i, { respectPrefix: !1, preserveSource: !0 });
                        });
                    t.remove();
                }
            }),
            e
        );
    }
    function RS(r, e) {
        let t = Object.entries({ ...ue, ...Hp })
                .map(([o, u]) =>
                    r.tailwindConfig.corePlugins.includes(o) ? u : null
                )
                .filter(Boolean),
            i = r.tailwindConfig.plugins.map(
                o => (
                    o.__isOptionsFunction && (o = o()),
                    typeof o == 'function' ? o : o.handler
                )
            ),
            n = IS(e),
            s = [
                ue.pseudoElementVariants,
                ue.pseudoClassVariants,
                ue.ariaVariants,
                ue.dataVariants,
            ],
            a = [
                ue.supportsVariants,
                ue.directionVariants,
                ue.reducedMotionVariants,
                ue.prefersContrastVariants,
                ue.darkVariants,
                ue.printVariant,
                ue.screenVariants,
                ue.orientationVariants,
            ];
        return [...t, ...s, ...i, ...a, ...n];
    }
    function MS(r, e) {
        let t = [],
            i = new Map();
        e.variantMap = i;
        let n = new Ua();
        e.offsets = n;
        let s = new Set(),
            a = qS(e.tailwindConfig, e, {
                variantList: t,
                variantMap: i,
                offsets: n,
                classList: s,
            });
        for (let f of r)
            if (Array.isArray(f)) for (let p of f) p(a);
            else f?.(a);
        n.recordVariants(t, f => i.get(f).length);
        for (let [f, p] of i.entries())
            e.variantMap.set(
                f,
                p.map((h, d) => [n.forVariant(f, d), h])
            );
        let o = (e.tailwindConfig.safelist ?? []).filter(Boolean);
        if (o.length > 0) {
            let f = [];
            for (let p of o) {
                if (typeof p == 'string') {
                    e.changedContent.push({ content: p, extension: 'html' });
                    continue;
                }
                if (p instanceof RegExp) {
                    N.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(p);
            }
            if (f.length > 0) {
                let p = new Map(),
                    h = e.tailwindConfig.prefix.length,
                    d = f.some(y => y.pattern.source.includes('!'));
                for (let y of s) {
                    let k = Array.isArray(y)
                        ? (() => {
                              let [w, b] = y,
                                  S = Object.keys(b?.values ?? {}).map(_ =>
                                      Gr(w, _)
                                  );
                              return (
                                  b?.supportsNegativeValues &&
                                      ((S = [...S, ...S.map(_ => '-' + _)]),
                                      (S = [
                                          ...S,
                                          ...S.map(
                                              _ =>
                                                  _.slice(0, h) +
                                                  '-' +
                                                  _.slice(h)
                                          ),
                                      ])),
                                  b.types.some(
                                      ({ type: _ }) => _ === 'color'
                                  ) &&
                                      (S = [
                                          ...S,
                                          ...S.flatMap(_ =>
                                              Object.keys(
                                                  e.tailwindConfig.theme.opacity
                                              ).map(D => `${_}/${D}`)
                                          ),
                                      ]),
                                  d &&
                                      b?.respectImportant &&
                                      (S = [...S, ...S.map(_ => '!' + _)]),
                                  S
                              );
                          })()
                        : [y];
                    for (let w of k)
                        for (let { pattern: b, variants: x = [] } of f)
                            if (
                                ((b.lastIndex = 0),
                                p.has(b) || p.set(b, 0),
                                !!b.test(w))
                            ) {
                                p.set(b, p.get(b) + 1),
                                    e.changedContent.push({
                                        content: w,
                                        extension: 'html',
                                    });
                                for (let S of x)
                                    e.changedContent.push({
                                        content:
                                            S + e.tailwindConfig.separator + w,
                                        extension: 'html',
                                    });
                            }
                }
                for (let [y, k] of p.entries())
                    k === 0 &&
                        N.warn([
                            `The safelist pattern \`${y}\` 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 = [Ya(e, u), Ya(e, 'group'), Ya(e, 'peer')];
        (e.getClassOrder = function (p) {
            let h = new Map(p.map(k => [k, null])),
                d = mn(new Set(p), e);
            d = e.offsets.sort(d);
            let y = BigInt(c.length);
            for (let [, k] of d) h.set(k.raws.tailwind.candidate, y++);
            return p.map(k => {
                let w = h.get(k) ?? null,
                    b = c.indexOf(k);
                return w === null && b !== -1 && (w = BigInt(b)), [k, w];
            });
        }),
            (e.getClassList = function () {
                let p = [];
                for (let h of s)
                    if (Array.isArray(h)) {
                        let [d, y] = h,
                            k = [];
                        for (let [w, b] of Object.entries(y?.values ?? {}))
                            b != null &&
                                (p.push(Gr(d, w)),
                                y?.supportsNegativeValues &&
                                    ut(b) &&
                                    k.push(Gr(d, `-${w}`)));
                        p.push(...k);
                    } else p.push(h);
                return p;
            }),
            (e.getVariants = function () {
                let p = [];
                for (let [h, d] of e.variantOptions.entries())
                    d.variantInfo !== Ha.Base &&
                        p.push({
                            name: h,
                            isArbitrary: d.type === Symbol.for('MATCH_VARIANT'),
                            values: Object.keys(d.values ?? {}),
                            hasDash: h !== '@',
                            selectors({ modifier: y, value: k } = {}) {
                                let w = '__TAILWIND_PLACEHOLDER__',
                                    b = j.rule({ selector: `.${w}` }),
                                    x = j.root({ nodes: [b.clone()] }),
                                    S = x.toString(),
                                    _ = (e.variantMap.get(h) ?? []).flatMap(
                                        ([F, X]) => X
                                    ),
                                    D = [];
                                for (let F of _) {
                                    let X = [],
                                        ce = {
                                            args: {
                                                modifier: y,
                                                value: d.values?.[k] ?? k,
                                            },
                                            separator:
                                                e.tailwindConfig.separator,
                                            modifySelectors(re) {
                                                return (
                                                    x.each(pe => {
                                                        pe.type === 'rule' &&
                                                            (pe.selectors =
                                                                pe.selectors.map(
                                                                    Rl =>
                                                                        re({
                                                                            get className() {
                                                                                return $a(
                                                                                    Rl
                                                                                );
                                                                            },
                                                                            selector:
                                                                                Rl,
                                                                        })
                                                                ));
                                                    }),
                                                    x
                                                );
                                            },
                                            format(re) {
                                                X.push(re);
                                            },
                                            wrap(re) {
                                                X.push(
                                                    `@${re.name} ${re.params} { & }`
                                                );
                                            },
                                            container: x,
                                        },
                                        se = F(ce);
                                    if (
                                        (X.length > 0 && D.push(X),
                                        Array.isArray(se))
                                    )
                                        for (let re of se)
                                            (X = []), re(ce), D.push(X);
                                }
                                let M = [],
                                    B = x.toString();
                                S !== B &&
                                    (x.walkRules(F => {
                                        let X = F.selector,
                                            ce = (0, Wa.default)(se => {
                                                se.walkClasses(re => {
                                                    re.value = `${h}${e.tailwindConfig.separator}${re.value}`;
                                                });
                                            }).processSync(X);
                                        M.push(
                                            X.replace(ce, '&').replace(w, '&')
                                        );
                                    }),
                                    x.walkAtRules(F => {
                                        M.push(
                                            `@${F.name} (${F.params}) { & }`
                                        );
                                    }));
                                let q = D.map(F =>
                                    pn(Yr('&', ...F), {
                                        selector: `.${w}`,
                                        candidate: w,
                                        context: e,
                                        isArbitraryVariant: !(
                                            k in (d.values ?? {})
                                        ),
                                    })
                                        .replace(`.${w}`, '&')
                                        .replace('{ & }', '')
                                        .trim()
                                );
                                return M.length > 0 && q.push(Yr('&', ...M)), q;
                            },
                        });
                return p;
            });
    }
    function gd(r, e) {
        !r.classCache.has(e) ||
            (r.notClassCache.add(e),
            r.classCache.delete(e),
            r.applyClassCache.delete(e),
            r.candidateRuleMap.delete(e),
            r.candidateRuleCache.delete(e),
            (r.stylesheetCache = null));
    }
    function FS(r, e) {
        let t = e.raws.tailwind.candidate;
        if (!!t) {
            for (let i of r.ruleCache)
                i[1].raws.tailwind.candidate === t && r.ruleCache.delete(i);
            gd(r, t);
        }
    }
    function Ja(r, e = [], t = j.root()) {
        let i = {
                disposables: [],
                ruleCache: new Set(),
                candidateRuleCache: new Map(),
                classCache: new Map(),
                applyClassCache: new Map(),
                notClassCache: new Set(r.blocklist ?? []),
                postCssNodeCache: new Map(),
                candidateRuleMap: new Map(),
                tailwindConfig: r,
                changedContent: e,
                variantMap: new Map(),
                stylesheetCache: null,
                variantOptions: new Map(),
                markInvalidUtilityCandidate: s => gd(i, s),
                markInvalidUtilityNode: s => FS(i, s),
            },
            n = RS(i, t);
        return MS(n, i), i;
    }
    function yd(r, e, t, i, n, s) {
        let a = e.opts.from,
            o = i !== null;
        Te.DEBUG && console.log('Source path:', a);
        let u;
        if (o && Mt.has(a)) u = Mt.get(a);
        else if (Jr.has(n)) {
            let p = Jr.get(n);
            it.get(p).add(a), Mt.set(a, p), (u = p);
        }
        let c = sd(a, r);
        if (u && !hd([...s], vn(u)) && !c) return [u, !1];
        if (Mt.has(a)) {
            let p = Mt.get(a);
            if (it.has(p) && (it.get(p).delete(a), it.get(p).size === 0)) {
                it.delete(p);
                for (let [h, d] of Jr) d === p && Jr.delete(h);
                for (let h of p.disposables.splice(0)) h(p);
            }
        }
        Te.DEBUG && console.log('Setting up new context...');
        let f = Ja(t, [], r);
        return (
            Object.assign(f, { userConfigPath: i }),
            hd([...s], vn(f)),
            Jr.set(n, f),
            Mt.set(a, f),
            it.has(f) || it.set(f, new Set()),
            it.get(f).add(a),
            [f, !0]
        );
    }
    var ud,
        Wa,
        Ga,
        Ha,
        Qa,
        Mt,
        Jr,
        it,
        wn = A(() => {
            l();
            Ge();
            Ks();
            Ze();
            (ud = J(va())), (Wa = J(De()));
            Ur();
            Da();
            rn();
            wt();
            qt();
            Ia();
            Pr();
            Yp();
            rt();
            rt();
            li();
            Ae();
            ai();
            Fa();
            gn();
            ad();
            ld();
            $e();
            La();
            (Ga = {
                AddVariant: Symbol.for('ADD_VARIANT'),
                MatchVariant: Symbol.for('MATCH_VARIANT'),
            }),
                (Ha = { Base: 1 << 0, Dynamic: 1 << 1 });
            Qa = new WeakMap();
            (Mt = Qp), (Jr = Jp), (it = fn);
        });
    function Xa(r) {
        return r.ignore
            ? []
            : r.glob
            ? m.env.ROLLUP_WATCH === 'true'
                ? [{ type: 'dependency', file: r.base }]
                : [{ type: 'dir-dependency', dir: r.base, glob: r.glob }]
            : [{ type: 'dependency', file: r.base }];
    }
    var wd = A(() => {
        l();
    });
    function Ka(r) {
        return (
            r.content.files.length === 0 &&
                N.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',
                ]),
            r
        );
    }
    var bd = A(() => {
        l();
        Ae();
    });
    var vd,
        xd = A(() => {
            l();
            vd = () => !1;
        });
    var xn,
        kd = A(() => {
            l();
            xn = {
                sync: r => [].concat(r),
                generateTasks: r => [
                    {
                        dynamic: !1,
                        base: '.',
                        negative: [],
                        positive: [].concat(r),
                        patterns: [].concat(r),
                    },
                ],
                escapePath: r => r,
            };
        });
    var Za,
        Sd = A(() => {
            l();
            Za = r => r;
        });
    var Cd,
        _d = A(() => {
            l();
            Cd = () => '';
        });
    function Ad(r) {
        let e = r,
            t = Cd(r);
        return (
            t !== '.' &&
                ((e = r.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 Od = A(() => {
        l();
        _d();
    });
    function Ed(r, e) {
        let t = e.content.files;
        (t = t.filter(o => typeof o == 'string')), (t = t.map(Za));
        let i = xn.generateTasks(t),
            n = [],
            s = [];
        for (let o of i)
            n.push(...o.positive.map(u => Td(u, !1))),
                s.push(...o.negative.map(u => Td(u, !0)));
        let a = [...n, ...s];
        return (a = LS(r, a)), (a = a.flatMap(BS)), (a = a.map(NS)), a;
    }
    function Td(r, e) {
        let t = { original: r, base: r, ignore: e, pattern: r, glob: null };
        return vd(r) && Object.assign(t, Ad(r)), t;
    }
    function NS(r) {
        let e = Za(r.base);
        return (
            (e = xn.escapePath(e)),
            (r.pattern = r.glob ? `${e}/${r.glob}` : e),
            (r.pattern = r.ignore ? `!${r.pattern}` : r.pattern),
            r
        );
    }
    function LS(r, e) {
        let t = [];
        return (
            r.userConfigPath &&
                r.tailwindConfig.content.relative &&
                (t = [ie.dirname(r.userConfigPath)]),
            e.map(i => ((i.base = ie.resolve(...t, i.base)), i))
        );
    }
    function BS(r) {
        let e = [r];
        try {
            let t = ae.realpathSync(r.base);
            t !== r.base && e.push({ ...r, base: t });
        } catch {}
        return e;
    }
    function Pd(r, e, t) {
        let i = r.tailwindConfig.content.files
            .filter(n => typeof n.raw == 'string')
            .map(({ raw: n, extension: s = 'html' }) => ({
                content: n,
                extension: s,
            }));
        for (let n of $S(e, t)) {
            let s = ae.readFileSync(n, 'utf8'),
                a = ie.extname(n).slice(1);
            i.push({ content: s, extension: a });
        }
        return i;
    }
    function $S(r, e) {
        let t = r.map(s => s.pattern),
            i = new Set();
        Te.DEBUG && console.time('Finding changed files');
        let n = xn.sync(t, { absolute: !0 });
        for (let s of n) {
            let a = e.has(s) ? e.get(s) : -1 / 0,
                o = ae.statSync(s).mtimeMs;
            o >= a && (i.add(s), e.set(s, o));
        }
        return Te.DEBUG && console.timeEnd('Finding changed files'), i;
    }
    var Dd = A(() => {
        l();
        Ge();
        lt();
        xd();
        kd();
        Sd();
        Od();
        rt();
    });
    function zS(r, e) {
        if (eo.has(r)) return eo.get(r);
        let t = Ed(r, e);
        return eo.set(r, t).get(r);
    }
    function jS(r) {
        let e = Js(r);
        if (e !== null) {
            let [i, n, s, a] = Id.get(e) || [],
                o = Ln(e).map(h => h.file),
                u = !1,
                c = new Map();
            for (let h of o) {
                let d = ae.statSync(h).mtimeMs;
                c.set(h, d), (!a || !a.has(h) || d > a.get(h)) && (u = !0);
            }
            if (!u) return [i, e, n, s];
            for (let h of o) delete Fn.cache[h];
            let f = qr(Fn(e));
            f = Ka(f);
            let p = ni(f);
            return Id.set(e, [f, p, o, c]), [f, e, p, o];
        }
        let t = qr(r.config === void 0 ? r : r.config);
        return (t = Ka(t)), [t, null, ni(t), []];
    }
    function to(r) {
        return ({ tailwindDirectives: e, registerDependency: t }) =>
            (i, n) => {
                let [s, a, o, u] = jS(r),
                    c = new Set(u);
                if (e.size > 0) {
                    c.add(n.opts.from);
                    for (let h of n.messages)
                        h.type === 'dependency' && c.add(h.file);
                }
                let [f] = yd(i, n, s, a, o, c),
                    p = zS(f, s);
                if (e.size > 0) {
                    let h = vn(f);
                    for (let d of p) for (let y of Xa(d)) t(y);
                    for (let d of Pd(f, p, h)) f.changedContent.push(d);
                }
                for (let h of u) t({ type: 'dependency', file: h });
                return f;
            };
    }
    var qd,
        Id,
        eo,
        Rd = A(() => {
            l();
            Ge();
            qd = J(Nn());
            $l();
            Vl();
            Qs();
            Vf();
            wn();
            wd();
            bd();
            Dd();
            (Id = new qd.default({ maxSize: 100 })), (eo = new WeakMap());
        });
    function ro(r) {
        let e = new Set(),
            t = new Set(),
            i = new Set();
        if (
            (r.walkAtRules(n => {
                n.name === 'apply' && i.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) &&
                            N.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: i };
    }
    var Md = A(() => {
        l();
        Ae();
    });
    function ht(r, e = void 0, t = void 0) {
        return r.map(i => {
            let n = i.clone(),
                s = i.raws.tailwind?.preserveSource !== !0 || !n.source;
            return (
                e !== void 0 &&
                    s &&
                    ((n.source = e),
                    'walk' in n &&
                        n.walk(a => {
                            a.source = e;
                        })),
                t !== void 0 &&
                    (n.raws.tailwind = { ...n.raws.tailwind, ...t }),
                n
            );
        });
    }
    var Fd = A(() => {
        l();
    });
    function kn(r) {
        return (
            (r = Array.isArray(r) ? r : [r]),
            (r = r.map(e => (e instanceof RegExp ? e.source : e))),
            r.join('')
        );
    }
    function xe(r) {
        return new RegExp(kn(r), 'g');
    }
    function Ft(r) {
        return `(?:${r.map(kn).join('|')})`;
    }
    function io(r) {
        return `(?:${kn(r)})?`;
    }
    function Ld(r) {
        return `(?:${kn(r)})*`;
    }
    function Bd(r) {
        return r && VS.test(r) ? r.replace(Nd, '\\$&') : r || '';
    }
    var Nd,
        VS,
        $d = A(() => {
            l();
            (Nd = /[\\^$.*+?()[\]{}|]/g), (VS = RegExp(Nd.source));
        });
    function zd(r) {
        let e = Array.from(US(r));
        return t => {
            let i = [];
            for (let n of e) i = [...i, ...(t.match(n) ?? [])];
            return i.filter(n => n !== void 0).map(HS);
        };
    }
    function* US(r) {
        let e = r.tailwindConfig.separator,
            t = K(r.tailwindConfig, 'variantGrouping'),
            i =
                r.tailwindConfig.prefix !== ''
                    ? io(xe([/-?/, Bd(r.tailwindConfig.prefix)]))
                    : '',
            n = Ft([
                /\[[^\s:'"`]+:[^\s]+\]/,
                xe([
                    /-?(?:\w+)/,
                    io(
                        Ft([
                            xe([
                                /-(?:\w+-)*\[[^\s:]+\]/,
                                /(?![{([]])/,
                                /(?:\/[^\s'"`\\><$]*)?/,
                            ]),
                            xe([
                                /-(?:\w+-)*\[[^\s]+\]/,
                                /(?![{([]])/,
                                /(?:\/[^\s'"`\\$]*)?/,
                            ]),
                            /[-\/][^\s'"`\\$={><]*/,
                        ])
                    ),
                ]),
            ]),
            s = [
                Ft([
                    xe([/@\[[^\s"'`]+\](\/[^\s"'`]+)?/, e]),
                    xe([/([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/, e]),
                    xe([/[^\s"'`\[\\]+/, e]),
                ]),
                Ft([
                    xe([/([^\s"'`\[\\]+-)?\[[^\s`]+\]/, e]),
                    xe([/[^\s`\[\\]+/, e]),
                ]),
            ];
        for (let a of s)
            yield xe([
                '((?=((',
                a,
                ')+))\\2)?',
                /!?/,
                i,
                t ? Ft([xe([/\(/, n, Ld([/,/, n]), /\)/]), n]) : n,
            ]);
        yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g;
    }
    function HS(r) {
        if (!r.includes('-[')) return r;
        let e = 0,
            t = [],
            i = r.matchAll(WS);
        i = Array.from(i).flatMap(n => {
            let [, ...s] = n;
            return s.map((a, o) =>
                Object.assign([], n, { index: n.index + o, 0: a })
            );
        });
        for (let n of i) {
            let s = n[0],
                a = t[t.length - 1];
            if (
                (s === a
                    ? t.pop()
                    : (s === "'" || s === '"' || s === '`') && t.push(s),
                !a)
            ) {
                if (s === '[') {
                    e++;
                    continue;
                } else if (s === ']') {
                    e--;
                    continue;
                }
                if (e < 0 || (e === 0 && !GS.test(s)))
                    return r.substring(0, n.index);
            }
        }
        return r;
    }
    var WS,
        GS,
        jd = A(() => {
            l();
            $e();
            $d();
            (WS = /([\[\]'"`])([^\[\]'"`])?/g), (GS = /[^"'`\s<>\]]+/);
        });
    function YS(r, e) {
        let t = r.tailwindConfig.content.extract;
        return t[e] || t.DEFAULT || Ud[e] || Ud.DEFAULT(r);
    }
    function QS(r, e) {
        let t = r.content.transform;
        return t[e] || t.DEFAULT || Wd[e] || Wd.DEFAULT;
    }
    function JS(r, e, t, i) {
        Xr.has(e) || Xr.set(e, new Vd.default({ maxSize: 25e3 }));
        for (let n of r.split(`
`))
            if (((n = n.trim()), !i.has(n)))
                if ((i.add(n), Xr.get(e).has(n)))
                    for (let s of Xr.get(e).get(n)) t.add(s);
                else {
                    let s = e(n).filter(o => o !== '!*'),
                        a = new Set(s);
                    for (let o of a) t.add(o);
                    Xr.get(e).set(n, a);
                }
    }
    function XS(r, e) {
        let t = e.offsets.sort(r),
            i = {
                base: new Set(),
                defaults: new Set(),
                components: new Set(),
                utilities: new Set(),
                variants: new Set(),
            };
        for (let [n, s] of t) i[n.layer].add(s);
        return i;
    }
    function no(r) {
        return e => {
            let t = {
                base: null,
                components: null,
                utilities: null,
                variants: null,
            };
            if (
                (e.walkAtRules(d => {
                    d.name === 'tailwind' &&
                        Object.keys(t).includes(d.params) &&
                        (t[d.params] = d);
                }),
                Object.values(t).every(d => d === null))
            )
                return e;
            let i = new Set([Ve]),
                n = new Set();
            mt.DEBUG && console.time('Reading changed files');
            for (let { content: d, extension: y } of r.changedContent) {
                let k = QS(r.tailwindConfig, y),
                    w = YS(r, y);
                JS(k(d), w, i, n);
            }
            mt.DEBUG && console.timeEnd('Reading changed files');
            let s = r.classCache.size;
            mt.DEBUG && console.time('Generate rules'),
                mn(i, r),
                mt.DEBUG && console.timeEnd('Generate rules'),
                mt.DEBUG && console.time('Build stylesheet'),
                (r.stylesheetCache === null || r.classCache.size !== s) &&
                    (r.stylesheetCache = XS([...r.ruleCache], r)),
                mt.DEBUG && console.timeEnd('Build stylesheet');
            let {
                defaults: a,
                base: o,
                components: u,
                utilities: c,
                variants: f,
            } = r.stylesheetCache;
            t.base &&
                (t.base.before(
                    ht([...o, ...a], t.base.source, { layer: 'base' })
                ),
                t.base.remove()),
                t.components &&
                    (t.components.before(
                        ht([...u], t.components.source, { layer: 'components' })
                    ),
                    t.components.remove()),
                t.utilities &&
                    (t.utilities.before(
                        ht([...c], t.utilities.source, { layer: 'utilities' })
                    ),
                    t.utilities.remove());
            let p = Array.from(f).filter(d => {
                let y = d.raws.tailwind?.parentLayer;
                return y === 'components'
                    ? t.components !== null
                    : y === 'utilities'
                    ? t.utilities !== null
                    : !0;
            });
            t.variants
                ? (t.variants.before(
                      ht(p, t.variants.source, { layer: 'variants' })
                  ),
                  t.variants.remove())
                : p.length > 0 &&
                  e.append(ht(p, e.source, { layer: 'variants' }));
            let h = p.some(d => d.raws.tailwind?.parentLayer === 'utilities');
            t.utilities &&
                c.size === 0 &&
                !h &&
                N.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',
                ]),
                mt.DEBUG &&
                    (console.log('Potential classes: ', i.size),
                    console.log('Active contexts: ', fn.size)),
                (r.changedContent = []),
                e.walkAtRules('layer', d => {
                    Object.keys(t).includes(d.params) && d.remove();
                });
        };
    }
    var Vd,
        mt,
        Ud,
        Wd,
        Xr,
        Gd = A(() => {
            l();
            Vd = J(Nn());
            rt();
            gn();
            Ae();
            Fd();
            jd();
            (mt = Te),
                (Ud = { DEFAULT: zd }),
                (Wd = {
                    DEFAULT: r => r,
                    svelte: r => r.replace(/(?:^|\s)class:/g, ' '),
                });
            Xr = new WeakMap();
        });
    function Sn(r) {
        let e = new Map();
        j.root({ nodes: [r.clone()] }).walkRules(s => {
            (0, so.default)(a => {
                a.walkClasses(o => {
                    let u = o.parent.toString(),
                        c = e.get(u);
                    c || e.set(u, (c = new Set())), c.add(o.value);
                });
            }).processSync(s.selector);
        });
        let i = Array.from(e.values(), s => Array.from(s)),
            n = i.flat();
        return Object.assign(n, { groups: i });
    }
    function ao(r) {
        return KS.astSync(r);
    }
    function Hd(r, e) {
        let t = new Set();
        for (let i of r) t.add(i.split(e).pop());
        return Array.from(t);
    }
    function Yd(r, e) {
        let t = r.tailwindConfig.prefix;
        return typeof t == 'function' ? t(e) : t + e;
    }
    function* Qd(r) {
        for (yield r; r.parent; ) yield r.parent, (r = r.parent);
    }
    function ZS(r, e = {}) {
        let t = r.nodes;
        r.nodes = [];
        let i = r.clone(e);
        return (r.nodes = t), i;
    }
    function e2(r) {
        for (let e of Qd(r))
            if (r !== e) {
                if (e.type === 'root') break;
                r = ZS(e, { nodes: [r] });
            }
        return r;
    }
    function t2(r, e) {
        let t = new Map();
        return (
            r.walkRules(i => {
                for (let a of Qd(i))
                    if (a.raws.tailwind?.layer !== void 0) return;
                let n = e2(i),
                    s = e.offsets.create('user');
                for (let a of Sn(i)) {
                    let o = t.get(a) || [];
                    t.set(a, o),
                        o.push([{ layer: 'user', sort: s, important: !1 }, n]);
                }
            }),
            t
        );
    }
    function r2(r, e) {
        for (let t of r) {
            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, s]) => [n, s.clone()])
                );
                continue;
            }
            let i = Array.from(dn(t, e));
            if (i.length === 0) {
                e.notClassCache.add(t);
                continue;
            }
            e.applyClassCache.set(t, i);
        }
        return e.applyClassCache;
    }
    function i2(r) {
        let e = null;
        return {
            get: t => ((e = e || r()), e.get(t)),
            has: t => ((e = e || r()), e.has(t)),
        };
    }
    function n2(r) {
        return {
            get: e => r.flatMap(t => t.get(e) || []),
            has: e => r.some(t => t.has(e)),
        };
    }
    function Jd(r) {
        let e = r.split(/[\s\t\n]+/g);
        return e[e.length - 1] === '!important'
            ? [e.slice(0, -1), !0]
            : [e, !1];
    }
    function Xd(r, e, t) {
        let i = new Set(),
            n = [];
        if (
            (r.walkAtRules('apply', u => {
                let [c] = Jd(u.params);
                for (let f of c) i.add(f);
                n.push(u);
            }),
            n.length === 0)
        )
            return;
        let s = n2([t, r2(i, e)]);
        function a(u, c, f) {
            let p = ao(u),
                h = ao(c),
                y = ao(`.${ve(f)}`).nodes[0].nodes[0];
            return (
                p.each(k => {
                    let w = new Set();
                    h.each(b => {
                        let x = !1;
                        (b = b.clone()),
                            b.walkClasses(S => {
                                S.value === y.value &&
                                    (x ||
                                        (S.replaceWith(
                                            ...k.nodes.map(_ => _.clone())
                                        ),
                                        w.add(b),
                                        (x = !0)));
                            });
                    });
                    for (let b of w) {
                        let x = [[]];
                        for (let S of b.nodes)
                            S.type === 'combinator'
                                ? (x.push(S), x.push([]))
                                : x[x.length - 1].push(S);
                        b.nodes = [];
                        for (let S of x)
                            Array.isArray(S) &&
                                S.sort((_, D) =>
                                    _.type === 'tag' && D.type === 'class'
                                        ? -1
                                        : _.type === 'class' && D.type === 'tag'
                                        ? 1
                                        : _.type === 'class' &&
                                          D.type === 'pseudo' &&
                                          D.value.startsWith('::')
                                        ? -1
                                        : _.type === 'pseudo' &&
                                          _.value.startsWith('::') &&
                                          D.type === 'class'
                                        ? 1
                                        : 0
                                ),
                                (b.nodes = b.nodes.concat(S));
                    }
                    k.replaceWith(...w);
                }),
                p.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, p] = Jd(u.params);
            if (u.parent.type === 'atrule') {
                if (u.parent.name === 'screen') {
                    let h = 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(d => `${h}:${d}`)
                            .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 h of f) {
                if ([Yd(e, 'group'), Yd(e, 'peer')].includes(h))
                    throw u.error(
                        `@apply should not be used with the '${h}' utility`
                    );
                if (!s.has(h))
                    throw u.error(
                        `The \`${h}\` class does not exist. If \`${h}\` is a custom class, make sure it is defined within a \`@layer\` directive.`
                    );
                let d = s.get(h);
                c.push([h, p, d]);
            }
        }
        for (let [u, [c, f]] of o) {
            let p = [];
            for (let [d, y, k] of c) {
                let w = [d, ...Hd([d], e.tailwindConfig.separator)];
                for (let [b, x] of k) {
                    let S = Sn(u),
                        _ = Sn(x);
                    if (
                        ((_ = _.groups
                            .filter(q => q.some(F => w.includes(F)))
                            .flat()),
                        (_ = _.concat(Hd(_, e.tailwindConfig.separator))),
                        S.some(q => _.includes(q)))
                    )
                        throw x.error(
                            `You cannot \`@apply\` the \`${d}\` utility here because it creates a circular dependency.`
                        );
                    let M = j.root({ nodes: [x.clone()] });
                    M.walk(q => {
                        q.source = f;
                    }),
                        (x.type !== 'atrule' ||
                            (x.type === 'atrule' && x.name !== 'keyframes')) &&
                            M.walkRules(q => {
                                if (!Sn(q).some(se => se === d)) {
                                    q.remove();
                                    return;
                                }
                                let F =
                                        typeof e.tailwindConfig.important ==
                                        'string'
                                            ? e.tailwindConfig.important
                                            : null,
                                    ce =
                                        u.raws.tailwind !== void 0 &&
                                        F &&
                                        u.selector.indexOf(F) === 0
                                            ? u.selector.slice(F.length)
                                            : u.selector;
                                (q.selector = a(ce, q.selector, d)),
                                    F &&
                                        ce !== u.selector &&
                                        (q.selector = `${F} ${q.selector}`),
                                    q.walkDecls(se => {
                                        se.important = b.important || y;
                                    });
                            }),
                        !!M.nodes[0] && p.push([b.sort, M.nodes[0]]);
                }
            }
            let h = e.offsets.sort(p).map(d => d[1]);
            u.after(h);
        }
        for (let u of n)
            u.parent.nodes.length > 1 ? u.remove() : u.parent.remove();
        Xd(r, e, t);
    }
    function oo(r) {
        return e => {
            let t = i2(() => t2(e, r));
            Xd(e, r, t);
        };
    }
    var so,
        KS,
        Kd = A(() => {
            l();
            Ze();
            so = J(De());
            gn();
            qt();
            KS = (0, so.default)();
        });
    var Zd = v((LP, Cn) => {
        l();
        (function () {
            'use strict';
            function r(i, n, s) {
                if (!i) return null;
                r.caseSensitive || (i = i.toLowerCase());
                var a = r.threshold === null ? null : r.threshold * i.length,
                    o = r.thresholdAbsolute,
                    u;
                a !== null && o !== null
                    ? (u = Math.min(a, o))
                    : a !== null
                    ? (u = a)
                    : o !== null
                    ? (u = o)
                    : (u = null);
                var c,
                    f,
                    p,
                    h,
                    d,
                    y = n.length;
                for (d = 0; d < y; d++)
                    if (
                        ((f = n[d]),
                        s && (f = f[s]),
                        !!f &&
                            (r.caseSensitive ? (p = f) : (p = f.toLowerCase()),
                            (h = t(i, p, u)),
                            (u === null || h < u) &&
                                ((u = h),
                                s && r.returnWinningObject
                                    ? (c = n[d])
                                    : (c = f),
                                r.returnFirstMatch)))
                    )
                        return c;
                return c || r.nullResultValue;
            }
            (r.threshold = 0.4),
                (r.thresholdAbsolute = 20),
                (r.caseSensitive = !1),
                (r.nullResultValue = null),
                (r.returnWinningObject = null),
                (r.returnFirstMatch = !1),
                typeof Cn != 'undefined' && Cn.exports
                    ? (Cn.exports = r)
                    : (window.didYouMean = r);
            var e = Math.pow(2, 32) - 1;
            function t(i, n, s) {
                s = s || s === 0 ? s : e;
                var a = i.length,
                    o = n.length;
                if (a === 0) return Math.min(s + 1, o);
                if (o === 0) return Math.min(s + 1, a);
                if (Math.abs(a - o) > s) return s + 1;
                var u = [],
                    c,
                    f,
                    p,
                    h,
                    d;
                for (c = 0; c <= o; c++) u[c] = [c];
                for (f = 0; f <= a; f++) u[0][f] = f;
                for (c = 1; c <= o; c++) {
                    for (
                        p = e,
                            h = 1,
                            c > s && (h = c - s),
                            d = o + 1,
                            d > s + c && (d = s + c),
                            f = 1;
                        f <= a;
                        f++
                    )
                        f < h || f > d
                            ? (u[c][f] = s + 1)
                            : n.charAt(c - 1) === i.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] < p && (p = u[c][f]);
                    if (p > s) return s + 1;
                }
                return u[o][a];
            }
        })();
    });
    var th = v((BP, eh) => {
        l();
        var lo = '('.charCodeAt(0),
            uo = ')'.charCodeAt(0),
            _n = "'".charCodeAt(0),
            fo = '"'.charCodeAt(0),
            co = '\\'.charCodeAt(0),
            Nt = '/'.charCodeAt(0),
            po = ','.charCodeAt(0),
            ho = ':'.charCodeAt(0),
            An = '*'.charCodeAt(0),
            s2 = 'u'.charCodeAt(0),
            a2 = 'U'.charCodeAt(0),
            o2 = '+'.charCodeAt(0),
            l2 = /^[a-f0-9?-]+$/i;
        eh.exports = function (r) {
            for (
                var e = [],
                    t = r,
                    i,
                    n,
                    s,
                    a,
                    o,
                    u,
                    c,
                    f,
                    p = 0,
                    h = t.charCodeAt(p),
                    d = t.length,
                    y = [{ nodes: e }],
                    k = 0,
                    w,
                    b = '',
                    x = '',
                    S = '';
                p < d;

            )
                if (h <= 32) {
                    i = p;
                    do (i += 1), (h = t.charCodeAt(i));
                    while (h <= 32);
                    (a = t.slice(p, i)),
                        (s = e[e.length - 1]),
                        h === uo && k
                            ? (S = a)
                            : s && s.type === 'div'
                            ? ((s.after = a), (s.sourceEndIndex += a.length))
                            : h === po ||
                              h === ho ||
                              (h === Nt &&
                                  t.charCodeAt(i + 1) !== An &&
                                  (!w ||
                                      (w &&
                                          w.type === 'function' &&
                                          w.value !== 'calc')))
                            ? (x = a)
                            : e.push({
                                  type: 'space',
                                  sourceIndex: p,
                                  sourceEndIndex: i,
                                  value: a,
                              }),
                        (p = i);
                } else if (h === _n || h === fo) {
                    (i = p),
                        (n = h === _n ? "'" : '"'),
                        (a = { type: 'string', sourceIndex: p, quote: n });
                    do
                        if (((o = !1), (i = t.indexOf(n, i + 1)), ~i))
                            for (u = i; t.charCodeAt(u - 1) === co; )
                                (u -= 1), (o = !o);
                        else (t += n), (i = t.length - 1), (a.unclosed = !0);
                    while (o);
                    (a.value = t.slice(p + 1, i)),
                        (a.sourceEndIndex = a.unclosed ? i : i + 1),
                        e.push(a),
                        (p = i + 1),
                        (h = t.charCodeAt(p));
                } else if (h === Nt && t.charCodeAt(p + 1) === An)
                    (i = t.indexOf('*/', p)),
                        (a = {
                            type: 'comment',
                            sourceIndex: p,
                            sourceEndIndex: i + 2,
                        }),
                        i === -1 &&
                            ((a.unclosed = !0),
                            (i = t.length),
                            (a.sourceEndIndex = i)),
                        (a.value = t.slice(p + 2, i)),
                        e.push(a),
                        (p = i + 2),
                        (h = t.charCodeAt(p));
                else if (
                    (h === Nt || h === An) &&
                    w &&
                    w.type === 'function' &&
                    w.value === 'calc'
                )
                    (a = t[p]),
                        e.push({
                            type: 'word',
                            sourceIndex: p - x.length,
                            sourceEndIndex: p + a.length,
                            value: a,
                        }),
                        (p += 1),
                        (h = t.charCodeAt(p));
                else if (h === Nt || h === po || h === ho)
                    (a = t[p]),
                        e.push({
                            type: 'div',
                            sourceIndex: p - x.length,
                            sourceEndIndex: p + a.length,
                            value: a,
                            before: x,
                            after: '',
                        }),
                        (x = ''),
                        (p += 1),
                        (h = t.charCodeAt(p));
                else if (lo === h) {
                    i = p;
                    do (i += 1), (h = t.charCodeAt(i));
                    while (h <= 32);
                    if (
                        ((f = p),
                        (a = {
                            type: 'function',
                            sourceIndex: p - b.length,
                            value: b,
                            before: t.slice(f + 1, i),
                        }),
                        (p = i),
                        b === 'url' && h !== _n && h !== fo)
                    ) {
                        i -= 1;
                        do
                            if (((o = !1), (i = t.indexOf(')', i + 1)), ~i))
                                for (u = i; t.charCodeAt(u - 1) === co; )
                                    (u -= 1), (o = !o);
                            else
                                (t += ')'),
                                    (i = t.length - 1),
                                    (a.unclosed = !0);
                        while (o);
                        c = i;
                        do (c -= 1), (h = t.charCodeAt(c));
                        while (h <= 32);
                        f < c
                            ? (p !== c + 1
                                  ? (a.nodes = [
                                        {
                                            type: 'word',
                                            sourceIndex: p,
                                            sourceEndIndex: c + 1,
                                            value: t.slice(p, c + 1),
                                        },
                                    ])
                                  : (a.nodes = []),
                              a.unclosed && c + 1 !== i
                                  ? ((a.after = ''),
                                    a.nodes.push({
                                        type: 'space',
                                        sourceIndex: c + 1,
                                        sourceEndIndex: i,
                                        value: t.slice(c + 1, i),
                                    }))
                                  : ((a.after = t.slice(c + 1, i)),
                                    (a.sourceEndIndex = i)))
                            : ((a.after = ''), (a.nodes = [])),
                            (p = i + 1),
                            (a.sourceEndIndex = a.unclosed ? i : p),
                            (h = t.charCodeAt(p)),
                            e.push(a);
                    } else
                        (k += 1),
                            (a.after = ''),
                            (a.sourceEndIndex = p + 1),
                            e.push(a),
                            y.push(a),
                            (e = a.nodes = []),
                            (w = a);
                    b = '';
                } else if (uo === h && k)
                    (p += 1),
                        (h = t.charCodeAt(p)),
                        (w.after = S),
                        (w.sourceEndIndex += S.length),
                        (S = ''),
                        (k -= 1),
                        (y[y.length - 1].sourceEndIndex = p),
                        y.pop(),
                        (w = y[k]),
                        (e = w.nodes);
                else {
                    i = p;
                    do h === co && (i += 1), (i += 1), (h = t.charCodeAt(i));
                    while (
                        i < d &&
                        !(
                            h <= 32 ||
                            h === _n ||
                            h === fo ||
                            h === po ||
                            h === ho ||
                            h === Nt ||
                            h === lo ||
                            (h === An &&
                                w &&
                                w.type === 'function' &&
                                w.value === 'calc') ||
                            (h === Nt &&
                                w.type === 'function' &&
                                w.value === 'calc') ||
                            (h === uo && k)
                        )
                    );
                    (a = t.slice(p, i)),
                        lo === h
                            ? (b = a)
                            : (s2 === a.charCodeAt(0) ||
                                  a2 === a.charCodeAt(0)) &&
                              o2 === a.charCodeAt(1) &&
                              l2.test(a.slice(2))
                            ? e.push({
                                  type: 'unicode-range',
                                  sourceIndex: p,
                                  sourceEndIndex: i,
                                  value: a,
                              })
                            : e.push({
                                  type: 'word',
                                  sourceIndex: p,
                                  sourceEndIndex: i,
                                  value: a,
                              }),
                        (p = i);
                }
            for (p = y.length - 1; p; p -= 1)
                (y[p].unclosed = !0), (y[p].sourceEndIndex = t.length);
            return y[0].nodes;
        };
    });
    var ih = v(($P, rh) => {
        l();
        rh.exports = function r(e, t, i) {
            var n, s, a, o;
            for (n = 0, s = e.length; n < s; n += 1)
                (a = e[n]),
                    i || (o = t(a, n, e)),
                    o !== !1 &&
                        a.type === 'function' &&
                        Array.isArray(a.nodes) &&
                        r(a.nodes, t, i),
                    i && t(a, n, e);
        };
    });
    var oh = v((zP, ah) => {
        l();
        function nh(r, e) {
            var t = r.type,
                i = r.value,
                n,
                s;
            return e && (s = e(r)) !== void 0
                ? s
                : t === 'word' || t === 'space'
                ? i
                : t === 'string'
                ? ((n = r.quote || ''), n + i + (r.unclosed ? '' : n))
                : t === 'comment'
                ? '/*' + i + (r.unclosed ? '' : '*/')
                : t === 'div'
                ? (r.before || '') + i + (r.after || '')
                : Array.isArray(r.nodes)
                ? ((n = sh(r.nodes, e)),
                  t !== 'function'
                      ? n
                      : i +
                        '(' +
                        (r.before || '') +
                        n +
                        (r.after || '') +
                        (r.unclosed ? '' : ')'))
                : i;
        }
        function sh(r, e) {
            var t, i;
            if (Array.isArray(r)) {
                for (t = '', i = r.length - 1; ~i; i -= 1) t = nh(r[i], e) + t;
                return t;
            }
            return nh(r, e);
        }
        ah.exports = sh;
    });
    var uh = v((jP, lh) => {
        l();
        var On = '-'.charCodeAt(0),
            En = '+'.charCodeAt(0),
            mo = '.'.charCodeAt(0),
            u2 = 'e'.charCodeAt(0),
            f2 = 'E'.charCodeAt(0);
        function c2(r) {
            var e = r.charCodeAt(0),
                t;
            if (e === En || e === On) {
                if (((t = r.charCodeAt(1)), t >= 48 && t <= 57)) return !0;
                var i = r.charCodeAt(2);
                return t === mo && i >= 48 && i <= 57;
            }
            return e === mo
                ? ((t = r.charCodeAt(1)), t >= 48 && t <= 57)
                : e >= 48 && e <= 57;
        }
        lh.exports = function (r) {
            var e = 0,
                t = r.length,
                i,
                n,
                s;
            if (t === 0 || !c2(r)) return !1;
            for (
                i = r.charCodeAt(e), (i === En || i === On) && e++;
                e < t && ((i = r.charCodeAt(e)), !(i < 48 || i > 57));

            )
                e += 1;
            if (
                ((i = r.charCodeAt(e)),
                (n = r.charCodeAt(e + 1)),
                i === mo && n >= 48 && n <= 57)
            )
                for (
                    e += 2;
                    e < t && ((i = r.charCodeAt(e)), !(i < 48 || i > 57));

                )
                    e += 1;
            if (
                ((i = r.charCodeAt(e)),
                (n = r.charCodeAt(e + 1)),
                (s = r.charCodeAt(e + 2)),
                (i === u2 || i === f2) &&
                    ((n >= 48 && n <= 57) ||
                        ((n === En || n === On) && s >= 48 && s <= 57)))
            )
                for (
                    e += n === En || n === On ? 3 : 2;
                    e < t && ((i = r.charCodeAt(e)), !(i < 48 || i > 57));

                )
                    e += 1;
            return { number: r.slice(0, e), unit: r.slice(e) };
        };
    });
    var Kr = v((VP, ph) => {
        l();
        var p2 = th(),
            fh = ih(),
            ch = oh();
        function nt(r) {
            return this instanceof nt
                ? ((this.nodes = p2(r)), this)
                : new nt(r);
        }
        nt.prototype.toString = function () {
            return Array.isArray(this.nodes) ? ch(this.nodes) : '';
        };
        nt.prototype.walk = function (r, e) {
            return fh(this.nodes, r, e), this;
        };
        nt.unit = uh();
        nt.walk = fh;
        nt.stringify = ch;
        ph.exports = nt;
    });
    function yo(r) {
        return typeof r == 'object' && r !== null;
    }
    function d2(r, e) {
        let t = He(e);
        do if ((t.pop(), (0, Zr.default)(r, t) !== void 0)) break;
        while (t.length);
        return t.length ? t : void 0;
    }
    function Lt(r) {
        return typeof r == 'string'
            ? r
            : r.reduce(
                  (e, t, i) =>
                      t.includes('.')
                          ? `${e}[${t}]`
                          : i === 0
                          ? t
                          : `${e}.${t}`,
                  ''
              );
    }
    function hh(r) {
        return r.map(e => `'${e}'`).join(', ');
    }
    function mh(r) {
        return hh(Object.keys(r));
    }
    function wo(r, e, t, i = {}) {
        let n = Array.isArray(e) ? Lt(e) : e.replace(/^['"]+|['"]+$/g, ''),
            s = Array.isArray(e) ? e : He(n),
            a = (0, Zr.default)(r.theme, s, t);
        if (a === void 0) {
            let u = `'${n}' does not exist in your theme config.`,
                c = s.slice(0, -1),
                f = (0, Zr.default)(r.theme, c);
            if (yo(f)) {
                let p = Object.keys(f).filter(d => wo(r, [...c, d]).isValid),
                    h = (0, dh.default)(s[s.length - 1], p);
                h
                    ? (u += ` Did you mean '${Lt([...c, h])}'?`)
                    : p.length > 0 &&
                      (u += ` '${Lt(c)}' has the following valid keys: ${hh(
                          p
                      )}`);
            } else {
                let p = d2(r.theme, n);
                if (p) {
                    let h = (0, Zr.default)(r.theme, p);
                    yo(h)
                        ? (u += ` '${Lt(p)}' has the following keys: ${mh(h)}`)
                        : (u += ` '${Lt(p)}' is not an object.`);
                } else
                    u += ` Your theme has the following top-level keys: ${mh(
                        r.theme
                    )}`;
            }
            return { isValid: !1, error: u };
        }
        if (
            !(
                typeof a == 'string' ||
                typeof a == 'number' ||
                typeof a == 'function' ||
                a instanceof String ||
                a instanceof Number ||
                Array.isArray(a)
            )
        ) {
            let u = `'${n}' was found but does not resolve to a string.`;
            if (yo(a)) {
                let c = Object.keys(a).filter(f => wo(r, [...s, f]).isValid);
                c.length &&
                    (u += ` Did you mean something like '${Lt([
                        ...s,
                        c[0],
                    ])}'?`);
            }
            return { isValid: !1, error: u };
        }
        let [o] = s;
        return { isValid: !0, value: je(o)(a, i) };
    }
    function h2(r, e, t) {
        e = e.map(n => gh(r, n, t));
        let i = [''];
        for (let n of e)
            n.type === 'div' && n.value === ','
                ? i.push('')
                : (i[i.length - 1] += go.default.stringify(n));
        return i;
    }
    function gh(r, e, t) {
        if (e.type === 'function' && t[e.value] !== void 0) {
            let i = h2(r, e.nodes, t);
            (e.type = 'word'), (e.value = t[e.value](r, ...i));
        }
        return e;
    }
    function m2(r, e, t) {
        return (0, go.default)(e)
            .walk(i => {
                gh(r, i, t);
            })
            .toString();
    }
    function* y2(r) {
        r = r.replace(/^['"]+|['"]+$/g, '');
        let e = r.match(/^([^\s]+)(?![^\[]*\])(?:\s*\/\s*([^\/\s]+))$/),
            t;
        yield [r, void 0], e && ((r = e[1]), (t = e[2]), yield [r, t]);
    }
    function w2(r, e, t) {
        let i = Array.from(y2(e)).map(([n, s]) =>
            Object.assign(wo(r, n, t, { opacityValue: s }), {
                resolvedPath: n,
                alpha: s,
            })
        );
        return i.find(n => n.isValid) ?? i[0];
    }
    function yh(r) {
        let e = r.tailwindConfig,
            t = {
                theme: (i, n, ...s) => {
                    let {
                        isValid: a,
                        value: o,
                        error: u,
                        alpha: c,
                    } = w2(e, n, s.length ? s : void 0);
                    if (!a) {
                        let h = i.parent,
                            d = h?.raws.tailwind?.candidate;
                        if (h && d !== void 0) {
                            r.markInvalidUtilityNode(h),
                                h.remove(),
                                N.warn('invalid-theme-key-in-class', [
                                    `The utility \`${d}\` contains an invalid theme value and was not generated.`,
                                ]);
                            return;
                        }
                        throw i.error(u);
                    }
                    let f = kt(o),
                        p = f !== void 0 && typeof f == 'function';
                    return (
                        (c !== void 0 || p) &&
                            (c === void 0 && (c = 1), (o = qe(f, c, f))),
                        o
                    );
                },
                screen: (i, n) => {
                    n = n.replace(/^['"]+/g, '').replace(/['"]+$/g, '');
                    let a = tt(e.theme.screens).find(({ name: o }) => o === n);
                    if (!a)
                        throw i.error(
                            `The '${n}' screen does not exist in your theme.`
                        );
                    return et(a);
                },
            };
        return i => {
            i.walk(n => {
                let s = g2[n.type];
                s !== void 0 && (n[s] = m2(n, n[s], t));
            });
        };
    }
    var Zr,
        dh,
        go,
        g2,
        wh = A(() => {
            l();
            (Zr = J(va())), (dh = J(Zd()));
            Ur();
            go = J(Kr());
            ln();
            sn();
            li();
            Cr();
            Pr();
            Ae();
            g2 = { atrule: 'params', decl: 'value' };
        });
    function bh({ tailwindConfig: { theme: r } }) {
        return function (e) {
            e.walkAtRules('screen', t => {
                let i = t.params,
                    s = tt(r.screens).find(({ name: a }) => a === i);
                if (!s) throw t.error(`No \`${i}\` screen found.`);
                (t.name = 'media'), (t.params = et(s));
            });
        };
    }
    var vh = A(() => {
        l();
        ln();
        sn();
    });
    function b2(r) {
        let e = r
                .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']),
            i = e.findIndex(o => t.has(o.type));
        if (i === -1) return e.reverse().join('').trim();
        let n = e[i],
            s = xh[n.type] ? xh[n.type](n) : n;
        e = e.slice(0, i);
        let a = e.findIndex(o => o.type === 'combinator' && o.value === '>');
        return (
            a !== -1 && (e.splice(0, a), e.unshift(Tn.default.universal())),
            [s, ...e.reverse()].join('').trim()
        );
    }
    function x2(r) {
        return bo.has(r) || bo.set(r, v2.transformSync(r)), bo.get(r);
    }
    function vo({ tailwindConfig: r }) {
        return e => {
            let t = new Map(),
                i = new Set();
            if (
                (e.walkAtRules('defaults', n => {
                    if (n.nodes && n.nodes.length > 0) {
                        i.add(n);
                        return;
                    }
                    let s = n.params;
                    t.has(s) || t.set(s, new Set()),
                        t.get(s).add(n.parent),
                        n.remove();
                }),
                K(r, 'optimizeUniversalDefaults'))
            )
                for (let n of i) {
                    let s = new Map(),
                        a = t.get(n.params) ?? [];
                    for (let o of a)
                        for (let u of x2(o.selector)) {
                            let c =
                                    u.includes(':-') || u.includes('::-')
                                        ? u
                                        : '__DEFAULT__',
                                f = s.get(c) ?? new Set();
                            s.set(c, f), f.add(u);
                        }
                    if (K(r, 'optimizeUniversalDefaults')) {
                        if (s.size === 0) {
                            n.remove();
                            continue;
                        }
                        for (let [, o] of s) {
                            let u = j.rule({ source: n.source });
                            (u.selectors = [...o]),
                                u.append(n.nodes.map(c => c.clone())),
                                n.before(u);
                        }
                    }
                    n.remove();
                }
            else if (i.size) {
                let n = j.rule({ selectors: ['*', '::before', '::after'] });
                for (let a of i)
                    n.append(a.nodes),
                        n.parent || a.before(n),
                        n.source || (n.source = a.source),
                        a.remove();
                let s = n.clone({ selectors: ['::backdrop'] });
                n.after(s);
            }
        };
    }
    var Tn,
        xh,
        v2,
        bo,
        kh = A(() => {
            l();
            Ze();
            Tn = J(De());
            $e();
            xh = {
                id(r) {
                    return Tn.default.attribute({
                        attribute: 'id',
                        operator: '=',
                        value: r.value,
                        quoteMark: '"',
                    });
                },
            };
            (v2 = (0, Tn.default)(r =>
                r.map(e => {
                    let t = e
                        .split(i => i.type === 'combinator' && i.value === ' ')
                        .pop();
                    return b2(t);
                })
            )),
                (bo = new Map());
        });
    function xo() {
        function r(e) {
            let t = null;
            e.each(i => {
                if (!k2.has(i.type)) {
                    t = null;
                    return;
                }
                if (t === null) {
                    t = i;
                    return;
                }
                let n = Sh[i.type];
                i.type === 'atrule' && i.name === 'font-face'
                    ? (t = i)
                    : n.every(
                          s =>
                              (i[s] ?? '').replace(/\s+/g, ' ') ===
                              (t[s] ?? '').replace(/\s+/g, ' ')
                      )
                    ? (i.nodes && t.append(i.nodes), i.remove())
                    : (t = i);
            }),
                e.each(i => {
                    i.type === 'atrule' && r(i);
                });
        }
        return e => {
            r(e);
        };
    }
    var Sh,
        k2,
        Ch = A(() => {
            l();
            (Sh = { atrule: ['name', 'params'], rule: ['selector'] }),
                (k2 = new Set(Object.keys(Sh)));
        });
    function ko() {
        return r => {
            r.walkRules(e => {
                let t = new Map(),
                    i = new Set([]),
                    n = new Map();
                e.walkDecls(s => {
                    if (s.parent === e) {
                        if (t.has(s.prop)) {
                            if (t.get(s.prop).value === s.value) {
                                i.add(t.get(s.prop)), t.set(s.prop, s);
                                return;
                            }
                            n.has(s.prop) || n.set(s.prop, new Set()),
                                n.get(s.prop).add(t.get(s.prop)),
                                n.get(s.prop).add(s);
                        }
                        t.set(s.prop, s);
                    }
                });
                for (let s of i) s.remove();
                for (let s of n.values()) {
                    let a = new Map();
                    for (let o of s) {
                        let u = C2(o.value);
                        u !== null &&
                            (a.has(u) || a.set(u, new Set()), a.get(u).add(o));
                    }
                    for (let o of a.values()) {
                        let u = Array.from(o).slice(0, -1);
                        for (let c of u) c.remove();
                    }
                }
            });
        };
    }
    function C2(r) {
        let e = /^-?\d*.?\d+([\w%]+)?$/g.exec(r);
        return e ? e[1] ?? S2 : null;
    }
    var S2,
        _h = A(() => {
            l();
            S2 = Symbol('unitless-number');
        });
    function _2(r) {
        if (!r.walkAtRules) return;
        let e = new Set();
        if (
            (r.walkAtRules('apply', t => {
                e.add(t.parent);
            }),
            e.size !== 0)
        )
            for (let t of e) {
                let i = [],
                    n = [];
                for (let s of t.nodes)
                    s.type === 'atrule' && s.name === 'apply'
                        ? (n.length > 0 && (i.push(n), (n = [])), i.push([s]))
                        : n.push(s);
                if ((n.length > 0 && i.push(n), i.length !== 1)) {
                    for (let s of [...i].reverse()) {
                        let a = t.clone({ nodes: [] });
                        a.append(s), t.after(a);
                    }
                    t.remove();
                }
            }
    }
    function Pn() {
        return r => {
            _2(r);
        };
    }
    var Ah = A(() => {
        l();
    });
    function Oh(r) {
        return (e, t) => {
            let i = !1;
            e.walkAtRules('tailwind', n => {
                if (i) return !1;
                if (n.parent && n.parent.type !== 'root')
                    return (
                        (i = !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 (i) return !1;
                    n.walkRules(
                        s => (
                            (i = !0),
                            s.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 Eh = A(() => {
        l();
    });
    function Dn(r) {
        return function (e, t) {
            let { tailwindDirectives: i, applyDirectives: n } = ro(e);
            Oh()(e, t), Pn()(e, t);
            let s = r({
                tailwindDirectives: i,
                applyDirectives: n,
                registerDependency(a) {
                    t.messages.push({
                        plugin: 'tailwindcss',
                        parent: t.opts.from,
                        ...a,
                    });
                },
                createContext(a, o) {
                    return Ja(a, o, e);
                },
            })(e, t);
            if (s.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."
                );
            Ef(s.tailwindConfig),
                no(s)(e, t),
                Pn()(e, t),
                oo(s)(e, t),
                yh(s)(e, t),
                bh(s)(e, t),
                vo(s)(e, t),
                xo(s)(e, t),
                ko(s)(e, t);
        };
    }
    var Th = A(() => {
        l();
        Md();
        Gd();
        Kd();
        wh();
        vh();
        kh();
        Ch();
        _h();
        Ah();
        Eh();
        wn();
        $e();
    });
    function Ph(r, e) {
        let t = null,
            i = null;
        return (
            r.walkAtRules('config', n => {
                if (
                    ((i = n.source?.input.file ?? e.opts.from ?? null),
                    i === 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 s = n.params.match(/(['"])(.*?)\1/);
                if (!s)
                    throw n.error(
                        'A path is required when using the `@config` directive.'
                    );
                let a = s[2];
                if (ie.isAbsolute(a))
                    throw n.error(
                        'The `@config` directive cannot be used with an absolute path.'
                    );
                if (((t = ie.resolve(ie.dirname(i), a)), !ae.existsSync(t)))
                    throw n.error(
                        `The config file at "${a}" does not exist. Make sure the path is correct and the file exists.`
                    );
                n.remove();
            }),
            t || null
        );
    }
    var Dh = A(() => {
        l();
        Ge();
        lt();
    });
    var qh = v((E3, So) => {
        l();
        Rd();
        Th();
        rt();
        Dh();
        So.exports = function (e) {
            return {
                postcssPlugin: 'tailwindcss',
                plugins: [
                    Te.DEBUG &&
                        function (t) {
                            return (
                                console.log(`
`),
                                console.time('JIT TOTAL'),
                                t
                            );
                        },
                    function (t, i) {
                        e = Ph(t, i) ?? e;
                        let n = to(e);
                        if (t.type === 'document') {
                            let s = t.nodes.filter(a => a.type === 'root');
                            for (let a of s) a.type === 'root' && Dn(n)(a, i);
                            return;
                        }
                        Dn(n)(t, i);
                    },
                    Te.DEBUG &&
                        function (t) {
                            return (
                                console.timeEnd('JIT TOTAL'),
                                console.log(`
`),
                                t
                            );
                        },
                ].filter(Boolean),
            };
        };
        So.exports.postcss = !0;
    });
    var Co = v((T3, Ih) => {
        l();
        Ih.exports = () => [
            'and_chr 92',
            'and_uc 12.12',
            'chrome 92',
            'chrome 91',
            'edge 91',
            'firefox 89',
            'ios_saf 14.5-14.7',
            'ios_saf 14.0-14.4',
            'safari 14.1',
            'samsung 14.0',
        ];
    });
    var qn = {};
    Ce(qn, { agents: () => A2, feature: () => O2 });
    function O2() {
        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',
                },
                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',
                    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',
                },
                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',
                    9.1: 'y',
                    10.1: 'y',
                    11.1: 'y',
                    12.1: 'y',
                    13.1: 'y',
                    14.1: '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',
                    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',
                    '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.4': '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.7': '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',
                    92: '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',
                    64: 'y',
                    11.1: 'n',
                    11.5: 'n',
                    12.1: 'n',
                },
                and_chr: { 92: 'y' },
                and_ff: { 90: 'y' },
                ie_mob: { 10: 'n', 11: 'n' },
                and_uc: { 12.12: 'y' },
                samsung: {
                    4: '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',
                },
                and_qq: { 10.4: 'y' },
                baidu: { 7.12: 'y' },
                kaios: { 2.5: 'y' },
            },
        };
    }
    var A2,
        In = A(() => {
            l();
            A2 = {
                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: { 64: 'webkit' } },
                and_chr: { prefix: 'webkit' },
                and_ff: { prefix: 'moz' },
                ie_mob: { prefix: 'ms' },
                and_uc: {
                    prefix: 'webkit',
                    prefix_exceptions: { 12.12: 'webkit' },
                },
                samsung: { prefix: 'webkit' },
                and_qq: { prefix: 'webkit' },
                baidu: { prefix: 'webkit' },
                kaios: { prefix: 'moz' },
            };
        });
    var Rh = v(() => {
        l();
    });
    var ne = v((q3, st) => {
        l();
        var { list: _o } = me();
        st.exports.error = function (r) {
            let e = new Error(r);
            throw ((e.autoprefixer = !0), e);
        };
        st.exports.uniq = function (r) {
            return [...new Set(r)];
        };
        st.exports.removeNote = function (r) {
            return r.includes(' ') ? r.split(' ')[0] : r;
        };
        st.exports.escapeRegexp = function (r) {
            return r.replace(/[$()*+-.?[\\\]^{|}]/g, '\\$&');
        };
        st.exports.regexp = function (r, e = !0) {
            return (
                e && (r = this.escapeRegexp(r)),
                new RegExp(`(^|[\\s,(])(${r}($|[\\s(,]))`, 'gi')
            );
        };
        st.exports.editList = function (r, e) {
            let t = _o.comma(r),
                i = e(t, []);
            if (t === i) return r;
            let n = r.match(/,\s*/);
            return (n = n ? n[0] : ', '), i.join(n);
        };
        st.exports.splitSelector = function (r) {
            return _o
                .comma(r)
                .map(e => _o.space(e).map(t => t.split(/(?=\.|#)/g)));
        };
    });
    var at = v((I3, Nh) => {
        l();
        var E2 = Co(),
            Mh = (In(), qn).agents,
            T2 = ne(),
            Fh = class {
                static prefixes() {
                    if (this.prefixesCache) return this.prefixesCache;
                    this.prefixesCache = [];
                    for (let e in Mh)
                        this.prefixesCache.push(`-${Mh[e].prefix}-`);
                    return (
                        (this.prefixesCache = T2.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, i, n) {
                    (this.data = e),
                        (this.options = i || {}),
                        (this.browserslistOpts = n || {}),
                        (this.selected = this.parse(t));
                }
                parse(e) {
                    let t = {};
                    for (let i in this.browserslistOpts)
                        t[i] = this.browserslistOpts[i];
                    return (t.path = this.options.from), E2(e, t);
                }
                prefix(e) {
                    let [t, i] = e.split(' '),
                        n = this.data[t],
                        s = n.prefix_exceptions && n.prefix_exceptions[i];
                    return s || (s = n.prefix), `-${s}-`;
                }
                isSelected(e) {
                    return this.selected.includes(e);
                }
            };
        Nh.exports = Fh;
    });
    var ei = v((R3, Lh) => {
        l();
        Lh.exports = {
            prefix(r) {
                let e = r.match(/^(-\w+-)/);
                return e ? e[0] : '';
            },
            unprefixed(r) {
                return r.replace(/^-\w+-/, '');
            },
        };
    });
    var Bt = v((M3, $h) => {
        l();
        var P2 = at(),
            Bh = ei(),
            D2 = ne();
        function Ao(r, e) {
            let t = new r.constructor();
            for (let i of Object.keys(r || {})) {
                let n = r[i];
                i === 'parent' && typeof n == 'object'
                    ? e && (t[i] = e)
                    : i === 'source' || i === null
                    ? (t[i] = n)
                    : Array.isArray(n)
                    ? (t[i] = n.map(s => Ao(s, t)))
                    : i !== '_autoprefixerPrefix' &&
                      i !== '_autoprefixerValues' &&
                      i !== 'proxyCache' &&
                      (typeof n == 'object' && n !== null && (n = Ao(n, t)),
                      (t[i] = n));
            }
            return t;
        }
        var Rn = class {
            static hack(e) {
                return (
                    this.hacks || (this.hacks = {}),
                    e.names.map(t => ((this.hacks[t] = e), this.hacks[t]))
                );
            }
            static load(e, t, i) {
                let n = this.hacks && this.hacks[e];
                return n ? new n(e, t, i) : new this(e, t, i);
            }
            static clone(e, t) {
                let i = Ao(e);
                for (let n in t) i[n] = t[n];
                return i;
            }
            constructor(e, t, i) {
                (this.prefixes = t), (this.name = e), (this.all = i);
            }
            parentPrefix(e) {
                let t;
                return (
                    typeof e._autoprefixerPrefix != 'undefined'
                        ? (t = e._autoprefixerPrefix)
                        : e.type === 'decl' && e.prop[0] === '-'
                        ? (t = Bh.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 = Bh.prefix(e.name))
                        : (t = this.parentPrefix(e.parent)),
                    P2.prefixes().includes(t) || (t = !1),
                    (e._autoprefixerPrefix = t),
                    e._autoprefixerPrefix
                );
            }
            process(e, t) {
                if (!this.check(e)) return;
                let i = this.parentPrefix(e),
                    n = this.prefixes.filter(a => !i || i === D2.removeNote(a)),
                    s = [];
                for (let a of n) this.add(e, a, s.concat([a]), t) && s.push(a);
                return s;
            }
            clone(e, t) {
                return Rn.clone(e, t);
            }
        };
        $h.exports = Rn;
    });
    var I = v((F3, Vh) => {
        l();
        var q2 = Bt(),
            I2 = at(),
            zh = ne(),
            jh = class extends q2 {
                check() {
                    return !0;
                }
                prefixed(e, t) {
                    return t + e;
                }
                normalize(e) {
                    return e;
                }
                otherPrefixes(e, t) {
                    for (let i of I2.prefixes())
                        if (i !== t && e.includes(i)) 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 i = 0;
                    for (let n of e)
                        (n = zh.removeNote(n)), n.length > i && (i = n.length);
                    return (t._autoprefixerMax = i), t._autoprefixerMax;
                }
                calcBefore(e, t, i = '') {
                    let s = this.maxPrefixed(e, t) - zh.removeNote(i).length,
                        a = t.raw('before');
                    return s > 0 && (a += Array(s).fill(' ').join('')), a;
                }
                restoreBefore(e) {
                    let t = e.raw('before').split(`
`),
                        i = t[t.length - 1];
                    this.all.group(e).up(n => {
                        let s = n.raw('before').split(`
`),
                            a = s[s.length - 1];
                        a.length < i.length && (i = a);
                    }),
                        (t[t.length - 1] = i),
                        (e.raws.before = t.join(`
`));
                }
                insert(e, t, i) {
                    let n = this.set(this.clone(e), t);
                    if (
                        !(
                            !n ||
                            e.parent.some(
                                a => a.prop === n.prop && a.value === n.value
                            )
                        )
                    )
                        return (
                            this.needCascade(e) &&
                                (n.raws.before = this.calcBefore(i, e, t)),
                            e.parent.insertBefore(e, n)
                        );
                }
                isAlready(e, t) {
                    let i = this.all.group(e).up(n => n.prop === t);
                    return (
                        i || (i = this.all.group(e).down(n => n.prop === t)), i
                    );
                }
                add(e, t, i, n) {
                    let s = this.prefixed(e.prop, t);
                    if (
                        !(
                            this.isAlready(e, s) ||
                            this.otherPrefixes(e.value, t)
                        )
                    )
                        return this.insert(e, t, i, n);
                }
                process(e, t) {
                    if (!this.needCascade(e)) {
                        super.process(e, t);
                        return;
                    }
                    let i = super.process(e, t);
                    !i ||
                        !i.length ||
                        (this.restoreBefore(e),
                        (e.raws.before = this.calcBefore(i, e)));
                }
                old(e, t) {
                    return [this.prefixed(e, t)];
                }
            };
        Vh.exports = jh;
    });
    var Wh = v((N3, Uh) => {
        l();
        Uh.exports = function r(e) {
            return {
                mul: t => new r(e * t),
                div: t => new r(e / t),
                simplify: () => new r(e),
                toString: () => e.toString(),
            };
        };
    });
    var Yh = v((L3, Hh) => {
        l();
        var R2 = Wh(),
            M2 = Bt(),
            Oo = ne(),
            F2 = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpcm|dpi|x)/gi,
            N2 = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpcm|dpi|x)/i,
            Gh = class extends M2 {
                prefixName(e, t) {
                    return e === '-moz-'
                        ? t + '--moz-device-pixel-ratio'
                        : e + t + '-device-pixel-ratio';
                }
                prefixQuery(e, t, i, n, s) {
                    return (
                        (n = new R2(n)),
                        s === 'dpi'
                            ? (n = n.div(96))
                            : s === 'dpcm' && (n = n.mul(2.54).div(96)),
                        (n = n.simplify()),
                        e === '-o-' && (n = n.n + '/' + n.d),
                        this.prefixName(e, t) + i + 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 = Oo.editList(e.params, t =>
                        t.filter(i => this.bad.every(n => !i.includes(n)))
                    );
                }
                process(e) {
                    let t = this.parentPrefix(e),
                        i = t ? [t] : this.prefixes;
                    e.params = Oo.editList(e.params, (n, s) => {
                        for (let a of n) {
                            if (
                                !a.includes('min-resolution') &&
                                !a.includes('max-resolution')
                            ) {
                                s.push(a);
                                continue;
                            }
                            for (let o of i) {
                                let u = a.replace(F2, c => {
                                    let f = c.match(N2);
                                    return this.prefixQuery(
                                        o,
                                        f[1],
                                        f[2],
                                        f[3],
                                        f[4]
                                    );
                                });
                                s.push(u);
                            }
                            s.push(a);
                        }
                        return Oo.uniq(s);
                    });
                }
            };
        Hh.exports = Gh;
    });
    var Zh = v((B3, Kh) => {
        l();
        var { list: L2 } = me(),
            Qh = Kr(),
            B2 = at(),
            Jh = ei(),
            Xh = class {
                constructor(e) {
                    (this.props = ['transition', 'transition-property']),
                        (this.prefixes = e);
                }
                add(e, t) {
                    let i,
                        n,
                        s = this.prefixes.add[e.prop],
                        a = this.ruleVendorPrefixes(e),
                        o = a || (s && s.prefixes) || [],
                        u = this.parse(e.value),
                        c = u.map(d => this.findProp(d)),
                        f = [];
                    if (c.some(d => d[0] === '-')) return;
                    for (let d of u) {
                        if (((n = this.findProp(d)), n[0] === '-')) continue;
                        let y = this.prefixes.add[n];
                        if (!(!y || !y.prefixes))
                            for (i of y.prefixes) {
                                if (a && !a.some(w => i.includes(w))) continue;
                                let k = this.prefixes.prefixed(n, i);
                                k !== '-ms-transform' &&
                                    !c.includes(k) &&
                                    (this.disabled(n, i) ||
                                        f.push(this.clone(n, k, d)));
                            }
                    }
                    u = u.concat(f);
                    let p = this.stringify(u),
                        h = this.stringify(
                            this.cleanFromUnprefixed(u, '-webkit-')
                        );
                    if (
                        (o.includes('-webkit-') &&
                            this.cloneBefore(e, `-webkit-${e.prop}`, h),
                        this.cloneBefore(e, e.prop, h),
                        o.includes('-o-'))
                    ) {
                        let d = this.stringify(
                            this.cleanFromUnprefixed(u, '-o-')
                        );
                        this.cloneBefore(e, `-o-${e.prop}`, d);
                    }
                    for (i of o)
                        if (i !== '-webkit-' && i !== '-o-') {
                            let d = this.stringify(
                                this.cleanOtherPrefixes(u, i)
                            );
                            this.cloneBefore(e, i + e.prop, d);
                        }
                    p !== e.value &&
                        !this.already(e, e.prop, p) &&
                        (this.checkForWarning(t, e),
                        e.cloneBefore(),
                        (e.value = p));
                }
                findProp(e) {
                    let t = e[0].value;
                    if (/^\d/.test(t)) {
                        for (let [i, n] of e.entries())
                            if (i !== 0 && n.type === 'word') return n.value;
                    }
                    return t;
                }
                already(e, t, i) {
                    return e.parent.some(n => n.prop === t && n.value === i);
                }
                cloneBefore(e, t, i) {
                    this.already(e, t, i) ||
                        e.cloneBefore({ prop: t, value: i });
                }
                checkForWarning(e, t) {
                    if (t.prop !== 'transition-property') return;
                    let i = !1,
                        n = !1;
                    t.parent.each(s => {
                        if (
                            s.type !== 'decl' ||
                            s.prop.indexOf('transition-') !== 0
                        )
                            return;
                        let a = L2.comma(s.value);
                        if (s.prop === 'transition-property') {
                            a.forEach(o => {
                                let u = this.prefixes.add[o];
                                u &&
                                    u.prefixes &&
                                    u.prefixes.length > 0 &&
                                    (i = !0);
                            });
                            return;
                        }
                        return (n = n || a.length > 1), !1;
                    }),
                        i &&
                            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(a => {
                        let o = this.prefixes.remove[this.findProp(a)];
                        return !o || !o.remove;
                    });
                    let i = this.stringify(t);
                    if (e.value === i) return;
                    if (t.length === 0) {
                        e.remove();
                        return;
                    }
                    let n = e.parent.some(
                            a => a.prop === e.prop && a.value === i
                        ),
                        s = e.parent.some(
                            a =>
                                a !== e &&
                                a.prop === e.prop &&
                                a.value.length > i.length
                        );
                    if (n || s) {
                        e.remove();
                        return;
                    }
                    e.value = i;
                }
                parse(e) {
                    let t = Qh(e),
                        i = [],
                        n = [];
                    for (let s of t.nodes)
                        n.push(s),
                            s.type === 'div' &&
                                s.value === ',' &&
                                (i.push(n), (n = []));
                    return i.push(n), i.filter(s => s.length > 0);
                }
                stringify(e) {
                    if (e.length === 0) return '';
                    let t = [];
                    for (let i of e)
                        i[i.length - 1].type !== 'div' && i.push(this.div(e)),
                            (t = t.concat(i));
                    return (
                        t[0].type === 'div' && (t = t.slice(1)),
                        t[t.length - 1].type === 'div' &&
                            (t = t.slice(0, -2 + 1 || void 0)),
                        Qh.stringify({ nodes: t })
                    );
                }
                clone(e, t, i) {
                    let n = [],
                        s = !1;
                    for (let a of i)
                        !s && a.type === 'word' && a.value === e
                            ? (n.push({ type: 'word', value: t }), (s = !0))
                            : n.push(a);
                    return n;
                }
                div(e) {
                    for (let t of e)
                        for (let i of t)
                            if (i.type === 'div' && i.value === ',') return i;
                    return { type: 'div', value: ',', after: ' ' };
                }
                cleanOtherPrefixes(e, t) {
                    return e.filter(i => {
                        let n = Jh.prefix(this.findProp(i));
                        return n === '' || n === t;
                    });
                }
                cleanFromUnprefixed(e, t) {
                    let i = e
                            .map(s => this.findProp(s))
                            .filter(s => s.slice(0, t.length) === t)
                            .map(s => this.prefixes.unprefixed(s)),
                        n = [];
                    for (let s of e) {
                        let a = this.findProp(s),
                            o = Jh.prefix(a);
                        !i.includes(a) && (o === t || o === '') && n.push(s);
                    }
                    return n;
                }
                disabled(e, t) {
                    let i = [
                        'order',
                        'justify-content',
                        'align-self',
                        'align-content',
                    ];
                    if (e.includes('flex') || i.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 i = B2.prefixes().filter(n =>
                        t.selector.includes(':' + n)
                    );
                    return i.length > 0 ? i : !1;
                }
            };
        Kh.exports = Xh;
    });
    var $t = v(($3, tm) => {
        l();
        var $2 = ne(),
            em = class {
                constructor(e, t, i, n) {
                    (this.unprefixed = e),
                        (this.prefixed = t),
                        (this.string = i || t),
                        (this.regexp = n || $2.regexp(t));
                }
                check(e) {
                    return e.includes(this.string)
                        ? !!e.match(this.regexp)
                        : !1;
                }
            };
        tm.exports = em;
    });
    var ke = v((z3, im) => {
        l();
        var z2 = Bt(),
            j2 = $t(),
            V2 = ei(),
            U2 = ne(),
            rm = class extends z2 {
                static save(e, t) {
                    let i = t.prop,
                        n = [];
                    for (let s in t._autoprefixerValues) {
                        let a = t._autoprefixerValues[s];
                        if (a === t.value) continue;
                        let o,
                            u = V2.prefix(i);
                        if (u === '-pie-') continue;
                        if (u === s) {
                            (o = t.value = a), n.push(o);
                            continue;
                        }
                        let c = e.prefixed(i, s),
                            f = t.parent;
                        if (!f.every(y => y.prop !== c)) {
                            n.push(o);
                            continue;
                        }
                        let p = a.replace(/\s+/, ' ');
                        if (
                            f.some(
                                y =>
                                    y.prop === t.prop &&
                                    y.value.replace(/\s+/, ' ') === p
                            )
                        ) {
                            n.push(o);
                            continue;
                        }
                        let d = this.clone(t, { value: a });
                        (o = t.parent.insertBefore(t, d)), 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 = U2.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 i = e._autoprefixerValues[t] || this.value(e),
                        n;
                    do
                        if (((n = i), (i = this.replace(i, t)), i === !1))
                            return;
                    while (i !== n);
                    e._autoprefixerValues[t] = i;
                }
                old(e) {
                    return new j2(this.name, e + this.name);
                }
            };
        im.exports = rm;
    });
    var ot = v((j3, nm) => {
        l();
        nm.exports = {};
    });
    var To = v((V3, om) => {
        l();
        var sm = Kr(),
            W2 = ke(),
            G2 = ot().insertAreas,
            H2 = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i,
            Y2 = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i,
            Q2 = /(!\s*)?autoprefixer:\s*ignore\s+next/i,
            J2 = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i,
            X2 = [
                '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 Eo(r) {
            return r.parent.some(
                e =>
                    e.prop === 'grid-template' ||
                    e.prop === 'grid-template-areas'
            );
        }
        function K2(r) {
            let e = r.parent.some(i => i.prop === 'grid-template-rows'),
                t = r.parent.some(i => i.prop === 'grid-template-columns');
            return e && t;
        }
        var am = class {
            constructor(e) {
                this.prefixes = e;
            }
            add(e, t) {
                let i = this.prefixes.add['@resolution'],
                    n = this.prefixes.add['@keyframes'],
                    s = this.prefixes.add['@viewport'],
                    a = 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 s && s.process(f);
                    } else if (f.name === 'supports') {
                        if (
                            this.prefixes.options.supports !== !1 &&
                            !this.disabled(f, t)
                        )
                            return a.process(f);
                    } else if (
                        f.name === 'media' &&
                        f.params.includes('-resolution') &&
                        !this.disabled(f, t)
                    )
                        return i && i.process(f);
                }),
                    e.walkRules(f => {
                        if (!this.disabled(f, t))
                            return this.prefixes.add.selectors.map(p =>
                                p.process(f, t)
                            );
                    });
                function o(f) {
                    return f.parent.nodes.some(p => {
                        if (p.type !== 'decl') return !1;
                        let h =
                                p.prop === 'display' &&
                                /(inline-)?grid/.test(p.value),
                            d = p.prop.startsWith('grid-template'),
                            y = /^grid-([A-z]+-)?gap/.test(p.prop);
                        return h || d || y;
                    });
                }
                function u(f) {
                    return f.parent.some(
                        p =>
                            p.prop === 'display' &&
                            /(inline-)?flex/.test(p.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 p = f.parent,
                            h = f.prop,
                            d = f.value;
                        if (h === 'grid-row-span') {
                            t.warn(
                                'grid-row-span is not part of final Grid Layout. Use grid-row.',
                                { node: f }
                            );
                            return;
                        } else if (h === 'grid-column-span') {
                            t.warn(
                                'grid-column-span is not part of final Grid Layout. Use grid-column.',
                                { node: f }
                            );
                            return;
                        } else if (h === 'display' && d === 'box') {
                            t.warn(
                                'You should write display: flex by final spec instead of display: box',
                                { node: f }
                            );
                            return;
                        } else if (h === 'text-emphasis-position')
                            (d === 'under' || d === '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(h) &&
                            u(f)
                        )
                            (d === 'start' || d === 'end') &&
                                t.warn(
                                    `${d} value has mixed support, consider using flex-${d} instead`,
                                    { node: f }
                                );
                        else if (h === 'text-decoration-skip' && d === '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(h) &&
                                        o(f))
                                ) {
                                    let k = h.replace('-items', '-self');
                                    t.warn(
                                        `IE does not support ${h} on grid containers. Try using ${k} on child elements instead: ${f.parent.selector} > * { ${k}: ${f.value} }`,
                                        { node: f }
                                    );
                                } else if (
                                    /^(align|justify|place)-content$/.test(h) &&
                                    o(f)
                                )
                                    t.warn(
                                        `IE does not support ${f.prop} on grid containers`,
                                        { node: f }
                                    );
                                else if (
                                    h === '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 k = this.gridStatus(f, t);
                                    k === 'autoplace' && !K2(f) && !Eo(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 }
                                          )
                                        : (k === !0 || k === 'no-autoplace') &&
                                          !Eo(f) &&
                                          t.warn(
                                              'grid-gap only works if grid-template(-areas) is being used',
                                              { node: f }
                                          );
                                } else if (h === 'grid-auto-columns') {
                                    t.warn(
                                        'grid-auto-columns is not supported by IE',
                                        { node: f }
                                    );
                                    return;
                                } else if (h === 'grid-auto-rows') {
                                    t.warn(
                                        'grid-auto-rows is not supported by IE',
                                        { node: f }
                                    );
                                    return;
                                } else if (h === 'grid-auto-flow') {
                                    let k = p.some(
                                            b => b.prop === 'grid-template-rows'
                                        ),
                                        w = p.some(
                                            b =>
                                                b.prop ===
                                                'grid-template-columns'
                                        );
                                    Eo(f)
                                        ? t.warn(
                                              'grid-auto-flow is not supported by IE',
                                              { node: f }
                                          )
                                        : d.includes('dense')
                                        ? t.warn(
                                              'grid-auto-flow: dense is not supported by IE',
                                              { node: f }
                                          )
                                        : !k &&
                                          !w &&
                                          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 (d.includes('auto-fit')) {
                                    t.warn(
                                        'auto-fit value is not supported by IE',
                                        { node: f, word: 'auto-fit' }
                                    );
                                    return;
                                } else if (d.includes('auto-fill')) {
                                    t.warn(
                                        'auto-fill value is not supported by IE',
                                        { node: f, word: 'auto-fill' }
                                    );
                                    return;
                                } else
                                    h.startsWith('grid-template') &&
                                        d.includes('[') &&
                                        t.warn(
                                            'Autoprefixer currently does not support line names. Try using grid-template-areas instead.',
                                            { node: f, word: '[' }
                                        );
                            if (d.includes('radial-gradient'))
                                if (Y2.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 k = sm(d);
                                    for (let w of k.nodes)
                                        if (
                                            w.type === 'function' &&
                                            w.value === 'radial-gradient'
                                        )
                                            for (let b of w.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 }
                                                          ));
                                }
                            d.includes('linear-gradient') &&
                                H2.test(d) &&
                                t.warn(
                                    'Gradient has outdated direction syntax. New syntax is like `to left` instead of `right`.',
                                    { node: f }
                                );
                        }
                        X2.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') &&
                                      sm(d).nodes.some(
                                          w =>
                                              w.type === 'word' &&
                                              w.value === 'fill'
                                      ) &&
                                      t.warn(
                                          'Replace fill to stretch, because spec had been changed',
                                          { node: f }
                                      )));
                        let y;
                        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 &&
                                    ((y = this.prefixes.add['align-self']),
                                    y && y.prefixes && y.process(f)),
                                this.gridStatus(f, t) !== !1 &&
                                    ((y = this.prefixes.add['grid-row-align']),
                                    y && y.prefixes))
                            )
                                return y.process(f, t);
                        } else if (f.prop === 'justify-self') {
                            if (
                                this.gridStatus(f, t) !== !1 &&
                                ((y = this.prefixes.add['grid-column-align']),
                                y && y.prefixes)
                            )
                                return y.process(f, t);
                        } else if (f.prop === 'place-self') {
                            if (
                                ((y = this.prefixes.add['place-self']),
                                y && y.prefixes && this.gridStatus(f, t) !== !1)
                            )
                                return y.process(f, t);
                        } else if (
                            ((y = this.prefixes.add[f.prop]), y && y.prefixes)
                        )
                            return y.process(f, t);
                    }),
                    this.gridStatus(e, t) && G2(e, this.disabled),
                    e.walkDecls(f => {
                        if (this.disabledValue(f, t)) return;
                        let p = this.prefixes.unprefixed(f.prop),
                            h = this.prefixes.values('add', p);
                        if (Array.isArray(h))
                            for (let d of h) d.process && d.process(f, t);
                        W2.save(this.prefixes, f);
                    })
                );
            }
            remove(e, t) {
                let i = this.prefixes.remove['@resolution'];
                e.walkAtRules((n, s) => {
                    this.prefixes.remove[`@${n.name}`]
                        ? this.disabled(n, t) || n.parent.removeChild(s)
                        : n.name === 'media' &&
                          n.params.includes('-resolution') &&
                          i &&
                          i.clean(n);
                });
                for (let n of this.prefixes.remove.selectors)
                    e.walkRules((s, a) => {
                        n.check(s) &&
                            (this.disabled(s, t) || s.parent.removeChild(a));
                    });
                return e.walkDecls((n, s) => {
                    if (this.disabled(n, t)) return;
                    let a = 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),
                                a.removeChild(s);
                            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)))
                        ) {
                            a.removeChild(s);
                            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 i = [
                        'order',
                        'justify-content',
                        'align-items',
                        'align-content',
                    ];
                    if (e.prop.includes('flex') || i.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' && Q2.test(n.text))
                        return (
                            (e._autoprefixerDisabled = !0),
                            (e._autoprefixerSelfDisabled = !0),
                            !0
                        );
                }
                let i = null;
                if (e.nodes) {
                    let n;
                    e.each(s => {
                        s.type === 'comment' &&
                            /(!\s*)?autoprefixer:\s*(off|on)/i.test(s.text) &&
                            (typeof n != 'undefined'
                                ? t.warn(
                                      'Second Autoprefixer control comment was ignored. Autoprefixer applies control comment to whole block, not to next rules.',
                                      { node: s }
                                  )
                                : (n = /on/i.test(s.text)));
                    }),
                        n !== void 0 && (i = !n);
                }
                if (!e.nodes || i === null)
                    if (e.parent) {
                        let n = this.disabled(e.parent, t);
                        e.parent._autoprefixerSelfDisabled === !0
                            ? (i = !1)
                            : (i = n);
                    } else i = !1;
                return (e._autoprefixerDisabled = i), i;
            }
            reduceSpaces(e) {
                let t = !1;
                if ((this.prefixes.group(e).up(() => ((t = !0), !0)), t))
                    return;
                let i = e.raw('before').split(`
`),
                    n = i[i.length - 1].length,
                    s = !1;
                this.prefixes.group(e).down(a => {
                    i = a.raw('before').split(`
`);
                    let o = i.length - 1;
                    i[o].length > n &&
                        (s === !1 && (s = i[o].length - n),
                        (i[o] = i[o].slice(0, -s)),
                        (a.raws.before = i.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 i = null;
                if (e.nodes) {
                    let n;
                    e.each(s => {
                        if (s.type === 'comment' && J2.test(s.text)) {
                            let a = /:\s*autoplace/i.test(s.text),
                                o = /no-autoplace/i.test(s.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: s }
                                  )
                                : a
                                ? (n = 'autoplace')
                                : o
                                ? (n = !0)
                                : (n = /on/i.test(s.text));
                        }
                    }),
                        n !== void 0 && (i = n);
                }
                if (e.type === 'atrule' && e.name === 'supports') {
                    let n = e.params;
                    n.includes('grid') && n.includes('auto') && (i = !1);
                }
                if (!e.nodes || i === null)
                    if (e.parent) {
                        let n = this.gridStatus(e.parent, t);
                        e.parent._autoprefixerSelfDisabled === !0
                            ? (i = !1)
                            : (i = n);
                    } else
                        typeof this.prefixes.options.grid != 'undefined'
                            ? (i = this.prefixes.options.grid)
                            : typeof m.env.AUTOPREFIXER_GRID != 'undefined'
                            ? m.env.AUTOPREFIXER_GRID === 'autoplace'
                                ? (i = 'autoplace')
                                : (i = !0)
                            : (i = !1);
                return (e._autoprefixerGridStatus = i), i;
            }
        };
        om.exports = am;
    });
    var um = v((U3, lm) => {
        l();
        lm.exports = {
            A: {
                A: { 2: 'J D E F A B iB' },
                B: { 1: 'C K L G M N O R S T U V W X Y Z a P b H' },
                C: {
                    1: '0 1 2 3 4 5 6 7 8 9 g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB bB HB cB IB JB Q KB LB MB NB OB PB QB RB SB TB UB VB WB XB R S T kB U V W X Y Z a P b H dB',
                    2: 'jB aB I c J D E F A B C K L G M N O d e f lB mB',
                },
                D: {
                    1: '0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB bB HB cB IB JB Q KB LB MB NB OB PB QB RB SB TB UB VB WB XB R S T U V W X Y Z a P b H dB nB oB',
                    2: 'I c J D E F A B C K L G M N O d e f g h i j k l',
                },
                E: {
                    1: 'F A B C K L G tB fB YB ZB uB vB wB',
                    2: 'I c J D E pB eB qB rB sB',
                },
                F: {
                    1: '0 1 2 3 4 5 6 7 8 9 G M N O d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB Q KB LB MB NB OB PB QB RB SB TB UB VB WB XB ZB',
                    2: 'F B C xB yB zB 0B YB gB 1B',
                },
                G: {
                    1: '7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC',
                    2: 'E eB 2B hB 3B 4B 5B 6B',
                },
                H: { 1: 'LC' },
                I: { 1: 'H QC RC', 2: 'aB I MC NC OC PC hB' },
                J: { 2: 'D A' },
                K: { 1: 'Q', 2: 'A B C YB gB ZB' },
                L: { 1: 'H' },
                M: { 1: 'P' },
                N: { 2: 'A B' },
                O: { 1: 'SC' },
                P: { 1: 'I TC UC VC WC XC fB YC ZC aC bC' },
                Q: { 1: 'cC' },
                R: { 1: 'dC' },
                S: { 1: 'eC' },
            },
            B: 4,
            C: 'CSS Feature Queries',
        };
    });
    var dm = v((W3, pm) => {
        l();
        function fm(r) {
            return r[r.length - 1];
        }
        var cm = {
            parse(r) {
                let e = [''],
                    t = [e];
                for (let i of r) {
                    if (i === '(') {
                        (e = ['']), fm(t).push(e), t.push(e);
                        continue;
                    }
                    if (i === ')') {
                        t.pop(), (e = fm(t)), e.push('');
                        continue;
                    }
                    e[e.length - 1] += i;
                }
                return t[0];
            },
            stringify(r) {
                let e = '';
                for (let t of r) {
                    if (typeof t == 'object') {
                        e += `(${cm.stringify(t)})`;
                        continue;
                    }
                    e += t;
                }
                return e;
            },
        };
        pm.exports = cm;
    });
    var wm = v((G3, ym) => {
        l();
        var Z2 = um(),
            { feature: eC } = (In(), qn),
            { parse: tC } = me(),
            rC = at(),
            Po = dm(),
            iC = ke(),
            nC = ne(),
            hm = eC(Z2),
            mm = [];
        for (let r in hm.stats) {
            let e = hm.stats[r];
            for (let t in e) {
                let i = e[t];
                /y/.test(i) && mm.push(r + ' ' + t);
            }
        }
        var gm = class {
            constructor(e, t) {
                (this.Prefixes = e), (this.all = t);
            }
            prefixer() {
                if (this.prefixerCache) return this.prefixerCache;
                let e = this.all.browsers.selected.filter(i => mm.includes(i)),
                    t = new rC(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(':'),
                    i = t[0],
                    n = t[1];
                return n || (n = ''), [i.trim(), n.trim()];
            }
            virtual(e) {
                let [t, i] = this.parse(e),
                    n = tC('a{}').first;
                return n.append({ prop: t, value: i, raws: { before: '' } }), n;
            }
            prefixed(e) {
                let t = this.virtual(e);
                if (this.disabled(t.first)) return t.nodes;
                let i = { warn: () => null },
                    n = this.prefixer().add[t.first.prop];
                n && n.process && n.process(t.first, i);
                for (let s of t.nodes) {
                    for (let a of this.prefixer().values('add', t.first.prop))
                        a.process(s);
                    iC.save(this.all, s);
                }
                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)${nC.escapeRegexp(t)}:`).test(e);
            }
            toRemove(e, t) {
                let [i, n] = this.parse(e),
                    s = this.all.unprefixed(i),
                    a = this.all.cleaner();
                if (a.remove[i] && a.remove[i].remove && !this.isHack(t, s))
                    return !0;
                for (let o of a.values('remove', s)) if (o.check(n)) return !0;
                return !1;
            }
            remove(e, t) {
                let i = 0;
                for (; i < e.length; ) {
                    if (
                        !this.isNot(e[i - 1]) &&
                        this.isProp(e[i]) &&
                        this.isOr(e[i + 1])
                    ) {
                        if (this.toRemove(e[i][0], t)) {
                            e.splice(i, 2);
                            continue;
                        }
                        i += 2;
                        continue;
                    }
                    typeof e[i] == 'object' && (e[i] = this.remove(e[i], t)),
                        (i += 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 i of e)
                    t.push([`${i.prop}: ${i.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 [Po.stringify(e)];
                }
                return e.map(t => this.normalize(t));
            }
            add(e, t) {
                return e.map(i => {
                    if (this.isProp(i)) {
                        let n = this.prefixed(i[0]);
                        return n.length > 1 ? this.convert(n) : i;
                    }
                    return typeof i == 'object' ? this.add(i, t) : i;
                });
            }
            process(e) {
                let t = Po.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 = Po.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;
            }
        };
        ym.exports = gm;
    });
    var xm = v((H3, vm) => {
        l();
        var bm = class {
            constructor(e, t) {
                (this.prefix = t),
                    (this.prefixed = e.prefixed(this.prefix)),
                    (this.regexp = e.regexp(this.prefix)),
                    (this.prefixeds = e
                        .possible()
                        .map(i => [e.prefixed(i), e.regexp(i)])),
                    (this.unprefixed = e.name),
                    (this.nameRegexp = e.regexp());
            }
            isHack(e) {
                let t = e.parent.index(e) + 1,
                    i = e.parent.nodes;
                for (; t < i.length; ) {
                    let n = i[t].selector;
                    if (!n) return !0;
                    if (n.includes(this.unprefixed) && n.match(this.nameRegexp))
                        return !1;
                    let s = !1;
                    for (let [a, o] of this.prefixeds)
                        if (n.includes(a) && n.match(o)) {
                            s = !0;
                            break;
                        }
                    if (!s) return !0;
                    t += 1;
                }
                return !0;
            }
            check(e) {
                return !(
                    !e.selector.includes(this.prefixed) ||
                    !e.selector.match(this.regexp) ||
                    this.isHack(e)
                );
            }
        };
        vm.exports = bm;
    });
    var zt = v((Y3, Sm) => {
        l();
        var { list: sC } = me(),
            aC = xm(),
            oC = Bt(),
            lC = at(),
            uC = ne(),
            km = class extends oC {
                constructor(e, t, i) {
                    super(e, t, i);
                    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(`(^|[^:"'=])${uC.escapeRegexp(t)}`, 'gi')
                        );
                    }
                    return this.regexpCache.get(e);
                }
                possible() {
                    return lC.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 = sC
                            .comma(e.selector)
                            .filter(s => s.includes(this.name));
                        for (let s of this.possible())
                            t[s] = n.map(a => this.replace(a, s)).join(', ');
                    } else
                        for (let i of this.possible())
                            t[i] = this.replace(e.selector, i);
                    return (
                        (e._autoprefixerPrefixeds[this.name] = t),
                        e._autoprefixerPrefixeds
                    );
                }
                already(e, t, i) {
                    let n = e.parent.index(e) - 1;
                    for (; n >= 0; ) {
                        let s = e.parent.nodes[n];
                        if (s.type !== 'rule') return !1;
                        let a = !1;
                        for (let o in t[this.name]) {
                            let u = t[this.name][o];
                            if (s.selector === u) {
                                if (i === o) return !0;
                                a = !0;
                                break;
                            }
                        }
                        if (!a) return !1;
                        n -= 1;
                    }
                    return !1;
                }
                replace(e, t) {
                    return e.replace(this.regexp(), `$1${this.prefixed(t)}`);
                }
                add(e, t) {
                    let i = this.prefixeds(e);
                    if (this.already(e, i, t)) return;
                    let n = this.clone(e, { selector: i[this.name][t] });
                    e.parent.insertBefore(e, n);
                }
                old(e) {
                    return new aC(this, e);
                }
            };
        Sm.exports = km;
    });
    var Am = v((Q3, _m) => {
        l();
        var fC = Bt(),
            Cm = class extends fC {
                add(e, t) {
                    let i = t + e.name;
                    if (
                        e.parent.some(
                            a => a.name === i && a.params === e.params
                        )
                    )
                        return;
                    let s = this.clone(e, { name: i });
                    return e.parent.insertBefore(e, s);
                }
                process(e) {
                    let t = this.parentPrefix(e);
                    for (let i of this.prefixes)
                        (!t || t === i) && this.add(e, i);
                }
            };
        _m.exports = Cm;
    });
    var Em = v((J3, Om) => {
        l();
        var cC = zt(),
            Do = class extends cC {
                prefixed(e) {
                    return e === '-webkit-'
                        ? ':-webkit-full-screen'
                        : e === '-moz-'
                        ? ':-moz-full-screen'
                        : `:${e}fullscreen`;
                }
            };
        Do.names = [':fullscreen'];
        Om.exports = Do;
    });
    var Pm = v((X3, Tm) => {
        l();
        var pC = zt(),
            qo = class extends pC {
                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`;
                }
            };
        qo.names = ['::placeholder'];
        Tm.exports = qo;
    });
    var qm = v((K3, Dm) => {
        l();
        var dC = zt(),
            Io = class extends dC {
                prefixed(e) {
                    return e === '-ms-'
                        ? ':-ms-input-placeholder'
                        : `:${e}placeholder-shown`;
                }
            };
        Io.names = [':placeholder-shown'];
        Dm.exports = Io;
    });
    var Rm = v((Z3, Im) => {
        l();
        var hC = zt(),
            mC = ne(),
            Ro = class extends hC {
                constructor(e, t, i) {
                    super(e, t, i);
                    this.prefixes &&
                        (this.prefixes = mC.uniq(
                            this.prefixes.map(n => '-webkit-')
                        ));
                }
                prefixed(e) {
                    return e === '-webkit-'
                        ? '::-webkit-file-upload-button'
                        : `::${e}file-selector-button`;
                }
            };
        Ro.names = ['::file-selector-button'];
        Im.exports = Ro;
    });
    var fe = v((eD, Mm) => {
        l();
        Mm.exports = function (r) {
            let e;
            return (
                r === '-webkit- 2009' || r === '-moz-'
                    ? (e = 2009)
                    : r === '-ms-'
                    ? (e = 2012)
                    : r === '-webkit-' && (e = 'final'),
                r === '-webkit- 2009' && (r = '-webkit-'),
                [e, r]
            );
        };
    });
    var Bm = v((tD, Lm) => {
        l();
        var Fm = me().list,
            Nm = fe(),
            gC = I(),
            jt = class extends gC {
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = Nm(t)),
                        i === 2009 ? t + 'box-flex' : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'flex';
                }
                set(e, t) {
                    let i = Nm(t)[0];
                    if (i === 2009)
                        return (
                            (e.value = Fm.space(e.value)[0]),
                            (e.value = jt.oldValues[e.value] || e.value),
                            super.set(e, t)
                        );
                    if (i === 2012) {
                        let n = Fm.space(e.value);
                        n.length === 3 &&
                            n[2] === '0' &&
                            (e.value = n.slice(0, 2).concat('0px').join(' '));
                    }
                    return super.set(e, t);
                }
            };
        jt.names = ['flex', 'box-flex'];
        jt.oldValues = { auto: '1', none: '0' };
        Lm.exports = jt;
    });
    var jm = v((rD, zm) => {
        l();
        var $m = fe(),
            yC = I(),
            Mo = class extends yC {
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = $m(t)),
                        i === 2009
                            ? t + 'box-ordinal-group'
                            : i === 2012
                            ? t + 'flex-order'
                            : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'order';
                }
                set(e, t) {
                    return $m(t)[0] === 2009 && /\d/.test(e.value)
                        ? ((e.value = (parseInt(e.value) + 1).toString()),
                          super.set(e, t))
                        : super.set(e, t);
                }
            };
        Mo.names = ['order', 'flex-order', 'box-ordinal-group'];
        zm.exports = Mo;
    });
    var Um = v((iD, Vm) => {
        l();
        var wC = I(),
            Fo = class extends wC {
                check(e) {
                    let t = e.value;
                    return (
                        !t.toLowerCase().includes('alpha(') &&
                        !t.includes('DXImageTransform.Microsoft') &&
                        !t.includes('data:image/svg+xml')
                    );
                }
            };
        Fo.names = ['filter'];
        Vm.exports = Fo;
    });
    var Gm = v((nD, Wm) => {
        l();
        var bC = I(),
            No = class extends bC {
                insert(e, t, i, n) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    let s = this.clone(e),
                        a = e.prop.replace(/end$/, 'start'),
                        o = t + e.prop.replace(/end$/, 'span');
                    if (!e.parent.some(u => u.prop === o)) {
                        if (((s.prop = o), e.value.includes('span')))
                            s.value = e.value.replace(/span\s/i, '');
                        else {
                            let u;
                            if (
                                (e.parent.walkDecls(a, c => {
                                    u = c;
                                }),
                                u)
                            ) {
                                let c = Number(e.value) - Number(u.value) + '';
                                s.value = c;
                            } else
                                e.warn(
                                    n,
                                    `Can not prefix ${e.prop} (${a} is not found)`
                                );
                        }
                        e.cloneBefore(s);
                    }
                }
            };
        No.names = ['grid-row-end', 'grid-column-end'];
        Wm.exports = No;
    });
    var Ym = v((sD, Hm) => {
        l();
        var vC = I(),
            Lo = class extends vC {
                check(e) {
                    return !e.value.split(/\s+/).some(t => {
                        let i = t.toLowerCase();
                        return i === 'reverse' || i === 'alternate-reverse';
                    });
                }
            };
        Lo.names = ['animation', 'animation-direction'];
        Hm.exports = Lo;
    });
    var Jm = v((aD, Qm) => {
        l();
        var xC = fe(),
            kC = I(),
            Bo = class extends kC {
                insert(e, t, i) {
                    let n;
                    if ((([n, t] = xC(t)), n !== 2009))
                        return super.insert(e, t, i);
                    let s = e.value
                        .split(/\s+/)
                        .filter(
                            p =>
                                p !== 'wrap' && p !== 'nowrap' && 'wrap-reverse'
                        );
                    if (
                        s.length === 0 ||
                        e.parent.some(
                            p =>
                                p.prop === t + 'box-orient' ||
                                p.prop === t + 'box-direction'
                        )
                    )
                        return;
                    let o = s[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(i, 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(i, e, t)),
                        e.parent.insertBefore(e, f)
                    );
                }
            };
        Bo.names = ['flex-flow', 'box-direction', 'box-orient'];
        Qm.exports = Bo;
    });
    var Km = v((oD, Xm) => {
        l();
        var SC = fe(),
            CC = I(),
            $o = class extends CC {
                normalize() {
                    return 'flex';
                }
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = SC(t)),
                        i === 2009
                            ? t + 'box-flex'
                            : i === 2012
                            ? t + 'flex-positive'
                            : super.prefixed(e, t)
                    );
                }
            };
        $o.names = ['flex-grow', 'flex-positive'];
        Xm.exports = $o;
    });
    var eg = v((lD, Zm) => {
        l();
        var _C = fe(),
            AC = I(),
            zo = class extends AC {
                set(e, t) {
                    if (_C(t)[0] !== 2009) return super.set(e, t);
                }
            };
        zo.names = ['flex-wrap'];
        Zm.exports = zo;
    });
    var rg = v((uD, tg) => {
        l();
        var OC = I(),
            Vt = ot(),
            jo = class extends OC {
                insert(e, t, i, n) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    let s = Vt.parse(e),
                        [a, o] = Vt.translate(s, 0, 2),
                        [u, c] = Vt.translate(s, 1, 3);
                    [
                        ['grid-row', a],
                        ['grid-row-span', o],
                        ['grid-column', u],
                        ['grid-column-span', c],
                    ].forEach(([f, p]) => {
                        Vt.insertDecl(e, f, p);
                    }),
                        Vt.warnTemplateSelectorNotFound(e, n),
                        Vt.warnIfGridRowColumnExists(e, n);
                }
            };
        jo.names = ['grid-area'];
        tg.exports = jo;
    });
    var ng = v((fD, ig) => {
        l();
        var EC = I(),
            ti = ot(),
            Vo = class extends EC {
                insert(e, t, i) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    if (e.parent.some(a => a.prop === '-ms-grid-row-align'))
                        return;
                    let [[n, s]] = ti.parse(e);
                    s
                        ? (ti.insertDecl(e, 'grid-row-align', n),
                          ti.insertDecl(e, 'grid-column-align', s))
                        : (ti.insertDecl(e, 'grid-row-align', n),
                          ti.insertDecl(e, 'grid-column-align', n));
                }
            };
        Vo.names = ['place-self'];
        ig.exports = Vo;
    });
    var ag = v((cD, sg) => {
        l();
        var TC = I(),
            Uo = class extends TC {
                check(e) {
                    let t = e.value;
                    return !t.includes('/') || t.includes('span');
                }
                normalize(e) {
                    return e.replace('-start', '');
                }
                prefixed(e, t) {
                    let i = super.prefixed(e, t);
                    return t === '-ms-' && (i = i.replace('-start', '')), i;
                }
            };
        Uo.names = ['grid-row-start', 'grid-column-start'];
        sg.exports = Uo;
    });
    var ug = v((pD, lg) => {
        l();
        var og = fe(),
            PC = I(),
            Ut = class extends PC {
                check(e) {
                    return (
                        e.parent &&
                        !e.parent.some(
                            t => t.prop && t.prop.startsWith('grid-')
                        )
                    );
                }
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = og(t)),
                        i === 2012
                            ? t + 'flex-item-align'
                            : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'align-self';
                }
                set(e, t) {
                    let i = og(t)[0];
                    if (i === 2012)
                        return (
                            (e.value = Ut.oldValues[e.value] || e.value),
                            super.set(e, t)
                        );
                    if (i === 'final') return super.set(e, t);
                }
            };
        Ut.names = ['align-self', 'flex-item-align'];
        Ut.oldValues = { 'flex-end': 'end', 'flex-start': 'start' };
        lg.exports = Ut;
    });
    var cg = v((dD, fg) => {
        l();
        var DC = I(),
            qC = ne(),
            Wo = class extends DC {
                constructor(e, t, i) {
                    super(e, t, i);
                    this.prefixes &&
                        (this.prefixes = qC.uniq(
                            this.prefixes.map(n =>
                                n === '-ms-' ? '-webkit-' : n
                            )
                        ));
                }
            };
        Wo.names = ['appearance'];
        fg.exports = Wo;
    });
    var hg = v((hD, dg) => {
        l();
        var pg = fe(),
            IC = I(),
            Go = class extends IC {
                normalize() {
                    return 'flex-basis';
                }
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = pg(t)),
                        i === 2012
                            ? t + 'flex-preferred-size'
                            : super.prefixed(e, t)
                    );
                }
                set(e, t) {
                    let i;
                    if ((([i, t] = pg(t)), i === 2012 || i === 'final'))
                        return super.set(e, t);
                }
            };
        Go.names = ['flex-basis', 'flex-preferred-size'];
        dg.exports = Go;
    });
    var gg = v((mD, mg) => {
        l();
        var RC = I(),
            Ho = class extends RC {
                normalize() {
                    return this.name.replace('box-image', 'border');
                }
                prefixed(e, t) {
                    let i = super.prefixed(e, t);
                    return (
                        t === '-webkit-' &&
                            (i = i.replace('border', 'box-image')),
                        i
                    );
                }
            };
        Ho.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',
        ];
        mg.exports = Ho;
    });
    var wg = v((gD, yg) => {
        l();
        var MC = I(),
            Fe = class extends MC {
                insert(e, t, i) {
                    let n = e.prop === 'mask-composite',
                        s;
                    n
                        ? (s = e.value.split(','))
                        : (s = e.value.match(Fe.regexp) || []),
                        (s = s.map(c => c.trim()).filter(c => c));
                    let a = s.length,
                        o;
                    if (
                        (a &&
                            ((o = this.clone(e)),
                            (o.value = s
                                .map(c => Fe.oldValues[c] || c)
                                .join(', ')),
                            s.includes('intersect') && (o.value += ', xor'),
                            (o.prop = t + 'mask-composite')),
                        n)
                    )
                        return a
                            ? (this.needCascade(e) &&
                                  (o.raws.before = this.calcBefore(i, e, t)),
                              e.parent.insertBefore(e, o))
                            : void 0;
                    let u = this.clone(e);
                    return (
                        (u.prop = t + u.prop),
                        a && (u.value = u.value.replace(Fe.regexp, '')),
                        this.needCascade(e) &&
                            (u.raws.before = this.calcBefore(i, e, t)),
                        e.parent.insertBefore(e, u),
                        a
                            ? (this.needCascade(e) &&
                                  (o.raws.before = this.calcBefore(i, e, t)),
                              e.parent.insertBefore(e, o))
                            : e
                    );
                }
            };
        Fe.names = ['mask', 'mask-composite'];
        Fe.oldValues = {
            add: 'source-over',
            subtract: 'source-out',
            intersect: 'source-in',
            exclude: 'xor',
        };
        Fe.regexp = new RegExp(
            `\\s+(${Object.keys(Fe.oldValues).join('|')})\\b(?!\\))\\s*(?=[,])`,
            'ig'
        );
        yg.exports = Fe;
    });
    var xg = v((yD, vg) => {
        l();
        var bg = fe(),
            FC = I(),
            Wt = class extends FC {
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = bg(t)),
                        i === 2009
                            ? t + 'box-align'
                            : i === 2012
                            ? t + 'flex-align'
                            : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'align-items';
                }
                set(e, t) {
                    let i = bg(t)[0];
                    return (
                        (i === 2009 || i === 2012) &&
                            (e.value = Wt.oldValues[e.value] || e.value),
                        super.set(e, t)
                    );
                }
            };
        Wt.names = ['align-items', 'flex-align', 'box-align'];
        Wt.oldValues = { 'flex-end': 'end', 'flex-start': 'start' };
        vg.exports = Wt;
    });
    var Sg = v((wD, kg) => {
        l();
        var NC = I(),
            Yo = class extends NC {
                set(e, t) {
                    return (
                        t === '-ms-' &&
                            e.value === 'contain' &&
                            (e.value = 'element'),
                        super.set(e, t)
                    );
                }
                insert(e, t, i) {
                    if (!(e.value === 'all' && t === '-ms-'))
                        return super.insert(e, t, i);
                }
            };
        Yo.names = ['user-select'];
        kg.exports = Yo;
    });
    var Ag = v((bD, _g) => {
        l();
        var Cg = fe(),
            LC = I(),
            Qo = class extends LC {
                normalize() {
                    return 'flex-shrink';
                }
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = Cg(t)),
                        i === 2012 ? t + 'flex-negative' : super.prefixed(e, t)
                    );
                }
                set(e, t) {
                    let i;
                    if ((([i, t] = Cg(t)), i === 2012 || i === 'final'))
                        return super.set(e, t);
                }
            };
        Qo.names = ['flex-shrink', 'flex-negative'];
        _g.exports = Qo;
    });
    var Eg = v((vD, Og) => {
        l();
        var BC = I(),
            Jo = class extends BC {
                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, i) {
                    if (e.prop !== 'break-inside') return super.insert(e, t, i);
                    if (!(/region/i.test(e.value) || /page/i.test(e.value)))
                        return super.insert(e, t, i);
                }
            };
        Jo.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',
        ];
        Og.exports = Jo;
    });
    var Pg = v((xD, Tg) => {
        l();
        var $C = I(),
            Xo = class extends $C {
                prefixed(e, t) {
                    return t + 'print-color-adjust';
                }
                normalize() {
                    return 'color-adjust';
                }
            };
        Xo.names = ['color-adjust', 'print-color-adjust'];
        Tg.exports = Xo;
    });
    var qg = v((kD, Dg) => {
        l();
        var zC = I(),
            Gt = class extends zC {
                insert(e, t, i) {
                    if (t === '-ms-') {
                        let n = this.set(this.clone(e), t);
                        this.needCascade(e) &&
                            (n.raws.before = this.calcBefore(i, e, t));
                        let s = 'ltr';
                        return (
                            e.parent.nodes.forEach(a => {
                                a.prop === 'direction' &&
                                    (a.value === 'rtl' || a.value === 'ltr') &&
                                    (s = a.value);
                            }),
                            (n.value = Gt.msValues[s][e.value] || e.value),
                            e.parent.insertBefore(e, n)
                        );
                    }
                    return super.insert(e, t, i);
                }
            };
        Gt.names = ['writing-mode'];
        Gt.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',
            },
        };
        Dg.exports = Gt;
    });
    var Rg = v((SD, Ig) => {
        l();
        var jC = I(),
            Ko = class extends jC {
                set(e, t) {
                    return (
                        (e.value = e.value.replace(/\s+fill(\s)/, '$1')),
                        super.set(e, t)
                    );
                }
            };
        Ko.names = ['border-image'];
        Ig.exports = Ko;
    });
    var Ng = v((CD, Fg) => {
        l();
        var Mg = fe(),
            VC = I(),
            Ht = class extends VC {
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = Mg(t)),
                        i === 2012 ? t + 'flex-line-pack' : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'align-content';
                }
                set(e, t) {
                    let i = Mg(t)[0];
                    if (i === 2012)
                        return (
                            (e.value = Ht.oldValues[e.value] || e.value),
                            super.set(e, t)
                        );
                    if (i === 'final') return super.set(e, t);
                }
            };
        Ht.names = ['align-content', 'flex-line-pack'];
        Ht.oldValues = {
            'flex-end': 'end',
            'flex-start': 'start',
            'space-between': 'justify',
            'space-around': 'distribute',
        };
        Fg.exports = Ht;
    });
    var Bg = v((_D, Lg) => {
        l();
        var UC = I(),
            Se = class extends UC {
                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 r of ['top', 'bottom'])
            for (let e of ['left', 'right']) {
                let t = `border-${r}-${e}-radius`,
                    i = `border-radius-${r}${e}`;
                Se.names.push(t),
                    Se.names.push(i),
                    (Se.toMozilla[t] = i),
                    (Se.toNormal[i] = t);
            }
        Lg.exports = Se;
    });
    var zg = v((AD, $g) => {
        l();
        var WC = I(),
            Zo = class extends WC {
                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');
                }
            };
        Zo.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',
        ];
        $g.exports = Zo;
    });
    var Vg = v((OD, jg) => {
        l();
        var GC = I(),
            {
                parseTemplate: HC,
                warnMissedAreas: YC,
                getGridGap: QC,
                warnGridGap: JC,
                inheritGridGap: XC,
            } = ot(),
            el = class extends GC {
                insert(e, t, i, n) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    if (e.parent.some(d => d.prop === '-ms-grid-rows')) return;
                    let s = QC(e),
                        a = XC(e, s),
                        {
                            rows: o,
                            columns: u,
                            areas: c,
                        } = HC({ decl: e, gap: a || s }),
                        f = Object.keys(c).length > 0,
                        p = Boolean(o),
                        h = Boolean(u);
                    return (
                        JC({ gap: s, hasColumns: h, decl: e, result: n }),
                        YC(c, e, n),
                        ((p && h) || f) &&
                            e.cloneBefore({
                                prop: '-ms-grid-rows',
                                value: o,
                                raws: {},
                            }),
                        h &&
                            e.cloneBefore({
                                prop: '-ms-grid-columns',
                                value: u,
                                raws: {},
                            }),
                        e
                    );
                }
            };
        el.names = ['grid-template'];
        jg.exports = el;
    });
    var Wg = v((ED, Ug) => {
        l();
        var KC = I(),
            tl = class extends KC {
                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',
        ];
        Ug.exports = tl;
    });
    var Hg = v((TD, Gg) => {
        l();
        var ZC = I(),
            rl = class extends ZC {
                check(e) {
                    return !e.value.includes('flex-') && e.value !== 'baseline';
                }
                prefixed(e, t) {
                    return t + 'grid-row-align';
                }
                normalize() {
                    return 'align-self';
                }
            };
        rl.names = ['grid-row-align'];
        Gg.exports = rl;
    });
    var Qg = v((PD, Yg) => {
        l();
        var e_ = I(),
            Yt = class extends e_ {
                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 Yt.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, i) {
                    if (t === '-ms-') {
                        if (!this.contain3d(e) && !this.keyframeParents(e))
                            return super.insert(e, t, i);
                    } else if (t === '-o-') {
                        if (!this.contain3d(e)) return super.insert(e, t, i);
                    } else return super.insert(e, t, i);
                }
            };
        Yt.names = ['transform', 'transform-origin'];
        Yt.functions3d = [
            'matrix3d',
            'translate3d',
            'translateZ',
            'scale3d',
            'scaleZ',
            'rotate3d',
            'rotateX',
            'rotateY',
            'perspective',
        ];
        Yg.exports = Yt;
    });
    var Kg = v((DD, Xg) => {
        l();
        var Jg = fe(),
            t_ = I(),
            il = class extends t_ {
                normalize() {
                    return 'flex-direction';
                }
                insert(e, t, i) {
                    let n;
                    if ((([n, t] = Jg(t)), n !== 2009))
                        return super.insert(e, t, i);
                    if (
                        e.parent.some(
                            f =>
                                f.prop === t + 'box-orient' ||
                                f.prop === t + 'box-direction'
                        )
                    )
                        return;
                    let a = e.value,
                        o,
                        u;
                    a === 'inherit' || a === 'initial' || a === 'unset'
                        ? ((o = a), (u = a))
                        : ((o = a.includes('row') ? 'horizontal' : 'vertical'),
                          (u = a.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(i, 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(i, e, t)),
                        e.parent.insertBefore(e, c)
                    );
                }
                old(e, t) {
                    let i;
                    return (
                        ([i, t] = Jg(t)),
                        i === 2009
                            ? [t + 'box-orient', t + 'box-direction']
                            : super.old(e, t)
                    );
                }
            };
        il.names = ['flex-direction', 'box-direction', 'box-orient'];
        Xg.exports = il;
    });
    var ey = v((qD, Zg) => {
        l();
        var r_ = I(),
            nl = class extends r_ {
                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);
                }
            };
        nl.names = ['image-rendering', 'interpolation-mode'];
        Zg.exports = nl;
    });
    var ry = v((ID, ty) => {
        l();
        var i_ = I(),
            n_ = ne(),
            sl = class extends i_ {
                constructor(e, t, i) {
                    super(e, t, i);
                    this.prefixes &&
                        (this.prefixes = n_.uniq(
                            this.prefixes.map(n =>
                                n === '-ms-' ? '-webkit-' : n
                            )
                        ));
                }
            };
        sl.names = ['backdrop-filter'];
        ty.exports = sl;
    });
    var ny = v((RD, iy) => {
        l();
        var s_ = I(),
            a_ = ne(),
            al = class extends s_ {
                constructor(e, t, i) {
                    super(e, t, i);
                    this.prefixes &&
                        (this.prefixes = a_.uniq(
                            this.prefixes.map(n =>
                                n === '-ms-' ? '-webkit-' : n
                            )
                        ));
                }
                check(e) {
                    return e.value.toLowerCase() === 'text';
                }
            };
        al.names = ['background-clip'];
        iy.exports = al;
    });
    var ay = v((MD, sy) => {
        l();
        var o_ = I(),
            l_ = [
                'none',
                'underline',
                'overline',
                'line-through',
                'blink',
                'inherit',
                'initial',
                'unset',
            ],
            ol = class extends o_ {
                check(e) {
                    return e.value.split(/\s+/).some(t => !l_.includes(t));
                }
            };
        ol.names = ['text-decoration'];
        sy.exports = ol;
    });
    var uy = v((FD, ly) => {
        l();
        var oy = fe(),
            u_ = I(),
            Qt = class extends u_ {
                prefixed(e, t) {
                    let i;
                    return (
                        ([i, t] = oy(t)),
                        i === 2009
                            ? t + 'box-pack'
                            : i === 2012
                            ? t + 'flex-pack'
                            : super.prefixed(e, t)
                    );
                }
                normalize() {
                    return 'justify-content';
                }
                set(e, t) {
                    let i = oy(t)[0];
                    if (i === 2009 || i === 2012) {
                        let n = Qt.oldValues[e.value] || e.value;
                        if (((e.value = n), i !== 2009 || n !== 'distribute'))
                            return super.set(e, t);
                    } else if (i === 'final') return super.set(e, t);
                }
            };
        Qt.names = ['justify-content', 'flex-pack', 'box-pack'];
        Qt.oldValues = {
            'flex-end': 'end',
            'flex-start': 'start',
            'space-between': 'justify',
            'space-around': 'distribute',
        };
        ly.exports = Qt;
    });
    var cy = v((ND, fy) => {
        l();
        var f_ = I(),
            ll = class extends f_ {
                set(e, t) {
                    let i = e.value.toLowerCase();
                    return (
                        t === '-webkit-' &&
                            !i.includes(' ') &&
                            i !== 'contain' &&
                            i !== 'cover' &&
                            (e.value = e.value + ' ' + e.value),
                        super.set(e, t)
                    );
                }
            };
        ll.names = ['background-size'];
        fy.exports = ll;
    });
    var dy = v((LD, py) => {
        l();
        var c_ = I(),
            ul = ot(),
            fl = class extends c_ {
                insert(e, t, i) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    let n = ul.parse(e),
                        [s, a] = ul.translate(n, 0, 1);
                    n[0] &&
                        n[0].includes('span') &&
                        (a = n[0].join('').replace(/\D/g, '')),
                        [
                            [e.prop, s],
                            [`${e.prop}-span`, a],
                        ].forEach(([u, c]) => {
                            ul.insertDecl(e, u, c);
                        });
                }
            };
        fl.names = ['grid-row', 'grid-column'];
        py.exports = fl;
    });
    var gy = v((BD, my) => {
        l();
        var p_ = I(),
            {
                prefixTrackProp: hy,
                prefixTrackValue: d_,
                autoplaceGridItems: h_,
                getGridGap: m_,
                inheritGridGap: g_,
            } = ot(),
            y_ = To(),
            cl = class extends p_ {
                prefixed(e, t) {
                    return t === '-ms-'
                        ? hy({ prop: e, prefix: t })
                        : super.prefixed(e, t);
                }
                normalize(e) {
                    return e.replace(
                        /^grid-(rows|columns)/,
                        'grid-template-$1'
                    );
                }
                insert(e, t, i, n) {
                    if (t !== '-ms-') return super.insert(e, t, i);
                    let { parent: s, prop: a, value: o } = e,
                        u = a.includes('rows'),
                        c = a.includes('columns'),
                        f = s.some(
                            x =>
                                x.prop === 'grid-template' ||
                                x.prop === 'grid-template-areas'
                        );
                    if (f && u) return !1;
                    let p = new y_({ options: {} }),
                        h = p.gridStatus(s, n),
                        d = m_(e);
                    d = g_(e, d) || d;
                    let y = u ? d.row : d.column;
                    (h === 'no-autoplace' || h === !0) && !f && (y = null);
                    let k = d_({ value: o, gap: y });
                    e.cloneBefore({
                        prop: hy({ prop: a, prefix: t }),
                        value: k,
                    });
                    let w = s.nodes.find(x => x.prop === 'grid-auto-flow'),
                        b = 'row';
                    if (
                        (w && !p.disabled(w, n) && (b = w.value.trim()),
                        h === 'autoplace')
                    ) {
                        let x = s.nodes.find(
                            _ => _.prop === 'grid-template-rows'
                        );
                        if (!x && f) return;
                        if (!x && !f) {
                            e.warn(
                                n,
                                'Autoplacement does not work without grid-template-rows property'
                            );
                            return;
                        }
                        !s.nodes.find(
                            _ => _.prop === 'grid-template-columns'
                        ) &&
                            !f &&
                            e.warn(
                                n,
                                'Autoplacement does not work without grid-template-columns property'
                            ),
                            c && !f && h_(e, n, d, b);
                    }
                }
            };
        cl.names = [
            'grid-template-rows',
            'grid-template-columns',
            'grid-rows',
            'grid-columns',
        ];
        my.exports = cl;
    });
    var wy = v(($D, yy) => {
        l();
        var w_ = I(),
            pl = class extends w_ {
                check(e) {
                    return !e.value.includes('flex-') && e.value !== 'baseline';
                }
                prefixed(e, t) {
                    return t + 'grid-column-align';
                }
                normalize() {
                    return 'justify-self';
                }
            };
        pl.names = ['grid-column-align'];
        yy.exports = pl;
    });
    var vy = v((zD, by) => {
        l();
        var b_ = I(),
            dl = class extends b_ {
                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)
                    );
                }
            };
        dl.names = ['overscroll-behavior', 'scroll-chaining'];
        by.exports = dl;
    });
    var Sy = v((jD, ky) => {
        l();
        var v_ = I(),
            {
                parseGridAreas: x_,
                warnMissedAreas: k_,
                prefixTrackProp: S_,
                prefixTrackValue: xy,
                getGridGap: C_,
                warnGridGap: __,
                inheritGridGap: A_,
            } = ot();
        function O_(r) {
            return r
                .trim()
                .slice(1, -1)
                .split(/["']\s*["']?/g);
        }
        var hl = class extends v_ {
            insert(e, t, i, n) {
                if (t !== '-ms-') return super.insert(e, t, i);
                let s = !1,
                    a = !1,
                    o = e.parent,
                    u = C_(e);
                (u = A_(e, u) || u),
                    o.walkDecls(/-ms-grid-rows/, p => p.remove()),
                    o.walkDecls(/grid-template-(rows|columns)/, p => {
                        if (p.prop === 'grid-template-rows') {
                            a = !0;
                            let { prop: h, value: d } = p;
                            p.cloneBefore({
                                prop: S_({ prop: h, prefix: t }),
                                value: xy({ value: d, gap: u.row }),
                            });
                        } else s = !0;
                    });
                let c = O_(e.value);
                s &&
                    !a &&
                    u.row &&
                    c.length > 1 &&
                    e.cloneBefore({
                        prop: '-ms-grid-rows',
                        value: xy({
                            value: `repeat(${c.length}, auto)`,
                            gap: u.row,
                        }),
                        raws: {},
                    }),
                    __({ gap: u, hasColumns: s, decl: e, result: n });
                let f = x_({ rows: c, gap: u });
                return k_(f, e, n), e;
            }
        };
        hl.names = ['grid-template-areas'];
        ky.exports = hl;
    });
    var _y = v((VD, Cy) => {
        l();
        var E_ = I(),
            ml = class extends E_ {
                set(e, t) {
                    return (
                        t === '-webkit-' &&
                            (e.value = e.value.replace(
                                /\s*(right|left)\s*/i,
                                ''
                            )),
                        super.set(e, t)
                    );
                }
            };
        ml.names = ['text-emphasis-position'];
        Cy.exports = ml;
    });
    var Oy = v((UD, Ay) => {
        l();
        var T_ = I(),
            gl = class extends T_ {
                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);
                }
            };
        gl.names = ['text-decoration-skip-ink', 'text-decoration-skip'];
        Ay.exports = gl;
    });
    var Iy = v((WD, qy) => {
        l();
        ('use strict');
        qy.exports = {
            wrap: Ey,
            limit: Ty,
            validate: Py,
            test: yl,
            curry: P_,
            name: Dy,
        };
        function Ey(r, e, t) {
            var i = e - r;
            return ((((t - r) % i) + i) % i) + r;
        }
        function Ty(r, e, t) {
            return Math.max(r, Math.min(e, t));
        }
        function Py(r, e, t, i, n) {
            if (!yl(r, e, t, i, n))
                throw new Error(
                    t + ' is outside of range [' + r + ',' + e + ')'
                );
            return t;
        }
        function yl(r, e, t, i, n) {
            return !(t < r || t > e || (n && t === e) || (i && t === r));
        }
        function Dy(r, e, t, i) {
            return (t ? '(' : '[') + r + ',' + e + (i ? ')' : ']');
        }
        function P_(r, e, t, i) {
            var n = Dy.bind(null, r, e, t, i);
            return {
                wrap: Ey.bind(null, r, e),
                limit: Ty.bind(null, r, e),
                validate: function (s) {
                    return Py(r, e, s, t, i);
                },
                test: function (s) {
                    return yl(r, e, s, t, i);
                },
                toString: n,
                name: n,
            };
        }
    });
    var Fy = v((GD, My) => {
        l();
        var wl = Kr(),
            D_ = Iy(),
            q_ = $t(),
            I_ = ke(),
            R_ = ne(),
            Ry = /top|left|right|bottom/gi,
            Ue = class extends I_ {
                replace(e, t) {
                    let i = wl(e);
                    for (let n of i.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 i.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 = D_.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' ||
                        ((Ry.lastIndex = 0), !Ry.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 i of e)
                        if (t === 'before' && i.type === 'space') t = 'at';
                        else if (t === 'at' && i.value === 'at') t = 'after';
                        else {
                            if (t === 'after' && i.type === 'space') return !0;
                            if (i.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 = [],
                        i = [],
                        n,
                        s,
                        a,
                        o,
                        u;
                    for (o = 0; o < e.length - 2; o++)
                        if (
                            ((n = e[o]),
                            (s = e[o + 1]),
                            (a = e[o + 2]),
                            n.type === 'space' &&
                                s.value === 'at' &&
                                a.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 i.push(e[o]);
                    e.splice(0, o, ...i, c, ...t);
                }
                revertDirection(e) {
                    return Ue.directions[e.toLowerCase()] || e;
                }
                roundFloat(e, t) {
                    return parseFloat(e.toFixed(t));
                }
                oldWebkit(e) {
                    let { nodes: t } = e,
                        i = wl.stringify(e.nodes);
                    if (
                        this.name !== 'linear-gradient' ||
                        (t[0] && t[0].value.includes('deg')) ||
                        i.includes('px') ||
                        i.includes('-corner') ||
                        i.includes('-side')
                    )
                        return !1;
                    let n = [[]];
                    for (let s of t)
                        n[n.length - 1].push(s),
                            s.type === 'div' && s.value === ',' && n.push([]);
                    this.oldDirection(n), this.colorStops(n), (e.nodes = []);
                    for (let s of n) e.nodes = e.nodes.concat(s);
                    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: Ue.oldDirections.bottom },
                            t,
                        ]);
                    {
                        let i = [];
                        for (let s of e[0].slice(2))
                            s.type === 'word' && i.push(s.value.toLowerCase());
                        i = i.join(' ');
                        let n = Ue.oldDirections[i] || i;
                        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 i = 0; i < e.length; i++) {
                        let n,
                            s = e[i],
                            a;
                        if (i === 0) continue;
                        let o = wl.stringify(s[0]);
                        s[1] && s[1].type === 'word'
                            ? (n = s[1].value)
                            : s[2] && s[2].type === 'word' && (n = s[2].value);
                        let u;
                        i === 1 && (!n || n === '0%')
                            ? (u = `from(${o})`)
                            : i === e.length - 1 && (!n || n === '100%')
                            ? (u = `to(${o})`)
                            : n
                            ? (u = `color-stop(${n}, ${o})`)
                            : (u = `color-stop(${o})`);
                        let c = s[s.length - 1];
                        (e[i] = [{ type: 'word', value: u }]),
                            c.type === 'div' &&
                                c.value === ',' &&
                                (a = e[i].push(c)),
                            t.push(a);
                    }
                    return t;
                }
                old(e) {
                    if (e === '-webkit-') {
                        let t =
                                this.name === 'linear-gradient'
                                    ? 'linear'
                                    : 'radial',
                            i = '-gradient',
                            n = R_.regexp(
                                `-webkit-(${t}-gradient|gradient\\(\\s*${t})`,
                                !1
                            );
                        return new q_(this.name, e + this.name, i, n);
                    } else return super.old(e);
                }
                add(e, t) {
                    let i = e.prop;
                    if (i.includes('mask')) {
                        if (t === '-webkit-' || t === '-webkit- old')
                            return super.add(e, t);
                    } else if (
                        i === 'list-style' ||
                        i === 'list-style-image' ||
                        i === 'content'
                    ) {
                        if (t === '-webkit-' || t === '-webkit- old')
                            return super.add(e, t);
                    } else return super.add(e, t);
                }
            };
        Ue.names = [
            'linear-gradient',
            'repeating-linear-gradient',
            'radial-gradient',
            'repeating-radial-gradient',
        ];
        Ue.directions = {
            top: 'bottom',
            left: 'right',
            bottom: 'top',
            right: 'left',
        };
        Ue.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',
        };
        My.exports = Ue;
    });
    var By = v((HD, Ly) => {
        l();
        var M_ = $t(),
            F_ = ke();
        function Ny(r) {
            return new RegExp(`(^|[\\s,(])(${r}($|[\\s),]))`, 'gi');
        }
        var bl = class extends F_ {
            regexp() {
                return (
                    this.regexpCache || (this.regexpCache = Ny(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 M_(this.name, t, t, Ny(t))
                );
            }
            add(e, t) {
                if (!(e.prop.includes('grid') && t !== '-webkit-'))
                    return super.add(e, t);
            }
        };
        bl.names = [
            'max-content',
            'min-content',
            'fit-content',
            'fill',
            'fill-available',
            'stretch',
        ];
        Ly.exports = bl;
    });
    var jy = v((YD, zy) => {
        l();
        var $y = $t(),
            N_ = ke(),
            vl = class extends N_ {
                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 $y(this.name, '-webkit-optimize-contrast')
                        : e === '-moz-'
                        ? new $y(this.name, '-moz-crisp-edges')
                        : super.old(e);
                }
            };
        vl.names = ['pixelated'];
        zy.exports = vl;
    });
    var Uy = v((QD, Vy) => {
        l();
        var L_ = ke(),
            xl = class extends L_ {
                replace(e, t) {
                    let i = super.replace(e, t);
                    return (
                        t === '-webkit-' &&
                            (i = i.replace(
                                /("[^"]+"|'[^']+')(\s+\d+\w)/gi,
                                'url($1)$2'
                            )),
                        i
                    );
                }
            };
        xl.names = ['image-set'];
        Vy.exports = xl;
    });
    var Gy = v((JD, Wy) => {
        l();
        var B_ = me().list,
            $_ = ke(),
            kl = class extends $_ {
                replace(e, t) {
                    return B_.space(e)
                        .map(i => {
                            if (
                                i.slice(0, +this.name.length + 1) !==
                                this.name + '('
                            )
                                return i;
                            let n = i.lastIndexOf(')'),
                                s = i.slice(n + 1),
                                a = i.slice(this.name.length + 1, n);
                            if (t === '-webkit-') {
                                let o = a.match(/\d*.?\d+%?/);
                                o
                                    ? ((a = a.slice(o[0].length).trim()),
                                      (a += `, ${o[0]}`))
                                    : (a += ', 0.5');
                            }
                            return t + this.name + '(' + a + ')' + s;
                        })
                        .join(' ');
                }
            };
        kl.names = ['cross-fade'];
        Wy.exports = kl;
    });
    var Yy = v((XD, Hy) => {
        l();
        var z_ = fe(),
            j_ = $t(),
            V_ = ke(),
            Sl = class extends V_ {
                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, i;
                    return (
                        ([t, e] = z_(e)),
                        t === 2009
                            ? this.name === 'flex'
                                ? (i = 'box')
                                : (i = 'inline-box')
                            : t === 2012
                            ? this.name === 'flex'
                                ? (i = 'flexbox')
                                : (i = 'inline-flexbox')
                            : t === 'final' && (i = this.name),
                        e + i
                    );
                }
                replace(e, t) {
                    return this.prefixed(t);
                }
                old(e) {
                    let t = this.prefixed(e);
                    if (!!t) return new j_(this.name, t);
                }
            };
        Sl.names = ['display-flex', 'inline-flex'];
        Hy.exports = Sl;
    });
    var Jy = v((KD, Qy) => {
        l();
        var U_ = ke(),
            Cl = class extends U_ {
                constructor(e, t) {
                    super(e, t);
                    e === 'display-grid' && (this.name = 'grid');
                }
                check(e) {
                    return e.prop === 'display' && e.value === this.name;
                }
            };
        Cl.names = ['display-grid', 'inline-grid'];
        Qy.exports = Cl;
    });
    var Ky = v((ZD, Xy) => {
        l();
        var W_ = ke(),
            _l = class extends W_ {
                constructor(e, t) {
                    super(e, t);
                    e === 'filter-function' && (this.name = 'filter');
                }
            };
        _l.names = ['filter', 'filter-function'];
        Xy.exports = _l;
    });
    var rw = v((eq, tw) => {
        l();
        var Zy = ei(),
            R = I(),
            ew = Yh(),
            G_ = Zh(),
            H_ = To(),
            Y_ = wm(),
            Al = at(),
            Jt = zt(),
            Q_ = Am(),
            Ne = ke(),
            Xt = ne(),
            J_ = Em(),
            X_ = Pm(),
            K_ = qm(),
            Z_ = Rm(),
            eA = Bm(),
            tA = jm(),
            rA = Um(),
            iA = Gm(),
            nA = Ym(),
            sA = Jm(),
            aA = Km(),
            oA = eg(),
            lA = rg(),
            uA = ng(),
            fA = ag(),
            cA = ug(),
            pA = cg(),
            dA = hg(),
            hA = gg(),
            mA = wg(),
            gA = xg(),
            yA = Sg(),
            wA = Ag(),
            bA = Eg(),
            vA = Pg(),
            xA = qg(),
            kA = Rg(),
            SA = Ng(),
            CA = Bg(),
            _A = zg(),
            AA = Vg(),
            OA = Wg(),
            EA = Hg(),
            TA = Qg(),
            PA = Kg(),
            DA = ey(),
            qA = ry(),
            IA = ny(),
            RA = ay(),
            MA = uy(),
            FA = cy(),
            NA = dy(),
            LA = gy(),
            BA = wy(),
            $A = vy(),
            zA = Sy(),
            jA = _y(),
            VA = Oy(),
            UA = Fy(),
            WA = By(),
            GA = jy(),
            HA = Uy(),
            YA = Gy(),
            QA = Yy(),
            JA = Jy(),
            XA = Ky();
        Jt.hack(J_);
        Jt.hack(X_);
        Jt.hack(K_);
        Jt.hack(Z_);
        R.hack(eA);
        R.hack(tA);
        R.hack(rA);
        R.hack(iA);
        R.hack(nA);
        R.hack(sA);
        R.hack(aA);
        R.hack(oA);
        R.hack(lA);
        R.hack(uA);
        R.hack(fA);
        R.hack(cA);
        R.hack(pA);
        R.hack(dA);
        R.hack(hA);
        R.hack(mA);
        R.hack(gA);
        R.hack(yA);
        R.hack(wA);
        R.hack(bA);
        R.hack(vA);
        R.hack(xA);
        R.hack(kA);
        R.hack(SA);
        R.hack(CA);
        R.hack(_A);
        R.hack(AA);
        R.hack(OA);
        R.hack(EA);
        R.hack(TA);
        R.hack(PA);
        R.hack(DA);
        R.hack(qA);
        R.hack(IA);
        R.hack(RA);
        R.hack(MA);
        R.hack(FA);
        R.hack(NA);
        R.hack(LA);
        R.hack(BA);
        R.hack($A);
        R.hack(zA);
        R.hack(jA);
        R.hack(VA);
        Ne.hack(UA);
        Ne.hack(WA);
        Ne.hack(GA);
        Ne.hack(HA);
        Ne.hack(YA);
        Ne.hack(QA);
        Ne.hack(JA);
        Ne.hack(XA);
        var Ol = new Map(),
            ri = class {
                constructor(e, t, i = {}) {
                    (this.data = e),
                        (this.browsers = t),
                        (this.options = i),
                        ([this.add, this.remove] = this.preprocess(
                            this.select(this.data)
                        )),
                        (this.transition = new G_(this)),
                        (this.processor = new H_(this));
                }
                cleaner() {
                    if (this.cleanerCache) return this.cleanerCache;
                    if (this.browsers.selected.length) {
                        let e = new Al(this.browsers.data, []);
                        this.cleanerCache = new ri(this.data, e, this.options);
                    } else return this;
                    return this.cleanerCache;
                }
                select(e) {
                    let t = { add: {}, remove: {} };
                    for (let i in e) {
                        let n = e[i],
                            s = n.browsers.map(u => {
                                let c = u.split(' ');
                                return {
                                    browser: `${c[0]} ${c[1]}`,
                                    note: c[2],
                                };
                            }),
                            a = s
                                .filter(u => u.note)
                                .map(
                                    u =>
                                        `${this.browsers.prefix(u.browser)} ${
                                            u.note
                                        }`
                                );
                        (a = Xt.uniq(a)),
                            (s = s
                                .filter(u =>
                                    this.browsers.isSelected(u.browser)
                                )
                                .map(u => {
                                    let c = this.browsers.prefix(u.browser);
                                    return u.note ? `${c} ${u.note}` : c;
                                })),
                            (s = this.sort(Xt.uniq(s))),
                            this.options.flexbox === 'no-2009' &&
                                (s = s.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(a)),
                            (o = Xt.uniq(o)),
                            s.length
                                ? ((t.add[i] = s),
                                  s.length < o.length &&
                                      (t.remove[i] = o.filter(
                                          u => !s.includes(u)
                                      )))
                                : (t.remove[i] = o);
                    }
                    return t;
                }
                sort(e) {
                    return e.sort((t, i) => {
                        let n = Xt.removeNote(t).length,
                            s = Xt.removeNote(i).length;
                        return n === s ? i.length - t.length : s - n;
                    });
                }
                preprocess(e) {
                    let t = { selectors: [], '@supports': new Y_(ri, this) };
                    for (let n in e.add) {
                        let s = e.add[n];
                        if (n === '@keyframes' || n === '@viewport')
                            t[n] = new Q_(n, s, this);
                        else if (n === '@resolution') t[n] = new ew(n, s, this);
                        else if (this.data[n].selector)
                            t.selectors.push(Jt.load(n, s, this));
                        else {
                            let a = this.data[n].props;
                            if (a) {
                                let o = Ne.load(n, s, this);
                                for (let u of a)
                                    t[u] || (t[u] = { values: [] }),
                                        t[u].values.push(o);
                            } else {
                                let o = (t[n] && t[n].values) || [];
                                (t[n] = R.load(n, s, this)), (t[n].values = o);
                            }
                        }
                    }
                    let i = { selectors: [] };
                    for (let n in e.remove) {
                        let s = e.remove[n];
                        if (this.data[n].selector) {
                            let a = Jt.load(n, s);
                            for (let o of s) i.selectors.push(a.old(o));
                        } else if (n === '@keyframes' || n === '@viewport')
                            for (let a of s) {
                                let o = `@${a}${n.slice(1)}`;
                                i[o] = { remove: !0 };
                            }
                        else if (n === '@resolution') i[n] = new ew(n, s, this);
                        else {
                            let a = this.data[n].props;
                            if (a) {
                                let o = Ne.load(n, [], this);
                                for (let u of s) {
                                    let c = o.old(u);
                                    if (c)
                                        for (let f of a)
                                            i[f] || (i[f] = {}),
                                                i[f].values ||
                                                    (i[f].values = []),
                                                i[f].values.push(c);
                                }
                            } else
                                for (let o of s) {
                                    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)
                                        i[c] || (i[c] = {}), (i[c].remove = !0);
                                }
                        }
                    }
                    return [t, i];
                }
                decl(e) {
                    return Ol.has(e) || Ol.set(e, R.load(e)), Ol.get(e);
                }
                unprefixed(e) {
                    let t = this.normalize(Zy.unprefixed(e));
                    return t === 'flex-direction' && (t = 'flex-flow'), t;
                }
                normalize(e) {
                    return this.decl(e).normalize(e);
                }
                prefixed(e, t) {
                    return (e = Zy.unprefixed(e)), this.decl(e).prefixed(e, t);
                }
                values(e, t) {
                    let i = this[e],
                        n = i['*'] && i['*'].values,
                        s = i[t] && i[t].values;
                    return n && s ? Xt.uniq(n.concat(s)) : n || s || [];
                }
                group(e) {
                    let t = e.parent,
                        i = t.index(e),
                        { length: n } = t.nodes,
                        s = this.unprefixed(e.prop),
                        a = (o, u) => {
                            for (i += o; i >= 0 && i < n; ) {
                                let c = t.nodes[i];
                                if (c.type === 'decl') {
                                    if (
                                        (o === -1 &&
                                            c.prop === s &&
                                            !Al.withPrefix(c.value)) ||
                                        this.unprefixed(c.prop) !== s
                                    )
                                        break;
                                    if (u(c) === !0) return !0;
                                    if (
                                        o === 1 &&
                                        c.prop === s &&
                                        !Al.withPrefix(c.value)
                                    )
                                        break;
                                }
                                i += o;
                            }
                            return !1;
                        };
                    return {
                        up(o) {
                            return a(-1, o);
                        },
                        down(o) {
                            return a(1, o);
                        },
                    };
                }
            };
        tw.exports = ri;
    });
    var nw = v((tq, iw) => {
        l();
        iw.exports = {
            'backface-visibility': {
                mistakes: ['-ms-', '-o-'],
                feature: 'transforms3d',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            'backdrop-filter': {
                feature: 'css-backdrop-filter',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            element: {
                props: [
                    'background',
                    'background-image',
                    'border-image',
                    'mask',
                    'list-style',
                    'list-style-image',
                    'content',
                    'mask-image',
                ],
                feature: 'css-element-function',
                browsers: ['firefox 89'],
            },
            'user-select': {
                mistakes: ['-khtml-'],
                feature: 'user-select-none',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            'background-clip': {
                feature: 'background-clip-text',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            hyphens: {
                feature: 'css-hyphens',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            ':fullscreen': {
                selector: !0,
                feature: 'fullscreen',
                browsers: ['and_chr 92', 'and_uc 12.12', 'safari 14.1'],
            },
            '::backdrop': {
                selector: !0,
                feature: 'fullscreen',
                browsers: ['and_chr 92', 'and_uc 12.12', 'safari 14.1'],
            },
            '::file-selector-button': {
                selector: !0,
                feature: 'fullscreen',
                browsers: ['safari 14.1'],
            },
            'tab-size': { feature: 'css3-tabsize', browsers: ['firefox 89'] },
            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 92',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            '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 92',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            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 89'],
            },
            '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 89'],
            },
            'text-decoration-style': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-decoration-color': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-decoration-line': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-decoration': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-decoration-skip': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-decoration-skip-ink': {
                feature: 'text-decoration',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'text-size-adjust': {
                feature: 'text-size-adjust',
                browsers: ['ios_saf 14.0-14.4', 'ios_saf 14.5-14.7'],
            },
            'mask-clip': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-composite': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-image': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-origin': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-repeat': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border-repeat': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border-source': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            mask: {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-position': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-size': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border-outset': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border-width': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'mask-border-slice': {
                feature: 'css-masks',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'clip-path': {
                feature: 'css-clip-path',
                browsers: [
                    'and_uc 12.12',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'box-decoration-break': {
                feature: 'css-boxdecorationbreak',
                browsers: [
                    'and_chr 92',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            '@resolution': {
                feature: 'css-media-resolution',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            'border-inline-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'border-inline-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'margin-inline-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'margin-inline-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'padding-inline-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'padding-inline-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'border-block-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'border-block-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'margin-block-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'margin-block-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'padding-block-start': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            'padding-block-end': {
                feature: 'css-logical-props',
                browsers: ['and_uc 12.12'],
            },
            appearance: {
                feature: 'css-appearance',
                browsers: [
                    'and_uc 12.12',
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                    'samsung 14.0',
                ],
            },
            'image-set': {
                props: [
                    'background',
                    'background-image',
                    'border-image',
                    'cursor',
                    'mask',
                    'mask-image',
                    'list-style',
                    'list-style-image',
                    'content',
                ],
                feature: 'css-image-set',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            'cross-fade': {
                props: [
                    'background',
                    'background-image',
                    'border-image',
                    'mask',
                    'list-style',
                    'list-style-image',
                    'content',
                    'mask-image',
                ],
                feature: 'css-cross-fade',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            'text-emphasis': {
                feature: 'text-emphasis',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            'text-emphasis-position': {
                feature: 'text-emphasis',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            'text-emphasis-style': {
                feature: 'text-emphasis',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            'text-emphasis-color': {
                feature: 'text-emphasis',
                browsers: [
                    'and_chr 92',
                    'and_uc 12.12',
                    'chrome 91',
                    'chrome 92',
                    'edge 91',
                    'samsung 14.0',
                ],
            },
            ':any-link': {
                selector: !0,
                feature: 'css-any-link',
                browsers: ['and_uc 12.12'],
            },
            isolate: {
                props: ['unicode-bidi'],
                feature: 'css-unicode-bidi',
                browsers: [
                    'ios_saf 14.0-14.4',
                    'ios_saf 14.5-14.7',
                    'safari 14.1',
                ],
            },
            'color-adjust': {
                feature: 'css-color-adjust',
                browsers: ['chrome 91', 'chrome 92', 'edge 91', 'safari 14.1'],
            },
        };
    });
    var aw = v((rq, sw) => {
        l();
        sw.exports = {};
    });
    var fw = v((iq, uw) => {
        l();
        var KA = Co(),
            { agents: ZA } = (In(), qn),
            El = Rh(),
            eO = at(),
            tO = rw(),
            rO = nw(),
            iO = aw(),
            ow = { browsers: ZA, prefixes: rO },
            lw = `
  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 nO(r) {
            return Object.prototype.toString.apply(r) === '[object Object]';
        }
        var Tl = new Map();
        function sO(r, e) {
            e.browsers.selected.length !== 0 &&
                (e.add.selectors.length > 0 ||
                    Object.keys(e.add).length > 2 ||
                    r.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

`));
        }
        uw.exports = Kt;
        function Kt(...r) {
            let e;
            if (
                (r.length === 1 && nO(r[0])
                    ? ((e = r[0]), (r = void 0))
                    : r.length === 0 || (r.length === 1 && !r[0])
                    ? (r = void 0)
                    : r.length <= 2 && (Array.isArray(r[0]) || !r[0])
                    ? ((e = r[1]), (r = r[0]))
                    : typeof r[r.length - 1] == 'object' && (e = r.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
                ? (r = e.overrideBrowserslist)
                : e.browsers &&
                  (typeof console != 'undefined' &&
                      console.warn &&
                      (El.red
                          ? console.warn(
                                El.red(
                                    lw.replace(/`[^`]+`/g, n =>
                                        El.yellow(n.slice(1, -1))
                                    )
                                )
                            )
                          : console.warn(lw)),
                  (r = e.browsers));
            let t = {
                ignoreUnknownVersions: e.ignoreUnknownVersions,
                stats: e.stats,
                env: e.env,
            };
            function i(n) {
                let s = ow,
                    a = new eO(s.browsers, r, n, t),
                    o = a.selected.join(', ') + JSON.stringify(e);
                return (
                    Tl.has(o) || Tl.set(o, new tO(s.prefixes, a, e)), Tl.get(o)
                );
            }
            return {
                postcssPlugin: 'autoprefixer',
                prepare(n) {
                    let s = i({ from: n.opts.from, env: e.env });
                    return {
                        OnceExit(a) {
                            sO(n, s),
                                e.remove !== !1 && s.processor.remove(a, n),
                                e.add !== !1 && s.processor.add(a, n);
                        },
                    };
                },
                info(n) {
                    return (
                        (n = n || {}), (n.from = n.from || m.cwd()), iO(i(n))
                    );
                },
                options: e,
                browsers: r,
            };
        }
        Kt.postcss = !0;
        Kt.data = ow;
        Kt.defaults = KA.defaults;
        Kt.info = () => Kt().info();
    });
    var cw = {};
    Ce(cw, { default: () => aO });
    var aO,
        pw = A(() => {
            l();
            aO = [];
        });
    var hw = {};
    Ce(hw, { default: () => oO });
    var dw,
        oO,
        mw = A(() => {
            l();
            ui();
            (dw = J(Zt())), (oO = Ye(dw.default.theme));
        });
    var yw = {};
    Ce(yw, { default: () => lO });
    var gw,
        lO,
        ww = A(() => {
            l();
            ui();
            (gw = J(Zt())), (lO = Ye(gw.default));
        });
    function bw(r, e) {
        return { handler: r, config: e };
    }
    var vw,
        xw = A(() => {
            l();
            bw.withOptions = function (r, e = () => ({})) {
                let t = function (i) {
                    return { __options: i, handler: r(i), config: e(i) };
                };
                return (
                    (t.__isOptionsFunction = !0),
                    (t.__pluginFunction = r),
                    (t.__configFunction = e),
                    t
                );
            };
            vw = bw;
        });
    var kw = {};
    Ce(kw, { default: () => uO });
    var uO,
        Sw = A(() => {
            l();
            xw();
            uO = vw;
        });
    l();
    ('use strict');
    var fO = We(qh()),
        cO = We(me()),
        pO = We(fw()),
        dO = We((pw(), cw)),
        hO = We((mw(), hw)),
        mO = We((ww(), yw)),
        gO = We((jn(), Xl)),
        yO = We((Sw(), kw)),
        wO = We((Qs(), zf));
    function We(r) {
        return r && r.__esModule ? r : { default: r };
    }
    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 Mn = 'tailwind',
        Pl = 'text/tailwindcss',
        Cw = '/template.html',
        gt,
        _w = !0,
        Aw = 0,
        Dl = new Set(),
        ql,
        Ow = '',
        Ew = (r = !1) => ({
            get(e, t) {
                return (!r || t === 'config') &&
                    typeof e[t] == 'object' &&
                    e[t] !== null
                    ? new Proxy(e[t], Ew())
                    : e[t];
            },
            set(e, t, i) {
                return (e[t] = i), (!r || t === 'config') && Il(!0), !0;
            },
        });
    window[Mn] = new Proxy(
        {
            config: {},
            defaultTheme: hO.default,
            defaultConfig: mO.default,
            colors: gO.default,
            plugin: yO.default,
            resolveConfig: wO.default,
        },
        Ew(!0)
    );
    function Tw(r) {
        ql.observe(r, {
            attributes: !0,
            attributeFilter: ['type'],
            characterData: !0,
            subtree: !0,
            childList: !0,
        });
    }
    new MutationObserver(async r => {
        let e = !1;
        if (!ql) {
            ql = new MutationObserver(async () => await Il(!0));
            for (let t of document.querySelectorAll(`style[type="${Pl}"]`))
                Tw(t);
        }
        for (let t of r)
            for (let i of t.addedNodes)
                i.nodeType === 1 &&
                    i.tagName === 'STYLE' &&
                    i.getAttribute('type') === Pl &&
                    (Tw(i), (e = !0));
        await Il(e);
    }).observe(document.documentElement, {
        attributes: !0,
        attributeFilter: ['class'],
        childList: !0,
        subtree: !0,
    });
    async function Il(r = !1) {
        r && (Aw++, Dl.clear());
        let e = '';
        for (let i of document.querySelectorAll(`style[type="${Pl}"]`))
            e += i.textContent;
        let t = new Set();
        for (let i of document.querySelectorAll('[class]'))
            for (let n of i.classList) Dl.has(n) || t.add(n);
        if (
            document.body &&
            (_w || t.size > 0 || e !== Ow || !gt || !gt.isConnected)
        ) {
            for (let n of t) Dl.add(n);
            (_w = !1), (Ow = e), (self[Cw] = Array.from(t).join(' '));
            let i = (0, cO.default)([
                (0, fO.default)({
                    ...window[Mn].config,
                    _hash: Aw,
                    content: [Cw],
                    plugins: [
                        ...dO.default,
                        ...(Array.isArray(window[Mn].config.plugins)
                            ? window[Mn].config.plugins
                            : []),
                    ],
                }),
                (0, pO.default)({ remove: !1 }),
            ]).process(
                `@tailwind base;@tailwind components;@tailwind utilities;${e}`
            ).css;
            (!gt || !gt.isConnected) &&
                ((gt = document.createElement('style')),
                document.head.append(gt)),
                (gt.textContent = i);
        }
    }
})();
/*! https://mths.be/cssesc v3.0.0 by @mathias */