'use strict';

const unocss = require('unocss');
const utils = require('@unocss/preset-mini/utils');
const P = require('@vinicunca/perkakas');

function _interopNamespaceCompat(e) {
  if (e && typeof e === 'object' && 'default' in e) return e;
  const n = Object.create(null);
  if (e) {
    for (const k in e) {
      n[k] = e[k];
    }
  }
  n.default = e;
  return n;
}

const P__namespace = /*#__PURE__*/_interopNamespaceCompat(P);

const CSS_VARIABLE_PREFIX = "--vin";
const ENTER_ANIMATION_NAME = "vin-in";
const EXIT_ANIMATION_NAME = "vin-out";

function handleSlide(val, dir) {
  let value = utils.h.cssvar.fraction.rem(val || DEFAULT_SLIDE_TRANSLATE);
  if (!value) {
    return [];
  }
  if (!value.startsWith("var(--") && ["left", "top"].includes(dir ?? "")) {
    if (value.startsWith("-")) {
      value = value.slice(1);
    } else if (value !== "0") {
      value = `-${value}`;
    }
  }
  return [value, dir];
}

const DEFAULT_FADE_OPACITY = "0";
const DEFAULT_ZOOM_SCALE = "0";
const DEFAULT_SPIN_DEGREE = "30deg";
const DEFAULT_SLIDE_TRANSLATE = "100%";
const DIRECTIONS_AUTOCOMPLETE = "(t|b|l|r|top|bottom|left|right)";
const fadeRules = [
  [
    /^fade-in(?:-(.+))?$/,
    ([, op]) => ({
      [`${CSS_VARIABLE_PREFIX}-enter-opacity`]: utils.h.cssvar.percent(op || DEFAULT_FADE_OPACITY)
    }),
    { autocomplete: "fade-(in|out)-<percent>", layer: "animation" }
  ],
  [
    /^fade-out(?:-(.+))?$/,
    ([, op]) => ({
      [`${CSS_VARIABLE_PREFIX}-exit-opacity`]: utils.h.cssvar.percent(op || DEFAULT_FADE_OPACITY)
    }),
    { layer: "animation" }
  ]
];
const zoomRules = [
  [
    /^zoom-in(?:-(.+))?$/,
    ([, scale]) => ({
      [`${CSS_VARIABLE_PREFIX}-enter-scale`]: utils.h.cssvar.fraction.percent(scale || DEFAULT_ZOOM_SCALE)
    }),
    { autocomplete: "zoom-(in|out)-<percent>", layer: "animation" }
  ],
  [
    /^zoom-out(?:-(.+))?$/,
    ([, scale]) => ({
      [`${CSS_VARIABLE_PREFIX}-exit-scale`]: utils.h.cssvar.fraction.percent(scale || DEFAULT_ZOOM_SCALE)
    }),
    { layer: "animation" }
  ]
];
const spinRules = [
  [
    /^spin-in(?:-(.+))?$/,
    ([, deg]) => ({
      [`${CSS_VARIABLE_PREFIX}-enter-rotate`]: utils.h.cssvar.degree(deg || DEFAULT_SPIN_DEGREE)
    }),
    { autocomplete: "spin-(in|out)-<percent>", layer: "animation" }
  ],
  [
    /^spin-out(?:-(.+))?$/,
    ([, deg]) => ({
      [`${CSS_VARIABLE_PREFIX}-exit-rotate`]: utils.h.cssvar.degree(deg || DEFAULT_SPIN_DEGREE)
    }),
    { layer: "animation" }
  ]
];
const slideRules = [
  [
    /^slide-in(?:-from)?-([tblr]|top|bottom|left|right)(?:-(.+))?$/,
    ([, dir, val]) => {
      const [value, direction] = handleSlide(val, dir);
      if (!value) {
        return;
      }
      switch (direction) {
        case "top":
        case "bottom": {
          return { [`${CSS_VARIABLE_PREFIX}-enter-translate-y`]: value };
        }
        case "left":
        case "right": {
          return { [`${CSS_VARIABLE_PREFIX}-enter-translate-x`]: value };
        }
      }
    },
    {
      autocomplete: [
        `slide-(in|out)-${DIRECTIONS_AUTOCOMPLETE}-<percent>`,
        `slide-(in|out)-${DIRECTIONS_AUTOCOMPLETE}-full`,
        `slide-in-from-${DIRECTIONS_AUTOCOMPLETE}-<percent>`,
        `slide-in-from-${DIRECTIONS_AUTOCOMPLETE}-full`
      ],
      layer: "animation"
    }
  ],
  [
    /^slide-out(?:-to)?-([tblr]|top|bottom|left|right)(?:-(.+))?$/,
    ([, dir, val]) => {
      const [value, direction] = handleSlide(val, dir);
      if (!value) {
        return;
      }
      switch (direction) {
        case "top":
        case "bottom": {
          return { [`${CSS_VARIABLE_PREFIX}-exit-translate-y`]: value };
        }
        case "left":
        case "right": {
          return { [`${CSS_VARIABLE_PREFIX}-exit-translate-x`]: value };
        }
      }
    },
    {
      autocomplete: [
        `slide-out-to-${DIRECTIONS_AUTOCOMPLETE}-<percent>`,
        `slide-out-to-${DIRECTIONS_AUTOCOMPLETE}-full`
      ],
      layer: "animation"
    }
  ]
];
const animationRules = [
  ...fadeRules,
  ...zoomRules,
  ...spinRules,
  ...slideRules
];

