@unocss/preset-mini 0.48.5 → 0.49.1

package/dist/shared/{preset-mini.89cb41ec.cjs → preset-mini.6f1356df.cjs}

@@ -1,16 +1,16 @@
 'use strict';
 
-const colors = require('./preset-mini.e54ce13d.cjs');
+const colors = require('./preset-mini.65179802.cjs');
 const core = require('@unocss/core');
-const variants$1 = require('./preset-mini.28b1d01c.cjs');
+const variants$1 = require('./preset-mini.77e00c7b.cjs');
 
 const variantAria = {
   name: "aria",
-  match(matcher, { theme }) {
-    const variant = variants$1.variantGetParameter("aria-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("aria-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
-      const aria = colors.handler.bracket(match) ?? theme.aria?.[match] ?? "";
+      const aria = colors.handler.bracket(match) ?? ctx.theme.aria?.[match] ?? "";
       if (aria) {
         return {
           matcher: rest,
@@ -21,74 +21,77 @@ const variantAria = {
   }
 };
 
-const regexCache = {};
 const calcMaxWidthBySize = (size) => {
   const value = size.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
   const unit = size.slice(value.length);
   const maxWidth = parseFloat(value) - 0.1;
   return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
 };
-const variantBreakpoints = {
-  name: "breakpoints",
-  match(matcher, context) {
-    const variantEntries = Object.entries(colors.resolveBreakpoints(context) ?? {}).map(([point, size], idx) => [point, size, idx]);
-    for (const [point, size, idx] of variantEntries) {
-      if (!regexCache[point])
-        regexCache[point] = new RegExp(`^((?:[al]t-)?${point}[:-])`);
-      const match = matcher.match(regexCache[point]);
-      if (!match)
-        continue;
-      const [, pre] = match;
-      const m = matcher.slice(pre.length);
-      if (m === "container")
-        continue;
-      const isLtPrefix = pre.startsWith("lt-");
-      const isAtPrefix = pre.startsWith("at-");
-      let order = 1e3;
-      if (isLtPrefix) {
-        order -= idx + 1;
-        return {
-          matcher: m,
-          handle: (input, next) => next({
-            ...input,
-            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (max-width: ${calcMaxWidthBySize(size)})`,
-            parentOrder: order
-          })
-        };
-      }
-      order += idx + 1;
-      if (isAtPrefix && idx < variantEntries.length - 1) {
+const variantBreakpoints = () => {
+  const regexCache = {};
+  return {
+    name: "breakpoints",
+    match(matcher, context) {
+      const variantEntries = Object.entries(colors.resolveBreakpoints(context) ?? {}).map(([point, size], idx) => [point, size, idx]);
+      for (const [point, size, idx] of variantEntries) {
+        if (!regexCache[point])
+          regexCache[point] = new RegExp(`^((?:[al]t-)?${point}(?:${context.generator.config.separators.join("|")}))`);
+        const match = matcher.match(regexCache[point]);
+        if (!match)
+          continue;
+        const [, pre] = match;
+        const m = matcher.slice(pre.length);
+        if (m === "container")
+          continue;
+        const isLtPrefix = pre.startsWith("lt-");
+        const isAtPrefix = pre.startsWith("at-");
+        let order = 1e3;
+        if (isLtPrefix) {
+          order -= idx + 1;
+          return {
+            matcher: m,
+            handle: (input, next) => next({
+              ...input,
+              parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (max-width: ${calcMaxWidthBySize(size)})`,
+              parentOrder: order
+            })
+          };
+        }
+        order += idx + 1;
+        if (isAtPrefix && idx < variantEntries.length - 1) {
+          return {
+            matcher: m,
+            handle: (input, next) => next({
+              ...input,
+              parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size}) and (max-width: ${calcMaxWidthBySize(variantEntries[idx + 1][1])})`,
+              parentOrder: order
+            })
+          };
+        }
         return {
           matcher: m,
           handle: (input, next) => next({
             ...input,
-            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size}) and (max-width: ${calcMaxWidthBySize(variantEntries[idx + 1][1])})`,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size})`,
             parentOrder: order
           })
         };
       }
-      return {
-        matcher: m,
-        handle: (input, next) => next({
-          ...input,
-          parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size})`,
-          parentOrder: order
-        })
-      };
-    }
-  },
-  multiPass: true,
-  autocomplete: "(at-|lt-|)$breakpoints:"
+    },
+    multiPass: true,
+    autocomplete: "(at-|lt-|)$breakpoints:"
+  };
 };
 
 const scopeMatcher = (name, combinator) => ({
   name: `combinator:${name}`,
-  match(matcher) {
+  match(matcher, ctx) {
     if (!matcher.startsWith(name))
       return;
-    let body = variants$1.variantGetBracket(`${name}-`, matcher, [":", "-"]);
+    const separators = ctx.generator.config.separators;
+    let body = variants$1.variantGetBracket(`${name}-`, matcher, separators);
     if (!body) {
-      for (const separator of [":", "-"]) {
+      for (const separator of separators) {
         if (matcher.startsWith(`${name}${separator}`)) {
           body = ["", matcher.slice(name.length + separator.length)];
           break;
@@ -117,10 +120,10 @@ const variantCombinators = [
 
 const variantContainerQuery = {
   name: "@",
-  match(matcher, { theme }) {
+  match(matcher, ctx) {
     if (matcher.startsWith("@container"))
       return;
-    const variant = variants$1.variantGetParameter("@", matcher, [":", "-"]);
+    const variant = variants$1.variantGetParameter("@", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest, label] = variant;
       const unbracket = colors.handler.bracket(match);
@@ -130,7 +133,7 @@ const variantContainerQuery = {
         if (minWidth)
           container = `(min-width: ${minWidth})`;
       } else {
-        container = theme.containers?.[match] ?? "";
+        container = ctx.theme.containers?.[match] ?? "";
       }
       if (container) {
         core.warnOnce("The container query variant is experimental and may not follow semver.");
@@ -149,11 +152,11 @@ const variantContainerQuery = {
 
 const variantDataAttribute = {
   name: "data",
-  match(matcher, { theme }) {
-    const variant = variants$1.variantGetParameter("data-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("data-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
-      const dataAttribute = colors.handler.bracket(match) ?? theme.data?.[match] ?? "";
+      const dataAttribute = colors.handler.bracket(match) ?? ctx.theme.data?.[match] ?? "";
       if (dataAttribute) {
         return {
           matcher: rest,
@@ -167,13 +170,13 @@ const variantDataAttribute = {
 const variantPrint = variants$1.variantParentMatcher("print", "@media print");
 const variantCustomMedia = {
   name: "media",
-  match(matcher, { theme }) {
-    const variant = variants$1.variantGetParameter("media-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("media-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       let media = colors.handler.bracket(match) ?? "";
       if (media === "")
-        media = theme.media?.[match] ?? "";
+        media = ctx.theme.media?.[match] ?? "";
       if (media) {
         return {
           matcher: rest,
@@ -190,13 +193,13 @@ const variantCustomMedia = {
 
 const variantSupports = {
   name: "supports",
-  match(matcher, { theme }) {
-    const variant = variants$1.variantGetParameter("supports-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("supports-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       let supports = colors.handler.bracket(match) ?? "";
       if (supports === "")
-        supports = theme.supports?.[match] ?? "";
+        supports = ctx.theme.supports?.[match] ?? "";
       if (supports) {
         return {
           matcher: rest,
@@ -232,8 +235,8 @@ const variantLanguageDirections = [
 
 const variantSelector = {
   name: "selector",
-  match(matcher) {
-    const variant = variants$1.variantGetBracket("selector-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetBracket("selector-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       const selector = colors.handler.bracket(match);
@@ -248,8 +251,8 @@ const variantSelector = {
 };
 const variantCssLayer = {
   name: "layer",
-  match(matcher) {
-    const variant = variants$1.variantGetParameter("layer-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("layer-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       const layer = colors.handler.bracket(match) ?? match;
@@ -267,8 +270,8 @@ const variantCssLayer = {
 };
 const variantInternalLayer = {
   name: "uno-layer",
-  match(matcher) {
-    const variant = variants$1.variantGetParameter("uno-layer-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetParameter("uno-layer-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       const layer = colors.handler.bracket(match) ?? match;
@@ -283,8 +286,8 @@ const variantInternalLayer = {
 };
 const variantScope = {
   name: "scope",
-  match(matcher) {
-    const variant = variants$1.variantGetBracket("scope-", matcher, [":", "-"]);
+  match(matcher, ctx) {
+    const variant = variants$1.variantGetBracket("scope-", matcher, ctx.generator.config.separators);
     if (variant) {
       const [match, rest] = variant;
       const scope = colors.handler.bracket(match);
@@ -299,14 +302,14 @@ const variantScope = {
 };
 const variantVariables = {
   name: "variables",
-  match(matcher) {
+  match(matcher, ctx) {
     if (!matcher.startsWith("["))
       return;
     const [match, rest] = colors.getBracket(matcher, "[", "]") ?? [];
     if (!(match && rest))
       return;
     let newMatcher;
-    for (const separator of [":", "-"]) {
+    for (const separator of ctx.generator.config.separators) {
       if (rest.startsWith(separator)) {
         newMatcher = rest.slice(separator.length);
         break;
@@ -382,28 +385,33 @@ const variantNegative = {
   }
 };
 
-const variantImportant = {
-  name: "important",
-  match(matcher) {
-    let base;
-    const match = matcher.match(/^(important[:-]|!)/);
-    if (match)
-      base = matcher.slice(match[0].length);
-    else if (matcher.endsWith("!"))
-      base = matcher.slice(0, -1);
-    if (base) {
-      return {
-        matcher: base,
-        body: (body) => {
-          body.forEach((v) => {
-            if (v[1])
-              v[1] += " !important";
-          });
-          return body;
-        }
-      };
+const variantImportant = () => {
+  let re;
+  return {
+    name: "important",
+    match(matcher, ctx) {
+      if (!re)
+        re = new RegExp(`^(important(?:${ctx.generator.config.separators.join("|")})|!)`);
+      let base;
+      const match = matcher.match(re);
+      if (match)
+        base = matcher.slice(match[0].length);
+      else if (matcher.endsWith("!"))
+        base = matcher.slice(0, -1);
+      if (base) {
+        return {
+          matcher: base,
+          body: (body) => {
+            body.forEach((v) => {
+              if (v[1])
+                v[1] += " !important";
+            });
+            return body;
+          }
+        };
+      }
     }
-  }
+  };
 };
 
 const PseudoClasses = Object.fromEntries([
@@ -471,8 +479,9 @@ const sortValue = (pseudo) => {
 };
 const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   const rawRE = new RegExp(`^(${core.escapeRegExp(parent)}:)(\\S+)${core.escapeRegExp(combinator)}\\1`);
-  const pseudoRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))(?:(/\\w+))?[:-]`);
-  const pseudoColonRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))(?:(/\\w+))?[:]`);
+  let splitRE;
+  let pseudoRE;
+  let pseudoColonRE;
   const matchBracket = (input) => {
     const body = variants$1.variantGetBracket(`${tag}-`, input, []);
     if (!body)
@@ -481,7 +490,7 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
     const bracketValue = colors.handler.bracket(match);
     if (bracketValue == null)
       return;
-    const label = rest.split(/[:-]/, 1)?.[0] ?? "";
+    const label = rest.split(splitRE, 1)?.[0] ?? "";
     const prefix = `${parent}${core.escapeSelector(label)}`;
     return [
       label,
@@ -507,7 +516,12 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   };
   return {
     name: `pseudo:${tag}`,
-    match(input) {
+    match(input, ctx) {
+      if (!(splitRE && pseudoRE && pseudoColonRE)) {
+        splitRE = new RegExp(`(?:${ctx.generator.config.separators.join("|")})`);
+        pseudoRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))(?:(/\\w+))?(?:${ctx.generator.config.separators.join("|")})`);
+        pseudoColonRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))(?:(/\\w+))?(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
       if (!input.startsWith(tag))
         return;
       const result = matchBracket(input) || matchPseudo(input);
@@ -530,50 +544,62 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 };
 const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).join("|");
 const PseudoClassesAndElementsColonStr = Object.entries(PseudoClassesColon).map(([key]) => key).join("|");
-const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})[:-]`);
-const PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})[:]`);
-const variantPseudoClassesAndElements = {
-  name: "pseudo",
-  match(input) {
-    const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
-    if (match) {
-      const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
-      return {
-        matcher: input.slice(match[0].length),
-        handle: (input2, next) => {
-          const selectors = pseudo.startsWith("::") ? {
-            pseudo: `${input2.pseudo}${pseudo}`
-          } : {
-            selector: `${input2.selector}${pseudo}`
-          };
-          return next({
-            ...input2,
-            ...selectors,
-            sort: sortValue(match[1])
-          });
-        }
-      };
-    }
-  },
-  multiPass: true,
-  autocomplete: `(${PseudoClassesAndElementsStr}):`
+const variantPseudoClassesAndElements = () => {
+  let PseudoClassesAndElementsRE;
+  let PseudoClassesAndElementsColonRE;
+  return {
+    name: "pseudo",
+    match(input, ctx) {
+      if (!(PseudoClassesAndElementsRE && PseudoClassesAndElementsRE)) {
+        PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})(?:${ctx.generator.config.separators.join("|")})`);
+        PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
+      const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
+      if (match) {
+        const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
+        return {
+          matcher: input.slice(match[0].length),
+          handle: (input2, next) => {
+            const selectors = pseudo.startsWith("::") ? {
+              pseudo: `${input2.pseudo}${pseudo}`
+            } : {
+              selector: `${input2.selector}${pseudo}`
+            };
+            return next({
+              ...input2,
+              ...selectors,
+              sort: sortValue(match[1])
+            });
+          }
+        };
+      }
+    },
+    multiPass: true,
+    autocomplete: `(${PseudoClassesAndElementsStr}|${PseudoClassesAndElementsColonStr}):`
+  };
 };
-const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
-const PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})[:]`);
-const variantPseudoClassFunctions = {
-  match(input) {
-    const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE);
-    if (match) {
-      const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || PseudoClassesColon[match[2]] || `:${match[2]}`;
-      return {
-        matcher: input.slice(match[0].length),
-        selector: (s) => `${s}:${fn}(${pseudo})`
-      };
-    }
-  },
-  multiPass: true,
-  autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}|${PseudoClassesColonStr}):`
+const variantPseudoClassFunctions = () => {
+  let PseudoClassFunctionsRE;
+  let PseudoClassColonFunctionsRE;
+  return {
+    match(input, ctx) {
+      if (!(PseudoClassFunctionsRE && PseudoClassColonFunctionsRE)) {
+        PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})(?:${ctx.generator.config.separators.join("|")})`);
+        PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
+      const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE);
+      if (match) {
+        const fn = match[1];
+        const pseudo = PseudoClasses[match[2]] || PseudoClassesColon[match[2]] || `:${match[2]}`;
+        return {
+          matcher: input.slice(match[0].length),
+          selector: (s) => `${s}:${fn}(${pseudo})`
+        };
+      }
+    },
+    multiPass: true,
+    autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}|${PseudoClassesColonStr}):`
+  };
 };
 const variantTaggedPseudoClasses = (options = {}) => {
   const attributify = !!options?.attributifyPseudo;
@@ -606,14 +632,14 @@ const variants = (options) => [
   variantSelector,
   variantInternalLayer,
   variantNegative,
-  variantImportant,
+  variantImportant(),
   variantSupports,
   variantPrint,
   variantCustomMedia,
-  variantBreakpoints,
+  variantBreakpoints(),
   ...variantCombinators,
-  variantPseudoClassesAndElements,
-  variantPseudoClassFunctions,
+  variantPseudoClassesAndElements(),
+  variantPseudoClassFunctions(),
   ...variantTaggedPseudoClasses(options),
   partClasses,
   ...variantColorsMediaOrClass(options),

package/dist/shared/{preset-mini.0a36abfc.mjs → preset-mini.708f19ca.mjs}

@@ -1,6 +1,6 @@
 import { c as colors } from './preset-mini.65ac75be.mjs';
-import { P as transformBase, Q as boxShadowsBase, R as ringBase } from './preset-mini.a6daaf18.mjs';
-import './preset-mini.ca595ab5.mjs';
+import { P as transformBase, Q as boxShadowsBase, R as ringBase } from './preset-mini.8c7d231d.mjs';
+import './preset-mini.d9489281.mjs';
 import '@unocss/core';
 
 const fontFamily = {

package/dist/shared/{preset-mini.435805c5.cjs → preset-mini.70cd3126.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-const decoration = require('./preset-mini.8953ff1a.cjs');
-const colors = require('./preset-mini.e54ce13d.cjs');
+const decoration = require('./preset-mini.5d6b20c4.cjs');
+const colors = require('./preset-mini.65179802.cjs');
 const core = require('@unocss/core');
 
 const opacity = [
@@ -214,7 +214,7 @@ const cssVariables = [
   }]
 ];
 const cssProperty = [
-  [/^\[(--(\w|\\\W)+|[\w-]+):(.+)\]$/, ([match, prop, , value]) => {
+  [/^\[(--(\w|\\\W)+|[\w-]+):([^:].*)\]$/, ([match, prop, , value]) => {
     if (!isURI(match.slice(1, -1)))
       return { [prop]: colors.handler.bracket(`[${value}]`) };
   }]

package/dist/shared/{preset-mini.28b1d01c.cjs → preset-mini.77e00c7b.cjs}

@@ -1,13 +1,15 @@
 'use strict';
 
 const core = require('@unocss/core');
-const colors = require('./preset-mini.e54ce13d.cjs');
+const colors = require('./preset-mini.65179802.cjs');
 
 const variantMatcher = (name, handler) => {
-  const re = new RegExp(`^${core.escapeRegExp(name)}[:-]`);
+  let re;
   return {
     name,
-    match(input) {
+    match(input, ctx) {
+      if (!re)
+        re = new RegExp(`^${core.escapeRegExp(name)}(?:${ctx.generator.config.separators.join("|")})`);
       const match = input.match(re);
       if (match) {
         return {
@@ -23,10 +25,12 @@ const variantMatcher = (name, handler) => {
   };
 };
 const variantParentMatcher = (name, parent) => {
-  const re = new RegExp(`^${core.escapeRegExp(name)}[:-]`);
+  let re;
   return {
     name,
-    match(input) {
+    match(input, ctx) {
+      if (!re)
+        re = new RegExp(`^${core.escapeRegExp(name)}(?:${ctx.generator.config.separators.join("|")})`);
       const match = input.match(re);
       if (match) {
         return {

package/dist/shared/{preset-mini.bd4c0c0c.mjs → preset-mini.816a9399.mjs}

@@ -1,11 +1,13 @@
 import { escapeRegExp } from '@unocss/core';
-import { q as getBracket } from './preset-mini.ca595ab5.mjs';
+import { q as getBracket } from './preset-mini.d9489281.mjs';
 
 const variantMatcher = (name, handler) => {
-  const re = new RegExp(`^${escapeRegExp(name)}[:-]`);
+  let re;
   return {
     name,
-    match(input) {
+    match(input, ctx) {
+      if (!re)
+        re = new RegExp(`^${escapeRegExp(name)}(?:${ctx.generator.config.separators.join("|")})`);
       const match = input.match(re);
       if (match) {
         return {
@@ -21,10 +23,12 @@ const variantMatcher = (name, handler) => {
   };
 };
 const variantParentMatcher = (name, parent) => {
-  const re = new RegExp(`^${escapeRegExp(name)}[:-]`);
+  let re;
   return {
     name,
-    match(input) {
+    match(input, ctx) {
+      if (!re)
+        re = new RegExp(`^${escapeRegExp(name)}(?:${ctx.generator.config.separators.join("|")})`);
       const match = input.match(re);
       if (match) {
         return {

package/dist/shared/{preset-mini.a6daaf18.mjs → preset-mini.8c7d231d.mjs}

@@ -1,4 +1,4 @@
-import { g as globalKeywords, h as handler, c as colorResolver, d as directionMap, a as hasParseableColor, b as cornerMap, p as parseColor, e as colorToString, f as colorOpacityToString, m as makeGlobalStaticRules, s as splitShorthand, i as colorableShadows, j as insetMap, k as positionMap, x as xyzMap } from './preset-mini.ca595ab5.mjs';
+import { g as globalKeywords, h as handler, c as colorResolver, d as directionMap, a as hasParseableColor, b as cornerMap, p as parseColor, e as colorToString, f as colorOpacityToString, m as makeGlobalStaticRules, s as splitShorthand, i as colorableShadows, j as insetMap, k as positionMap, x as xyzMap } from './preset-mini.d9489281.mjs';
 import { toArray } from '@unocss/core';
 
 const verticalAlignAlias = {
@@ -69,9 +69,9 @@ const borders = [
   [/^(?:border|b)-(block|inline)-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
   [/^(?:border|b)-([bi][se])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
   [/^(?:border-|b-)?(?:rounded|rd)()(?:-(.+))?$/, handlerRounded, { autocomplete: ["(border|b)-(rounded|rd)", "(border|b)-(rounded|rd)-<num>", "(rounded|rd)", "(rounded|rd)-<num>"] }],
-  [/^(?:border-|b-)?(?:rounded|rd)-([rltb])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-|b-)?(?:rounded|rd)-([rltbse])(?:-(.+))?$/, handlerRounded],
   [/^(?:border-|b-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-|b-)?(?:rounded|rd)-([bi][se])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-|b-)?(?:rounded|rd)-([bise][se])(?:-(.+))?$/, handlerRounded],
   [/^(?:border-|b-)?(?:rounded|rd)-([bi][se]-[bi][se])(?:-(.+))?$/, handlerRounded],
   [/^(?:border|b)-(?:style-)?()(.+)$/, handlerBorderStyle, { autocomplete: ["(border|b)-style", `(border|b)-(${borderStyles.join("|")})`, "(border|b)-<directions>-style", `(border|b)-<directions>-(${borderStyles.join("|")})`, `(border|b)-<directions>-style-(${borderStyles.join("|")})`, `(border|b)-style-(${borderStyles.join("|")})`] }],
   [/^(?:border|b)-([xy])-(?:style-)?(.+)$/, handlerBorderStyle],
@@ -141,7 +141,7 @@ function handlerBorderStyle([, a = "", s]) {
 
 const transitionPropertyGroup = {
   all: "all",
-  colors: ["color", "background-color", "border-color", "text-decoration-color", "fill", "stroke"].join(","),
+  colors: ["color", "background-color", "border-color", "outline-color", "text-decoration-color", "fill", "stroke"].join(","),
   none: "none",
   opacity: "opacity",
   shadow: "box-shadow",
@@ -405,6 +405,7 @@ const insets = [
       ]
     }
   ],
+  [/^(?:position-|pos-)?(start|end)-(.+)$/, handleInsetValues],
   [/^(?:position-|pos-)?inset-([xy])-(.+)$/, handleInsetValues],
   [/^(?:position-|pos-)?inset-([rltbse])-(.+)$/, handleInsetValues],
   [/^(?:position-|pos-)?inset-(block|inline)-(.+)$/, handleInsetValues],