@unocss/preset-mini 0.15.0

package/dist/chunks/default3.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+const variants$1 = require('./variants.cjs');
+const pseudo = require('./pseudo.cjs');
+
+const regexCache = {};
+const variantBreakpoints = (matcher, _, theme) => {
+  const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
+  for (const [point, size, idx] of variantEntries) {
+    if (!regexCache[point])
+      regexCache[point] = new RegExp(`^((?:[a|l]t-)?${point}[:-])`);
+    const match = matcher.match(regexCache[point]);
+    if (!match)
+      continue;
+    const [, pre] = match;
+    let direction = "min";
+    let order = parseInt(size);
+    if (pre.startsWith("lt-")) {
+      direction = "max";
+      order = -order;
+    }
+    const m = matcher.slice(pre.length);
+    if (m === "container")
+      continue;
+    if (pre.startsWith("at-") && idx < variantEntries.length - 1) {
+      return {
+        matcher: m,
+        parent: [`@media (min-width: ${size}) and (max-width: ${variantEntries[idx + 1][1]})`, order]
+      };
+    }
+    return {
+      matcher: m,
+      parent: [`@media (${direction}-width: ${size})`, order]
+    };
+  }
+};
+
+const variantChildren = [
+  variants$1.variantMatcher("children", (input) => `${input} > *`),
+  variants$1.variantMatcher("all", (input) => `${input} *`),
+  variants$1.variantMatcher("next", (input) => `${input}+*`)
+];
+
+const variantColorsClass = [
+  variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`),
+  variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)
+];
+const variantColorsMedia = [
+  (v) => {
+    const dark = variants$1.variantMatcher("dark")(v);
+    if (dark) {
+      return {
+        ...dark,
+        parent: "@media (prefers-color-scheme: dark)"
+      };
+    }
+    const light = variants$1.variantMatcher("light")(v);
+    if (light) {
+      return {
+        ...light,
+        parent: "@media (prefers-color-scheme: light)"
+      };
+    }
+  }
+];
+
+const variantImportant = {
+  match(matcher) {
+    if (matcher.startsWith("!")) {
+      return {
+        matcher: matcher.slice(1),
+        body: (body) => {
+          body.forEach((v) => {
+            if (v[1])
+              v[1] += " !important";
+          });
+          return body;
+        }
+      };
+    }
+  }
+};
+const variantNegative = {
+  match(matcher) {
+    if (matcher.startsWith("-")) {
+      return {
+        matcher: matcher.slice(1),
+        body: (body) => {
+          body.forEach((v) => {
+            if (v[0].startsWith("--un-scale") || v[1]?.toString() === "0")
+              return;
+            v[1] = v[1]?.toString().replace(/[0-9.]+(?:[a-z]+|%)?/, (i) => `-${i}`);
+          });
+          return body;
+        }
+      };
+    }
+  }
+};
+const variantSpace = (matcher) => {
+  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
+    return {
+      matcher,
+      selector: (input) => {
+        return `${input}>:not([hidden])~:not([hidden])`;
+      }
+    };
+  }
+};
+
+const variants = [
+  variantSpace,
+  variantNegative,
+  variantImportant,
+  variantBreakpoints,
+  ...variantChildren,
+  pseudo.variantPseudoClasses,
+  pseudo.variantPseudoElements
+];
+
+exports.variantBreakpoints = variantBreakpoints;
+exports.variantChildren = variantChildren;
+exports.variantColorsClass = variantColorsClass;
+exports.variantColorsMedia = variantColorsMedia;
+exports.variantImportant = variantImportant;
+exports.variantNegative = variantNegative;
+exports.variantSpace = variantSpace;
+exports.variants = variants;

package/dist/chunks/default3.mjs

@@ -0,0 +1,119 @@
+import { v as variantMatcher } from './variants.mjs';
+import { v as variantPseudoClasses, a as variantPseudoElements } from './pseudo.mjs';
+
+const regexCache = {};
+const variantBreakpoints = (matcher, _, theme) => {
+  const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
+  for (const [point, size, idx] of variantEntries) {
+    if (!regexCache[point])
+      regexCache[point] = new RegExp(`^((?:[a|l]t-)?${point}[:-])`);
+    const match = matcher.match(regexCache[point]);
+    if (!match)
+      continue;
+    const [, pre] = match;
+    let direction = "min";
+    let order = parseInt(size);
+    if (pre.startsWith("lt-")) {
+      direction = "max";
+      order = -order;
+    }
+    const m = matcher.slice(pre.length);
+    if (m === "container")
+      continue;
+    if (pre.startsWith("at-") && idx < variantEntries.length - 1) {
+      return {
+        matcher: m,
+        parent: [`@media (min-width: ${size}) and (max-width: ${variantEntries[idx + 1][1]})`, order]
+      };
+    }
+    return {
+      matcher: m,
+      parent: [`@media (${direction}-width: ${size})`, order]
+    };
+  }
+};
+
+const variantChildren = [
+  variantMatcher("children", (input) => `${input} > *`),
+  variantMatcher("all", (input) => `${input} *`),
+  variantMatcher("next", (input) => `${input}+*`)
+];
+
+const variantColorsClass = [
+  variantMatcher("dark", (input) => `.dark $$ ${input}`),
+  variantMatcher("light", (input) => `.light $$ ${input}`)
+];
+const variantColorsMedia = [
+  (v) => {
+    const dark = variantMatcher("dark")(v);
+    if (dark) {
+      return {
+        ...dark,
+        parent: "@media (prefers-color-scheme: dark)"
+      };
+    }
+    const light = variantMatcher("light")(v);
+    if (light) {
+      return {
+        ...light,
+        parent: "@media (prefers-color-scheme: light)"
+      };
+    }
+  }
+];
+
+const variantImportant = {
+  match(matcher) {
+    if (matcher.startsWith("!")) {
+      return {
+        matcher: matcher.slice(1),
+        body: (body) => {
+          body.forEach((v) => {
+            if (v[1])
+              v[1] += " !important";
+          });
+          return body;
+        }
+      };
+    }
+  }
+};
+const variantNegative = {
+  match(matcher) {
+    if (matcher.startsWith("-")) {
+      return {
+        matcher: matcher.slice(1),
+        body: (body) => {
+          body.forEach((v) => {
+            if (v[0].startsWith("--un-scale") || v[1]?.toString() === "0")
+              return;
+            v[1] = v[1]?.toString().replace(/[0-9.]+(?:[a-z]+|%)?/, (i) => `-${i}`);
+          });
+          return body;
+        }
+      };
+    }
+  }
+};
+const variantSpace = (matcher) => {
+  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
+    return {
+      matcher,
+      selector: (input) => {
+        return `${input}>:not([hidden])~:not([hidden])`;
+      }
+    };
+  }
+};
+
+const variants = [
+  variantSpace,
+  variantNegative,
+  variantImportant,
+  variantBreakpoints,
+  ...variantChildren,
+  variantPseudoClasses,
+  variantPseudoElements
+];
+
+export { variantColorsMedia as a, variantColorsClass as b, variantBreakpoints as c, variantChildren as d, variantImportant as e, variantNegative as f, variantSpace as g, variants as v };

package/dist/chunks/index.cjs

@@ -0,0 +1,169 @@
+'use strict';
+
+const directionMap = {
+  "l": ["-left"],
+  "r": ["-right"],
+  "t": ["-top"],
+  "b": ["-bottom"],
+  "s": ["-inline-start"],
+  "e": ["-inline-end"],
+  "x": ["-left", "-right"],
+  "y": ["-top", "-bottom"],
+  "": [""],
+  "a": [""]
+};
+const cornerMap = {
+  "t": ["-top-left", "-top-right"],
+  "r": ["-top-right", "-bottom-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "l": ["-bottom-left", "-top-left"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""]
+};
+const xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+
+const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
+const numberRE = /^(-?[0-9.]+)$/i;
+function rem(str) {
+  if (str === "auto" || str === "a")
+    return "auto";
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num / 4}rem`;
+}
+function px(str) {
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num}px`;
+}
+function number(str) {
+  if (!numberRE.test(str))
+    return;
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return num;
+}
+function percent(str) {
+  if (str.endsWith("%"))
+    str = str.slice(0, -1);
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return `${num / 100}`;
+}
+function fraction(str) {
+  if (str === "full")
+    return "100%";
+  const [left, right] = str.split("/");
+  const num = parseFloat(left) / parseFloat(right);
+  if (!Number.isNaN(num))
+    return `${num * 100}%`;
+}
+function bracket(str) {
+  if (str && str[0] === "[" && str[str.length - 1] === "]") {
+    return str.slice(1, -1).replace(/_/g, " ").replace(/calc\((.*)/g, (v) => {
+      return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
+    });
+  }
+}
+function cssvar(str) {
+  if (str.startsWith("$"))
+    return `var(--${str.slice(1)})`;
+}
+function time(str) {
+  const duration = Number(str.replace(/(s|ms)$/, ""));
+  if (isNaN(duration))
+    return;
+  if (/ms|s$/.test(str))
+    return str;
+  return `${str}ms`;
+}
+function global(str) {
+  if (["inherit", "initial", "unset"].includes(str))
+    return str;
+}
+
+const handlers = {
+  __proto__: null,
+  rem: rem,
+  px: px,
+  number: number,
+  percent: percent,
+  fraction: fraction,
+  bracket: bracket,
+  cssvar: cssvar,
+  time: time,
+  global: global
+};
+
+const handlersNames = Object.keys(handlers);
+const handler = function(str) {
+  const s = this.__options?.sequence || [];
+  this.__options.sequence = [];
+  for (const n of s) {
+    const res = handlers[n](str);
+    if (res != null)
+      return res;
+  }
+  return void 0;
+};
+function addProcessor(that, name) {
+  if (!that.__options) {
+    that.__options = {
+      sequence: []
+    };
+  }
+  that.__options.sequence.push(name);
+  return that;
+}
+handlersNames.forEach((i) => {
+  Object.defineProperty(handler, i, {
+    enumerable: true,
+    get() {
+      return addProcessor(this, i);
+    }
+  });
+});
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+exports.bracket = bracket;
+exports.capitalize = capitalize;
+exports.cornerMap = cornerMap;
+exports.cssvar = cssvar;
+exports.directionMap = directionMap;
+exports.fraction = fraction;
+exports.global = global;
+exports.handler = handler;
+exports.handlersNames = handlersNames;
+exports.number = number;
+exports.percent = percent;
+exports.px = px;
+exports.rem = rem;
+exports.time = time;
+exports.xyzMap = xyzMap;

package/dist/chunks/index.mjs

@@ -0,0 +1,153 @@
+const directionMap = {
+  "l": ["-left"],
+  "r": ["-right"],
+  "t": ["-top"],
+  "b": ["-bottom"],
+  "s": ["-inline-start"],
+  "e": ["-inline-end"],
+  "x": ["-left", "-right"],
+  "y": ["-top", "-bottom"],
+  "": [""],
+  "a": [""]
+};
+const cornerMap = {
+  "t": ["-top-left", "-top-right"],
+  "r": ["-top-right", "-bottom-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "l": ["-bottom-left", "-top-left"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""]
+};
+const xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+
+const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
+const numberRE = /^(-?[0-9.]+)$/i;
+function rem(str) {
+  if (str === "auto" || str === "a")
+    return "auto";
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num / 4}rem`;
+}
+function px(str) {
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num}px`;
+}
+function number(str) {
+  if (!numberRE.test(str))
+    return;
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return num;
+}
+function percent(str) {
+  if (str.endsWith("%"))
+    str = str.slice(0, -1);
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return `${num / 100}`;
+}
+function fraction(str) {
+  if (str === "full")
+    return "100%";
+  const [left, right] = str.split("/");
+  const num = parseFloat(left) / parseFloat(right);
+  if (!Number.isNaN(num))
+    return `${num * 100}%`;
+}
+function bracket(str) {
+  if (str && str[0] === "[" && str[str.length - 1] === "]") {
+    return str.slice(1, -1).replace(/_/g, " ").replace(/calc\((.*)/g, (v) => {
+      return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
+    });
+  }
+}
+function cssvar(str) {
+  if (str.startsWith("$"))
+    return `var(--${str.slice(1)})`;
+}
+function time(str) {
+  const duration = Number(str.replace(/(s|ms)$/, ""));
+  if (isNaN(duration))
+    return;
+  if (/ms|s$/.test(str))
+    return str;
+  return `${str}ms`;
+}
+function global(str) {
+  if (["inherit", "initial", "unset"].includes(str))
+    return str;
+}
+
+const handlers = {
+  __proto__: null,
+  rem: rem,
+  px: px,
+  number: number,
+  percent: percent,
+  fraction: fraction,
+  bracket: bracket,
+  cssvar: cssvar,
+  time: time,
+  global: global
+};
+
+const handlersNames = Object.keys(handlers);
+const handler = function(str) {
+  const s = this.__options?.sequence || [];
+  this.__options.sequence = [];
+  for (const n of s) {
+    const res = handlers[n](str);
+    if (res != null)
+      return res;
+  }
+  return void 0;
+};
+function addProcessor(that, name) {
+  if (!that.__options) {
+    that.__options = {
+      sequence: []
+    };
+  }
+  that.__options.sequence.push(name);
+  return that;
+}
+handlersNames.forEach((i) => {
+  Object.defineProperty(handler, i, {
+    enumerable: true,
+    get() {
+      return addProcessor(this, i);
+    }
+  });
+});
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export { capitalize as a, percent as b, cornerMap as c, directionMap as d, bracket as e, fraction as f, cssvar as g, handler as h, global as i, handlersNames as j, number as n, px as p, rem as r, time as t, xyzMap as x };

package/dist/chunks/pseudo.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const core = require('@unocss/core');
+
+const CONTROL_BYPASS_PSEUDO = "$$no-pseudo";
+const PseudoClasses = Object.fromEntries([
+  "active",
+  "checked",
+  "default",
+  "empty",
+  "enabled",
+  "disabled",
+  "first-of-type",
+  ["first", "first-child"],
+  "focus-visible",
+  "focus-within",
+  "focus",
+  "hover",
+  "indeterminate",
+  "invalid",
+  "last-of-type",
+  ["last", "last-child"],
+  "link",
+  "only-child",
+  "only-of-type",
+  "optional",
+  "placeholder-shown",
+  "read-only",
+  "read-write",
+  "required",
+  "root",
+  "target",
+  "valid",
+  "visited",
+  ["even-of-type", "nth-of-type(even)"],
+  ["even", "nth-child(even)"],
+  ["odd-of-type", "nth-of-type(odd)"],
+  ["odd", "nth-child(odd)"]
+].map(core.toArray));
+const PseudoElements = [
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "selection"
+];
+const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
+const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
+const PseudoClassesNotRE = new RegExp(`^not-(${PseudoClassesStr})[:-]`);
+const PseudoClassesGroupRE = new RegExp(`^group-(${PseudoClassesStr})[:-]`);
+const PseudoClassesPeerRE = new RegExp(`^peer-(${PseudoClassesStr})[:-]`);
+const variantPseudoElements = (input) => {
+  const match = input.match(PseudoElementsRE);
+  if (match) {
+    return {
+      matcher: input.slice(match[1].length + 1),
+      selector: (s, body) => shouldAdd(body) && `${s}::${match[1]}`
+    };
+  }
+};
+function shouldAdd(entires) {
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO) || void 0;
+}
+const variantPseudoClasses = {
+  match: (input) => {
+    let match = input.match(PseudoClassesRE);
+    if (match) {
+      const pseudo = PseudoClasses[match[1]] || match[1];
+      return {
+        matcher: input.slice(match[1].length + 1),
+        selector: (s, body) => shouldAdd(body) && `${s}:${pseudo}`
+      };
+    }
+    match = input.match(PseudoClassesNotRE);
+    if (match) {
+      const pseudo = PseudoClasses[match[1]] || match[1];
+      return {
+        matcher: input.slice(match[1].length + 5),
+        selector: (s, body) => shouldAdd(body) && `${s}:not(:${pseudo})`
+      };
+    }
+    match = input.match(PseudoClassesGroupRE);
+    if (match) {
+      const pseudo = PseudoClasses[match[1]] || match[1];
+      return {
+        matcher: input.slice(match[1].length + 7),
+        selector: (s, body) => shouldAdd(body) && s.includes(".group:") ? s.replace(/\.group:/, `.group:${pseudo}:`) : `.group:${pseudo} ${s}`
+      };
+    }
+    match = input.match(PseudoClassesPeerRE);
+    if (match) {
+      const pseudo = PseudoClasses[match[1]] || match[1];
+      return {
+        matcher: input.slice(match[1].length + 6),
+        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo} ~ ${s}`
+      };
+    }
+  },
+  multiPass: true
+};
+
+exports.CONTROL_BYPASS_PSEUDO = CONTROL_BYPASS_PSEUDO;
+exports.PseudoClasses = PseudoClasses;
+exports.variantPseudoClasses = variantPseudoClasses;
+exports.variantPseudoElements = variantPseudoElements;