function animationShortcuts(options) {
  function getSharedAnimationProperties(theme) {
    return {
      "animation-duration": options.duration ? `${options.duration}${options.unit}` : theme.duration?.DEFAULT,
      ...options.delay && { "animation-delay": `${options.delay}${options.unit}` },
      ...options.direction && { "animation-direction": options.direction },
      ...options.fillMode && { "animation-fill-mode": options.fillMode },
      ...options.iterationCount && { "animation-iteration-count": options.iterationCount },
      ...options.playState && { "animation-play-state": options.playState },
      ...options.timingFunction && { "animation-timing-function": options.timingFunction }
    };
  }
  return [
    [
      /^animate-in$/,
      (_, { theme }) => [
        `keyframes-${ENTER_ANIMATION_NAME}`,
        {
          "animation-name": ENTER_ANIMATION_NAME,
          ...getSharedAnimationProperties(theme),
          [`${CSS_VARIABLE_PREFIX}-enter-opacity`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-enter-scale`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-enter-rotate`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-enter-translate-x`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-enter-translate-y`]: "initial"
        }
      ],
      { autocomplete: "animate-in" }
    ],
    [
      /^animate-out$/,
      (_, { theme }) => [
        `keyframes-${EXIT_ANIMATION_NAME}`,
        {
          "animation-name": EXIT_ANIMATION_NAME,
          ...getSharedAnimationProperties(theme),
          [`${CSS_VARIABLE_PREFIX}-exit-opacity`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-exit-scale`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-exit-rotate`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-exit-translate-x`]: "initial",
          [`${CSS_VARIABLE_PREFIX}-exit-translate-y`]: "initial"
        }
      ],
      { autocomplete: "animate-out" }
    ]
  ];
}

const animationTheme = {
  keyframes: {
    [ENTER_ANIMATION_NAME]: `{from{opacity:var(${CSS_VARIABLE_PREFIX}-enter-opacity,1);transform:translate3d(var(${CSS_VARIABLE_PREFIX}-enter-translate-x,0),var(${CSS_VARIABLE_PREFIX}-enter-translate-y,0),0) scale3d(var(${CSS_VARIABLE_PREFIX}-enter-scale,1),var(${CSS_VARIABLE_PREFIX}-enter-scale,1),var(${CSS_VARIABLE_PREFIX}-enter-scale,1)) rotate(var(${CSS_VARIABLE_PREFIX}-enter-rotate,0))}}`,
    [EXIT_ANIMATION_NAME]: `{to{opacity:var(${CSS_VARIABLE_PREFIX}-exit-opacity,1);transform:translate3d(var(${CSS_VARIABLE_PREFIX}-exit-translate-x,0),var(${CSS_VARIABLE_PREFIX}-exit-translate-y,0),0) scale3d(var(${CSS_VARIABLE_PREFIX}-exit-scale,1),var(${CSS_VARIABLE_PREFIX}-exit-scale,1),var(${CSS_VARIABLE_PREFIX}-exit-scale,1)) rotate(var(${CSS_VARIABLE_PREFIX}-exit-rotate,0))}}`
  }
};

const FLUID_UTILITIES = {
  "fluid-text": "font-size",
  "fluid-w": "width",
  "fluid-min-w": "min-width",
  "fluid-max-w": "max-width",
  "fluid-h": "height",
  "fluid-min-h": "min-height",
  "fluid-max-h": "max-height",
  "fluid-p": "padding",
  "fluid-pt": "padding-top",
  "fluid-pb": "padding-bottom",
  "fluid-pl": "padding-left",
  "fluid-pr": "padding-right",
  "fluid-px": ["padding-left", "padding-right"],
  "fluid-py": ["padding-top", "padding-bottom"],
  "fluid-m": "margin",
  "fluid-mt": "margin-top",
  "fluid-mb": "margin-bottom",
  "fluid-ml": "margin-left",
  "fluid-mr": "margin-right",
  "fluid-mx": ["margin-left", "margin-right"],
  "fluid-my": ["margin-top", "margin-bottom"],
  "fluid-gap": "gap",
  "fluid-gap-x": "column-gap",
  "fluid-gap-y": "row-gap",
  "fluid-indent": "text-indent",
  "fluid-scroll-m": "scroll-margin",
  "fluid-scroll-mt": "scroll-margin-top",
  "fluid-scroll-mb": "scroll-margin-bottom",
  "fluid-scroll-ml": "scroll-margin-left",
  "fluid-scroll-mr": "scroll-margin-right",
  "fluid-scroll-mx": ["scroll-margin-left", "scroll-margin-right"],
  "fluid-scroll-my": ["scroll-margin-top", "scroll-margin-bottom"],
  "fluid-scroll-ms": "scroll-margin-inline-start",
  "fluid-scroll-me": "scroll-margin-inline-end",
  "fluid-scroll-p": "scroll-padding",
  "fluid-scroll-pt": "scroll-padding-top",
  "fluid-scroll-pb": "scroll-padding-bottom",
  "fluid-scroll-pl": "scroll-padding-left",
  "fluid-scroll-pr": "scroll-padding-right",
  "fluid-scroll-px": ["scroll-padding-left", "scroll-padding-right"],
  "fluid-scroll-py": ["scroll-padding-top", "scroll-padding-bottom"],
  "fluid-scroll-ps": "scroll-padding-inline-start",
  "fluid-scroll-pe": "scroll-padding-inline-end",
  "fluid-leading": "line-height",
  "fluid-top": "top",
  "fluid-right": "right",
  "fluid-bottom": "bottom",
  "fluid-left": "left",
  "fluid-inset": "inset",
  "fluid-inset-x": ["left", "right"],
  "fluid-inset-y": ["top", "bottom"]
};

const REGEX_PATTERNS_NUMERIC_VALUES = "(?:--)?(-?\\d+)?(?:--)?(-?\\d+)?$";
const REGEX_PATTERNS_RANGE_VALUES = "(?:--)?(-?\\d+)?(?:-([a-zA-Z0-9]+))?$";
function extractValuesFromRegexMatch(match) {
  const [utility, matchMin, matchMax, , predefinedRangeName] = match;
  return {
    utility,
    matchMin,
    matchMax,
    predefinedRangeName
  };
}

function invertAndParseNumber(value) {
  if (!value) {
    return 0;
  }
  if (value.includes("-")) {
    return Number.parseInt(value.replace("-", ""));
  }
  return -Number.parseInt(value);
}

function validateUtilityRange({ range, utility, config }) {
  if (!config.ranges) {
    throw new Error(`[unocss-vinicunca fluid] (${utility}) Trying to use predefined range ${range} but no ranges are defined.`);
  }
  if (!config.ranges[range]) {
    throw new Error(`[unocss-vinicunca fluid] (${utility}) Trying to use predefined range ${range} but it is not defined in ranges.`);
  }
  return true;
}
function validateUtilityName({ match, config }) {
  const {
    utility,
    matchMin,
    matchMax,
    predefinedRangeName
  } = extractValuesFromRegexMatch(match);
  if (!predefinedRangeName && matchMin && matchMax) {
    return true;
  }
  try {
    validateUtilityRange({ range: predefinedRangeName, utility, config });
  } catch (error) {
    console.warn(error.message);
    return false;
  }
  return true;
}

function getRemMaxWidth(config) {
  const maxWidth = config.extendMaxWidth || config.maxWidth;
  if (config.useRemByDefault) {
    return maxWidth;
  } else {
    return maxWidth / config.remBase;
  }
}
function getRemMinWidth(config) {
  const minWidth = config.extendMinWidth || config.minWidth;
  if (config.useRemByDefault) {
    return minWidth;
  } else {
    return minWidth / config.remBase;
  }
}
function toRem(value, config) {
  if (config.useRemByDefault) {
    return value;
  } else {
    return value / config.remBase;
  }
}
function calculateRelativeSize({
  originalViewPortMin,
  originalMinSize,
  originalMaxSize,
  originalViewPortMax,
  newViewPortSize
}) {
  const slope = (originalMaxSize - originalMinSize) / (originalViewPortMax - originalViewPortMin);
  return slope * (newViewPortSize - originalViewPortMin) + originalMinSize;
}
function extractRemBoundsFromMatch({ match, config }) {
  let min, max;
  const [utility, matchMin, matchMax, , predefinedRangeName] = match;
  if (predefinedRangeName) {
    validateUtilityRange({ range: predefinedRangeName, utility, config });
    const [minRange, maxRange] = config.ranges[predefinedRangeName];
    min = toRem(minRange, config);
    max = toRem(maxRange, config);
  } else {
    min = toRem(invertAndParseNumber(matchMin), config);
    max = toRem(invertAndParseNumber(matchMax), config);
  }
  let relativeMin;
  let relativeMax;
  if (config.extendMinWidth) {
    relativeMin = calculateRelativeSize(
      {
        originalViewPortMin: config.minWidth,
        originalMinSize: min,
        originalMaxSize: max,
        originalViewPortMax: config.maxWidth,
        newViewPortSize: config.extendMinWidth
      }
    );
  }
  if (config.extendMaxWidth) {
    relativeMax = calculateRelativeSize(
      {
        originalViewPortMin: config.minWidth,
        originalMinSize: min,
        originalMaxSize: max,
        originalViewPortMax: config.maxWidth,
        newViewPortSize: config.extendMinWidth
      }
    );
  }
  return {
    min: relativeMin ?? min,
    max: relativeMax ?? max
  };
}

function getSlope({ min, max, config }) {
  const remMaxWidth = getRemMaxWidth(config);
  const remMinWidth = getRemMinWidth(config);
  return (max - min) / (remMaxWidth - remMinWidth);
}
function getIntersection({ min, slope, minWidth }) {
  return -minWidth * slope + min;
}
function getSlopePercentage({ min, max, config }) {
  const slope = getSlope({ min, max, config });
  return slope * 100;
}
function getClamp({ min, max, config }) {
  const slope = getSlope({ min, max, config });
  const intersection = getIntersection({ min, slope, minWidth: getRemMinWidth(config) });
  const slopePercentage = getSlopePercentage({ min, max, config });
  const clampMin = Math.min(min, max);
  const clampMax = Math.max(min, max);
  return `clamp(${clampMin}rem, ${intersection.toFixed(4)}rem + ${slopePercentage.toFixed(4)}vw, ${clampMax}rem)`;
}
function getClampComment({ match, config }) {
  if (!config.commentHelpers) {
    return "";
  }
  const { predefinedRangeName, matchMin, matchMax } = extractValuesFromRegexMatch(match);
  const predefinedRange = config.ranges && config.ranges[predefinedRangeName];
  const isRem = config.useRemByDefault;
  const min = predefinedRange ? predefinedRange[0] : -Number.parseInt(matchMin);
  const max = predefinedRange ? predefinedRange[1] : -Number.parseInt(matchMax);
  const unit = isRem ? "rem" : "px";
  return `/* ${min}${unit} -> ${max}${unit} */`;
}

function buildSinglePropertyRule({ match, config, property }) {
  if (!validateUtilityName({ match, config })) {
    return "";
  }
  const { min, max } = extractRemBoundsFromMatch({ match, config });
  return {
    [`${property}`]: getClamp({ min, max, config }) + getClampComment({ match, config })
  };
}
function buildMultiplePropertiesRule({ match, config, properties }) {
  if (!validateUtilityName({ match, config }) || !Array.isArray(properties)) {
    return "";
  }
  const { min, max } = extractRemBoundsFromMatch({ match, config });
  const selectors = {};
  properties.forEach((property) => {
    selectors[property] = getClamp({ min, max, config }) + getClampComment({ match, config });
  });
  return {
    ...selectors
  };
}
function buildRule({ name, properties, config }) {
  const regexPattersNumericValues = `^${name}${REGEX_PATTERNS_NUMERIC_VALUES}`;
  const regexPattersRangeValues = `^${name}${REGEX_PATTERNS_RANGE_VALUES}`;
  const regexPattern = `${regexPattersNumericValues}|${regexPattersRangeValues}`;
  const regex = new RegExp(regexPattern);
  if (Array.isArray(properties)) {
    return [
      [
        regex,
        (match) => buildMultiplePropertiesRule({ match, config, properties })
      ]
    ];
  } else {
    return [
      [
        regex,
        (match) => buildSinglePropertyRule({ match, config, property: properties })
      ]
    ];
  }
}
function buildRulesFromUtilities(config) {
  return Object.entries(FLUID_UTILITIES).flatMap(([name, property]) => {
    return buildRule({ name, properties: property, config });
  });
}

const resetCSS = `
/*
1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4)
2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116)
2. [UnoCSS]: allow to override the default border color with css var \`--un-default-border-color\`
*/

*,
::before,
::after {
  box-sizing: border-box; /* 1 */
  border-width: 0; /* 2 */
  border-style: solid; /* 2 */
  border-color: var(--un-default-border-color, #e5e7eb); /* 2 */
}

/*
1. Use a consistent sensible line-height in all browsers.
2. Prevent adjustments of font size after orientation changes in iOS.
3. Use a more readable tab size.
4. Use the user's configured \`sans\` font-family by default.
5. Use the user's configured \`sans\` font-feature-settings by default.
6. Use the user's configured \`sans\` font-variation-settings by default.
7. Disable tap highlights on iOS.
*/

html,
:host {
  line-height: 1.5; /* 1 */
  -webkit-text-size-adjust: 100%; /* 2 */
  -moz-tab-size: 4; /* 3 */
  tab-size: 4; /* 3 */
  font-family: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; /* 4 */
  font-feature-settings: normal; /* 5 */
  font-variation-settings: normal; /* 6 */
  -webkit-tap-highlight-color: transparent; /* 7 */
}

/*
1. Remove the margin in all browsers.
2. Inherit line-height from \`html\` so users can set them as a class directly on the \`html\` element.
*/

body {
  margin: 0; /* 1 */
  line-height: inherit; /* 2 */
}

/*
1. Add the correct height in Firefox.
2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655)
3. Ensure horizontal rules are visible by default.
*/

hr {
  height: 0; /* 1 */
  color: inherit; /* 2 */
  border-top-width: 1px; /* 3 */
}

/*
Add the correct text decoration in Chrome, Edge, and Safari.
*/

abbr:where([title]) {
  text-decoration: underline dotted;
}

/*
Remove the default font size and weight for headings.
*/

h1,
h2,
h3,
h4,
h5,
h6 {
  font-size: inherit;
  font-weight: inherit;
}

/*
Reset links to optimize for opt-in styling instead of opt-out.
*/

a {
  color: inherit;
  text-decoration: inherit;
}

/*
Add the correct font weight in Edge and Safari.
*/

b,
strong {
  font-weight: bolder;
}

/*
1. Use the user's configured \`mono\` font-family by default.
2. Use the user's configured \`mono\` font-feature-settings by default.
3. Use the user's configured \`mono\` font-variation-settings by default.
4. Correct the odd \`em\` font sizing in all browsers.
*/

code,
kbd,
samp,
pre {
  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; /* 1 */
  font-feature-settings: normal; /* 2 */
  font-variation-settings: normal; /* 3 */
  font-size: 1em; /* 4 */
}

/*
Add the correct font size in all browsers.
*/

small {
  font-size: 80%;
}

/*
Prevent \`sub\` and \`sup\` elements from affecting the line height in all browsers.
*/

sub,
sup {
  font-size: 75%;
  line-height: 0;
  position: relative;
  vertical-align: baseline;
}

sub {
  bottom: -0.25em;
}

sup {
  top: -0.5em;
}

/*
1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297)
2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016)
3. Remove gaps between table borders by default.
*/

table {
  text-indent: 0; /* 1 */
  border-color: inherit; /* 2 */
  border-collapse: collapse; /* 3 */
}

/*
1. Change the font styles in all browsers.
2. Remove the margin in Firefox and Safari.
3. Remove default padding in all browsers.
*/

button,
input,
optgroup,
select,
textarea {
  font-family: inherit; /* 1 */
  font-feature-settings: inherit; /* 1 */
  font-variation-settings: inherit; /* 1 */
  font-size: 100%; /* 1 */
  font-weight: inherit; /* 1 */
  line-height: inherit; /* 1 */
  color: inherit; /* 1 */
  margin: 0; /* 2 */
  padding: 0; /* 3 */
}

/*
Remove the inheritance of text transform in Edge and Firefox.
*/

button,
select {
  text-transform: none;
}

/*
1. Correct the inability to style clickable types in iOS and Safari.
2. Remove default button styles.
*/

button,
[type='button'],
[type='reset'],
[type='submit'] {
  -webkit-appearance: button; /* 1 */
  background-color: transparent; /* 2 */
  background-image: none; /* 2 */
}

/*
Use the modern Firefox focus style for all focusable elements.
*/

:-moz-focusring {
  outline: auto;
}

/*
Remove the additional \`:invalid\` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737)
*/

:-moz-ui-invalid {
  box-shadow: none;
}

/*
Add the correct vertical alignment in Chrome and Firefox.
*/

progress {
  vertical-align: baseline;
}

/*
Correct the cursor style of increment and decrement buttons in Safari.
*/

::-webkit-inner-spin-button,
::-webkit-outer-spin-button {
  height: auto;
}

/*
1. Correct the odd appearance in Chrome and Safari.
2. Correct the outline style in Safari.
*/

[type='search'] {
  -webkit-appearance: textfield; /* 1 */
  outline-offset: -2px; /* 2 */
}

/*
Remove the inner padding in Chrome and Safari on macOS.
*/

::-webkit-search-decoration {
  -webkit-appearance: none;
}

/*
1. Correct the inability to style clickable types in iOS and Safari.
2. Change font properties to \`inherit\` in Safari.
*/

::-webkit-file-upload-button {
  -webkit-appearance: button; /* 1 */
  font: inherit; /* 2 */
}

/*
Add the correct display in Chrome and Safari.
*/

summary {
  display: list-item;
}

/*
Removes the default spacing for appropriate elements.
*/

blockquote,
dl,
dd,
h1,
h2,
h3,
h4,
h5,
h6,
hr,
figure,
p,
pre {
  margin: 0;
}

fieldset {
  margin: 0;
  padding: 0;
}

legend {
  padding: 0;
}

ol,
ul,
menu {
  list-style: none;
  margin: 0;
  padding: 0;
}

dialog {
  padding: 0;
}

/*
Prevent resizing textareas horizontally by default.
*/

textarea {
  resize: vertical;
}

/*
1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300)
2. Set the default placeholder color to the user's configured gray 400 color.
*/

input::placeholder,
textarea::placeholder {
  opacity: 1; /* 1 */
  color: #9ca3af; /* 2 */
}

/*
Set the default cursor for buttons.
*/

button,
[role="button"] {
  cursor: pointer;
}

/*
Make sure disabled buttons don't get the pointer cursor.
*/

:disabled {
  cursor: default;
}

/*
1. Make replaced elements \`display: block\` by default. (https://github.com/mozdevs/cssremedy/issues/14)
2. Add \`vertical-align: middle\` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
   This can trigger a poorly considered lint error in some tools but is included by design.
*/

img,
svg,
video,
canvas,
audio,
iframe,
embed,
object {
  display: block; /* 1 */
  vertical-align: middle; /* 2 */
}

/*
Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14)
*/

img,
video {
  max-width: 100%;
  height: auto;
}

/*
Make elements with the HTML hidden attribute stay hidden by default.
*/

[hidden] {
  display: none;
}`.trim();
function compressCSS(css) {
  return css.replace(/\s+/g, " ").replace(/\/\*[\s\S]*?\*\//g, "");
}
const resetPreflight = {
  layer: "preflights",
  getCSS: () => compressCSS(resetCSS)
};

function getPreflights(options) {
  if (!options.enableResetStyles) {
    return [];
  }
  return [
    resetPreflight
  ];
}

const defaultFluidOptions = {
  maxWidth: 1440,
  minWidth: 375,
  remBase: 16,
  useRemByDefault: false,
  extendMaxWidth: null,
  extendMinWidth: null,
  ranges: null,
  commentHelpers: false
};
const defaultOptions = {
  icons: true,
  enableResetStyles: true,
  fluidOptions: defaultFluidOptions,
  animationOptions: {
    unit: "ms"
  }
};
function resolveOptions(options) {
  const optionsWithDefault = P__namespace.mergeDeep(defaultOptions, options);
  const presets = [];
  const presetMap = {
    icons: unocss.presetIcons
  };
  for (const [key, preset] of Object.entries(presetMap)) {
    const option = optionsWithDefault[key];
    if (option) {
      const preset_ = preset;
      presets.push(
        preset_(
          P__namespace.isBoolean(option) ? {} : option
        )
      );
    }
  }
  return {
    ...optionsWithDefault,
    presets
  };
}

const presetVinicunca = unocss.definePreset((options) => {
  const resolvedOptions = resolveOptions(options);
  const { presets, fluidOptions, animationOptions } = resolvedOptions;
  return {
    name: "unocss-preset-vinicunca",
    layers: {
      animation: 10
    },
    presets,
    preflights: getPreflights(resolvedOptions),
    theme: {
      animation: animationTheme
    },
    shortcuts: [
      ...animationShortcuts(animationOptions)
    ],
    rules: [
      ...animationRules,
      ...buildRulesFromUtilities(fluidOptions)
    ]
  };
});

exports.presetVinicunca = presetVinicunca;