CPL
/
banboshi_V2
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 1 Wiki Aktywność
版博士V2.0程序
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
63 Commity
5 Gałęzie
6.2 GiB
 
 
 
 
Gałąź: TongWei-PS
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z 'TongWei-PS'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/windicss/utils/index.mjs

2131 wiersze
67 KiB
Czysty Bezpośredni odnośnik Wina Historia 

  1. /*! *****************************************************************************

  2. Copyright (c) Microsoft Corporation.

  3. 

  4. Permission to use, copy, modify, and/or distribute this software for any

  5. purpose with or without fee is hereby granted.

  6. 

  7. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH

  8. REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

  9. AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,

  10. INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM

  11. LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

  12. OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

  13. PERFORMANCE OF THIS SOFTWARE.

  14. ***************************************************************************** */

  15. /* global Reflect, Promise */

  16. 

  17. var extendStatics = function(d, b) {

  18.     extendStatics = Object.setPrototypeOf ||

  19.         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||

  20.         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };

  21.     return extendStatics(d, b);

  22. };

  23. 

  24. function __extends(d, b) {

  25.     if (typeof b !== "function" && b !== null)

  26.         throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");

  27.     extendStatics(d, b);

  28.     function __() { this.constructor = d; }

  29.     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

  30. }

  31. 

  32. var __assign = function() {

  33.     __assign = Object.assign || function __assign(t) {

  34.         for (var s, i = 1, n = arguments.length; i < n; i++) {

  35.             s = arguments[i];

  36.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];

  37.         }

  38.         return t;

  39.     };

  40.     return __assign.apply(this, arguments);

  41. };

  42. 

  43. function __spreadArray(to, from, pack) {

  44.     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {

  45.         if (ar || !(i in from)) {

  46.             if (!ar) ar = Array.prototype.slice.call(from, 0, i);

  47.             ar[i] = from[i];

  48.         }

  49.     }

  50.     return to.concat(ar || Array.prototype.slice.call(from));

  51. }

  52. 

  53. var Console = /** @class */ (function () {

  54.     function Console() {

  55.     }

  56.     Console.log = function () {

  57.         var message = [];

  58.         for (var _i = 0; _i < arguments.length; _i++) {

  59.             message[_i] = arguments[_i];

  60.         }

  61.         // eslint-disable-next-line no-console

  62.         console.log.apply(console, message);

  63.     };

  64.     Console.error = function () {

  65.         var message = [];

  66.         for (var _i = 0; _i < arguments.length; _i++) {

  67.             message[_i] = arguments[_i];

  68.         }

  69.         // eslint-disable-next-line no-console

  70.         console.error.apply(console, message);

  71.     };

  72.     Console.time = function (label) {

  73.         // eslint-disable-next-line no-console

  74.         console.time(label);

  75.     };

  76.     Console.timeEnd = function (label) {

  77.         // eslint-disable-next-line no-console

  78.         console.timeEnd(label);

  79.     };

  80.     return Console;

  81. }());

  82. function toArray(v) {

  83.     if (Array.isArray(v))

  84.         return v;

  85.     return [v];

  86. }

  87. function hash(str) {

  88.     str = str.replace(/\r/g, '');

  89.     var hash = 5381;

  90.     var i = str.length;

  91.     while (i--)

  92.         hash = ((hash << 5) - hash) ^ str.charCodeAt(i);

  93.     return (hash >>> 0).toString(36);

  94. }

  95. function type(val) {

  96.     return val === null

  97.         ? 'Null'

  98.         : val === undefined

  99.             ? 'Undefined'

  100.             : Object.prototype.toString.call(val).slice(8, -1);

  101. }

  102. function indent(code, tab) {

  103.     if (tab === void 0) { tab = 2; }

  104.     var spaces = Array(tab).fill(' ').join('');

  105.     return code

  106.         .split('\n')

  107.         .map(function (line) { return spaces + line; })

  108.         .join('\n');

  109. }

  110. function wrapit(code, start, end, tab, minify) {

  111.     if (start === void 0) { start = '{'; }

  112.     if (end === void 0) { end = '}'; }

  113.     if (tab === void 0) { tab = 2; }

  114.     if (minify === void 0) { minify = false; }

  115.     if (minify)

  116.         return "".concat(start).concat(code).concat(end);

  117.     return "".concat(start, "\n").concat(indent(code, tab), "\n").concat(end);

  118. }

  119. function isNumber(amount, start, end, type) {

  120.     if (start === void 0) { start = -Infinity; }

  121.     if (end === void 0) { end = Infinity; }

  122.     if (type === void 0) { type = 'int'; }

  123.     var isInt = /^-?\d+$/.test(amount);

  124.     if (type === 'int') {

  125.         if (!isInt)

  126.             return false;

  127.     }

  128.     else {

  129.         var isFloat = /^-?\d+\.\d+$/.test(amount);

  130.         if (!(isInt || isFloat))

  131.             return false;

  132.     }

  133.     var num = parseFloat(amount);

  134.     return num >= start && num <= end;

  135. }

  136. function isFraction(amount) {

  137.     return /^\d+\/\d+$/.test(amount);

  138. }

  139. function isSize(amount) {

  140.     return /^-?(\d+(\.\d+)?)+(rem|em|px|rpx|vh|vw|ch|ex|cm|mm|in|pt|pc)$/.test(amount);

  141. }

  142. function isSpace(str) {

  143.     return /^\s*$/.test(str);

  144. }

  145. function roundUp(num, precision) {

  146.     if (precision === void 0) { precision = 0; }

  147.     precision = Math.pow(10, precision);

  148.     return Math.round(num * precision) / precision;

  149. }

  150. function fracToPercent(amount) {

  151.     var matches = amount.match(/[^/]+/g);

  152.     if (!matches || matches.length < 2)

  153.         return;

  154.     var a = +matches[0];

  155.     var b = +matches[1];

  156.     return roundUp((a / b) * 100, 6) + '%';

  157. }

  158. function hex2RGB(hex) {

  159.     var RGB_HEX = /^#?(?:([\da-f]{3})[\da-f]?|([\da-f]{6})(?:[\da-f]{2})?)$/i;

  160.     var _a = String(hex).match(RGB_HEX) || [], short = _a[1], long = _a[2];

  161.     if (long) {

  162.         var value = Number.parseInt(long, 16);

  163.         return [value >> 16, (value >> 8) & 0xff, value & 0xff];

  164.     }

  165.     else if (short) {

  166.         return Array.from(short, function (s) { return Number.parseInt(s, 16); }).map(function (n) { return (n << 4) | n; });

  167.     }

  168. }

  169. function camelToDash(str) {

  170.     // Use exact the same regex as Post CSS

  171.     return str.replace(/([A-Z])/g, '-$1').replace(/^ms-/, '-ms-').toLowerCase();

  172. }

  173. function dashToCamel(str) {

  174.     if (!/-/.test(str))

  175.         return str;

  176.     return str.toLowerCase().replace(/-(.)/g, function (_, group) { return group.toUpperCase(); });

  177. }

  178. // eslint-disable-next-line @typescript-eslint/no-explicit-any

  179. function getNestedValue(obj, key) {

  180.     var topKey = key.match(/^[^.[]+/);

  181.     if (!topKey)

  182.         return;

  183.     var topValue = obj[topKey[0]];

  184.     if (!topValue)

  185.         return;

  186.     var index = topKey[0].length;

  187.     while (index < key.length) {

  188.         var square = key.slice(index).match(/\[[^\s\]]+?\]/);

  189.         var dot = key.slice(index).match(/\.[^.[]+$|\.[^.[]+(?=\.)/);

  190.         if ((!square && !dot) || ((square === null || square === void 0 ? void 0 : square.index) === undefined && (dot === null || dot === void 0 ? void 0 : dot.index) === undefined))

  191.             return topValue;

  192.         if (typeof topValue !== 'object')

  193.             return;

  194.         if (dot && dot.index !== undefined && ((square === null || square === void 0 ? void 0 : square.index) === undefined || dot.index < square.index)) {

  195.             var arg = dot[0].slice(1);

  196.             topValue = topValue[arg];

  197.             index += dot.index + dot[0].length;

  198.         }

  199.         else if (square && square.index !== undefined) {

  200.             var arg = square[0].slice(1, -1).trim().replace(/^['"]+|['"]+$/g, '');

  201.             topValue = topValue[arg];

  202.             index += square.index + square[0].length;

  203.         }

  204.     }

  205.     return topValue;

  206. }

  207. function negateValue(value) {

  208.     if (/(^0\w)|(^-)|(^0$)/.test(value))

  209.         return value;

  210.     return '-' + value;

  211. }

  212. function searchFrom(text, target, startIndex, endIndex) {

  213.     if (startIndex === void 0) { startIndex = 0; }

  214.     // search from partial of string

  215.     var subText = text.substring(startIndex, endIndex);

  216.     var relativeIndex = subText.search(target);

  217.     return relativeIndex === -1 ? -1 : startIndex + relativeIndex;

  218. }

  219. function connectList(a, b, append) {

  220.     if (append === void 0) { append = true; }

  221.     return append ? __spreadArray(__spreadArray([], (a !== null && a !== void 0 ? a : []), true), (b !== null && b !== void 0 ? b : []), true) : __spreadArray(__spreadArray([], (b !== null && b !== void 0 ? b : []), true), (a !== null && a !== void 0 ? a : []), true);

  222. }

  223. function toType(value, type) {

  224.     switch (type) {

  225.         case 'object':

  226.             return value && typeof value === 'object' ? value : {};

  227.         case 'string':

  228.             if (typeof value === 'string')

  229.                 return value;

  230.             break;

  231.         case 'number':

  232.             if (typeof value === 'number')

  233.                 return value;

  234.             break;

  235.     }

  236. }

  237. function deepCopy(source) {

  238.     return Array.isArray(source)

  239.         ? source.map(function (item) { return deepCopy(item); })

  240.         : source instanceof Date

  241.             ? new Date(source.getTime())

  242.             : source && typeof source === 'object'

  243.                 ? Object.getOwnPropertyNames(source).reduce(function (o, prop) {

  244.                     var descriptor = Object.getOwnPropertyDescriptor(source, prop);

  245.                     if (descriptor) {

  246.                         Object.defineProperty(o, prop, descriptor);

  247.                         if (source && typeof source === 'object') {

  248.                             o[prop] = deepCopy(source[prop]);

  249.                         }

  250.                     }

  251.                     return o;

  252.                 }, Object.create(Object.getPrototypeOf(source)))

  253.                 : source;

  254. }

  255. function isTagName(name) {

  256.     return ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embd', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'svg', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr'].includes(name);

  257. }

  258. function flatColors(colors, head) {

  259.     var flatten = {};

  260.     for (var _i = 0, _a = Object.entries(colors); _i < _a.length; _i++) {

  261.         var _b = _a[_i], key = _b[0], value = _b[1];

  262.         if (typeof value === 'string' || typeof value === 'function') {

  263.             flatten[(head && key === 'DEFAULT') ? head : head ? "".concat(head, "-").concat(key) : key] = value;

  264.         }

  265.         else {

  266.             flatten = __assign(__assign({}, flatten), flatColors(value, head ? "".concat(head, "-").concat(key) : key));

  267.         }

  268.     }

  269.     return flatten;

  270. }

  271. function testRegexr(text, expressions) {

  272.     for (var _i = 0, expressions_1 = expressions; _i < expressions_1.length; _i++) {

  273.         var exp = expressions_1[_i];

  274.         if (exp.test(text))

  275.             return true;

  276.     }

  277.     return false;

  278. }

  279. function searchPropEnd(text, startIndex) {

  280.     if (startIndex === void 0) { startIndex = 0; }

  281.     var index = startIndex;

  282.     var output = -1;

  283.     var openSingleQuote = false;

  284.     var openDoubleQuote = false;

  285.     var openBracket = false;

  286.     var isEscaped = false;

  287.     while (index < text.length) {

  288.         switch (text.charAt(index)) {

  289.             case '\\':

  290.                 isEscaped = !isEscaped;

  291.                 break;

  292.             case '\'':

  293.                 if (!openDoubleQuote && !openBracket && !isEscaped)

  294.                     openSingleQuote = !openSingleQuote;

  295.                 isEscaped = false;

  296.                 break;

  297.             case '"':

  298.                 if (!openSingleQuote && !openBracket && !isEscaped)

  299.                     openDoubleQuote = !openDoubleQuote;

  300.                 isEscaped = false;

  301.                 break;

  302.             case '(':

  303.                 if (!openBracket && !openSingleQuote && !openDoubleQuote && !isEscaped)

  304.                     openBracket = true;

  305.                 isEscaped = false;

  306.                 break;

  307.             case ')':

  308.                 if (openBracket && !isEscaped)

  309.                     openBracket = false;

  310.                 isEscaped = false;

  311.                 break;

  312.             case ';':

  313.                 if (!isEscaped && !openSingleQuote && !openDoubleQuote && !openBracket)

  314.                     output = index;

  315.                 isEscaped = false;

  316.                 break;

  317.             default:

  318.                 isEscaped = false;

  319.                 break;

  320.         }

  321.         if (output !== -1)

  322.             break;

  323.         index++;

  324.     }

  325.     return output;

  326. }

  327. function searchNotEscape(text, chars) {

  328.     if (chars === void 0) { chars = ['{']; }

  329.     if (!Array.isArray(chars))

  330.         chars = [chars];

  331.     var i = 0;

  332.     while (i < text.length) {

  333.         if (chars.includes(text.charAt(i)) && text.charAt(i - 1) !== '\\') {

  334.             return i;

  335.         }

  336.         i++;

  337.     }

  338.     return -1;

  339. }

  340. function splitSelectors(selectors) {

  341.     var splitted = [];

  342.     var parens = 0;

  343.     var angulars = 0;

  344.     var soFar = '';

  345.     for (var i = 0, len = selectors.length; i < len; i++) {

  346.         var char = selectors[i];

  347.         if (char === '(') {

  348.             parens += 1;

  349.         }

  350.         else if (char === ')') {

  351.             parens -= 1;

  352.         }

  353.         else if (char === '[') {

  354.             angulars += 1;

  355.         }

  356.         else if (char === ']') {

  357.             angulars -= 1;

  358.         }

  359.         else if (char === ',') {

  360.             if (!parens && !angulars) {

  361.                 splitted.push(soFar.trim());

  362.                 soFar = '';

  363.                 continue;

  364.             }

  365.         }

  366.         soFar += char;

  367.     }

  368.     splitted.push(soFar.trim());

  369.     return splitted;

  370. }

  371. function guessClassName(selector) {

  372.     var _a;

  373.     if (selector.indexOf(',') >= 0) {

  374.         var splittedSelectors = splitSelectors(selector);

  375.         if (splittedSelectors.length !== 1)

  376.             return splittedSelectors.map(function (i) { return guessClassName(i); });

  377.     }

  378.     // not classes, contains attribute selectors, nested selectors - treat as static

  379.     if (selector.charAt(0) !== '.' || searchNotEscape(selector, ['[', '>', '+', '~']) >= 0 || selector.trim().indexOf(' ') >= 0 || searchNotEscape(selector.slice(1), '.') >= 0)

  380.         return { selector: selector, isClass: false };

  381.     var pseudo = searchNotEscape(selector, ':');

  382.     var className = (((_a = selector.match(/^\.([\w-]|(\\\W))+/)) === null || _a === void 0 ? void 0 : _a[0].slice(1)) || '').replace(/\\/g, '');

  383.     if (pseudo === -1)

  384.         return { selector: className, isClass: true };

  385.     return { selector: className, isClass: true, pseudo: selector.slice(pseudo) };

  386. }

  387. function increaseWithUnit(target, delta) {

  388.     var _a;

  389.     if (typeof target === 'number')

  390.         return target + delta;

  391.     var value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) === null || _a === void 0 ? void 0 : _a[0]) || '';

  392.     var unit = target.slice(value.length);

  393.     var result = (parseFloat(value) + delta);

  394.     if (Number.isNaN(result))

  395.         return target;

  396.     return result + unit;

  397. }

  398. function splitColorGroup(color) {

  399.     var sep = color.indexOf('/');

  400.     if (sep === -1)

  401.         return [color, undefined];

  402.     return [color.slice(0, sep), color.slice(sep + 1)];

  403. }

  404. 

  405. var Property = /** @class */ (function () {

  406.     function Property(name, value, comment, important) {

  407.         if (important === void 0) { important = false; }

  408.         this.meta = { type: 'utilities', group: 'plugin', order: 0, offset: 0, corePlugin: false };

  409.         this.name = name;

  410.         this.value = value;

  411.         this.comment = comment;

  412.         this.important = important;

  413.     }

  414.     Property._singleParse = function (css) {

  415.         css = css.trim();

  416.         if (!css)

  417.             return;

  418.         if (css.charAt(0) === '@')

  419.             return InlineAtRule.parse(css);

  420.         var split = css.search(':');

  421.         var end = searchPropEnd(css);

  422.         if (split === -1)

  423.             return;

  424.         var important = false;

  425.         var prop = css.substring(split + 1, end === -1 ? undefined : end).trim();

  426.         if (/!important;?$/.test(prop)) {

  427.             important = true;

  428.             prop = prop.replace(/!important/, '').trimRight();

  429.         }

  430.         return new Property(css.substring(0, split).trim(), prop, undefined, important);

  431.     };

  432.     Property.parse = function (css) {

  433.         if (!/;\s*$/.test(css))

  434.             css += ';'; // Fix for the situation where the last semicolon is omitted

  435.         var properties = [];

  436.         var index = 0;

  437.         var end = searchPropEnd(css, index);

  438.         while (end !== -1) {

  439.             var parsed = this._singleParse(css.substring(searchFrom(css, /\S/, index), end + 1));

  440.             if (parsed)

  441.                 properties.push(parsed);

  442.             index = end + 1;

  443.             end = searchPropEnd(css, index);

  444.         }

  445.         var count = properties.length;

  446.         if (count > 1)

  447.             return properties;

  448.         if (count === 1)

  449.             return properties[0];

  450.     };

  451.     Property.prototype.clone = function () {

  452.         return deepCopy(this);

  453.     };

  454.     Property.prototype.toStyle = function (selector) {

  455.         var style = new Style(selector, this, this.important);

  456.         style.meta = this.meta;

  457.         return style;

  458.     };

  459.     Property.prototype.build = function (minify) {

  460.         var _this = this;

  461.         if (minify === void 0) { minify = false; }

  462.         var createProperty = function (name, value) {

  463.             if (minify) {

  464.                 return "".concat(name, ":").concat(value).concat(_this.important ? '!important' : '', ";");

  465.             }

  466.             else {

  467.                 var p = "".concat(name, ": ").concat(value).concat(_this.important ? ' !important' : '', ";");

  468.                 return _this.comment ? p + " /* ".concat(_this.comment, " */") : p;

  469.             }

  470.         };

  471.         if (!this.value)

  472.             return '';

  473.         return typeof this.name === 'string'

  474.             ? createProperty(this.name, this.value)

  475.             : this.name

  476.                 .map(function (i) { return createProperty(i, _this.value); })

  477.                 .join(minify ? '' : '\n');

  478.     };

  479.     Property.prototype.updateMeta = function (type, group, order, offset, corePlugin) {

  480.         if (offset === void 0) { offset = 0; }

  481.         if (corePlugin === void 0) { corePlugin = false; }

  482.         this.meta = {

  483.             type: type,

  484.             group: group,

  485.             order: order,

  486.             offset: offset,

  487.             corePlugin: corePlugin,

  488.         };

  489.         return this;

  490.     };

  491.     return Property;

  492. }());

  493. var InlineAtRule = /** @class */ (function (_super) {

  494.     __extends(InlineAtRule, _super);

  495.     function InlineAtRule(name, value, important) {

  496.         if (important === void 0) { important = false; }

  497.         var _this = _super.call(this, name, value, undefined, important) || this;

  498.         _this.name = name;

  499.         return _this;

  500.     }

  501.     InlineAtRule.parse = function (css) {

  502.         var _a;

  503.         var matchName = css.match(/@[^\s;{}]+/);

  504.         if (matchName) {

  505.             var name_1 = matchName[0].substring(1);

  506.             var important = false;

  507.             var expression = matchName.index !== undefined

  508.                 ? (_a = css

  509.                     .substring(matchName.index + name_1.length + 1)

  510.                     .match(/(?:(['"]).*?\1|[^;])*/)) === null || _a === void 0 ? void 0 : _a[0].trim()

  511.                 : undefined;

  512.             if (expression && /!important;?$/.test(expression)) {

  513.                 important = true;

  514.                 expression = expression.replace(/!important/, '').trimRight();

  515.             }

  516.             return new InlineAtRule(name_1, expression === '' ? undefined : expression, important);

  517.         }

  518.     };

  519.     InlineAtRule.prototype.build = function () {

  520.         return this.value

  521.             ? "@".concat(this.name, " ").concat(this.value).concat(this.important ? ' !important' : '', ";")

  522.             : "@".concat(this.name).concat(this.important ? ' !important' : '', ";");

  523.     };

  524.     return InlineAtRule;

  525. }(Property));

  526. var Style = /** @class */ (function () {

  527.     function Style(selector, property, important) {

  528.         if (important === void 0) { important = false; }

  529.         this.meta = { type: 'components', group: 'plugin', order: 0, offset: 0, corePlugin: false };

  530.         this.selector = selector;

  531.         this.important = important;

  532.         this.property = toArray(property || []);

  533.     }

  534.     Object.defineProperty(Style.prototype, "rule", {

  535.         get: function () {

  536.             var _this = this;

  537.             var _a, _b, _c;

  538.             var selectors = ((_a = this.selector) !== null && _a !== void 0 ? _a : '').trim().split(/\s*,\s*/g);

  539.             this._parentSelectors && (selectors = selectors.map(function (i) { var _a; return "".concat((_a = _this._parentSelectors) === null || _a === void 0 ? void 0 : _a.join(' '), " ").concat(i); }));

  540.             ((_b = this._wrapSelectors) !== null && _b !== void 0 ? _b : []).forEach(function (func) { return (selectors = selectors.map(function (i) { return func(i); })); });

  541.             this._pseudoClasses && (selectors = selectors.map(function (i) { var _a; return i + ":".concat((_a = _this._pseudoClasses) === null || _a === void 0 ? void 0 : _a.join(':')); }));

  542.             this._pseudoElements && (selectors = selectors.map(function (i) { var _a; return i + "::".concat((_a = _this._pseudoElements) === null || _a === void 0 ? void 0 : _a.join('::')); }));

  543.             this._brotherSelectors && (selectors = selectors.map(function (i) { var _a; return i + ".".concat((_a = _this._brotherSelectors) === null || _a === void 0 ? void 0 : _a.join('.')); }));

  544.             this._childSelectors && (selectors = selectors.map(function (i) { var _a; return i + " ".concat((_a = _this._childSelectors) === null || _a === void 0 ? void 0 : _a.join(' ')); }));

  545.             ((_c = this._wrapRules) !== null && _c !== void 0 ? _c : []).forEach(function (func) { return (selectors = selectors.map(function (i) { return func(i); })); });

  546.             return selectors.join(', ');

  547.         },

  548.         enumerable: false,

  549.         configurable: true

  550.     });

  551.     Object.defineProperty(Style.prototype, "pseudoClasses", {

  552.         get: function () {

  553.             return this._pseudoClasses;

  554.         },

  555.         enumerable: false,

  556.         configurable: true

  557.     });

  558.     Object.defineProperty(Style.prototype, "pseudoElements", {

  559.         get: function () {

  560.             return this._pseudoElements;

  561.         },

  562.         enumerable: false,

  563.         configurable: true

  564.     });

  565.     Object.defineProperty(Style.prototype, "parentSelectors", {

  566.         get: function () {

  567.             return this._parentSelectors;

  568.         },

  569.         enumerable: false,

  570.         configurable: true

  571.     });

  572.     Object.defineProperty(Style.prototype, "childSelectors", {

  573.         get: function () {

  574.             return this._childSelectors;

  575.         },

  576.         enumerable: false,

  577.         configurable: true

  578.     });

  579.     Object.defineProperty(Style.prototype, "brotherSelectors", {

  580.         get: function () {

  581.             return this._brotherSelectors;

  582.         },

  583.         enumerable: false,

  584.         configurable: true

  585.     });

  586.     Object.defineProperty(Style.prototype, "wrapProperties", {

  587.         get: function () {

  588.             return this._wrapProperties;

  589.         },

  590.         enumerable: false,

  591.         configurable: true

  592.     });

  593.     Object.defineProperty(Style.prototype, "wrapSelectors", {

  594.         get: function () {

  595.             return this._wrapSelectors;

  596.         },

  597.         enumerable: false,

  598.         configurable: true

  599.     });

  600.     Object.defineProperty(Style.prototype, "wrapRules", {

  601.         get: function () {

  602.             return this._wrapRules;

  603.         },

  604.         enumerable: false,

  605.         configurable: true

  606.     });

  607.     Object.defineProperty(Style.prototype, "simple", {

  608.         get: function () {

  609.             // is this style only has property and no wrap?

  610.             return !(this.atRules || this._pseudoClasses || this._pseudoElements || this._parentSelectors || this._childSelectors || this._brotherSelectors || this._wrapProperties || this._wrapSelectors || this._wrapRules);

  611.         },

  612.         enumerable: false,

  613.         configurable: true

  614.     });

  615.     Object.defineProperty(Style.prototype, "isAtrule", {

  616.         get: function () {

  617.             return !(this.atRules === undefined || this.atRules.length === 0);

  618.         },

  619.         enumerable: false,

  620.         configurable: true

  621.     });

  622.     Style.generate = function (parent, property, root) {

  623.         if (!root)

  624.             root = (parent === null || parent === void 0 ? void 0 : parent.startsWith('@'))

  625.                 ? new Style().atRule(parent)

  626.                 : new Style(parent);

  627.         var output = [];

  628.         var _loop_1 = function (key, value) {

  629.             var propertyValue = value;

  630.             if (Array.isArray(propertyValue) && propertyValue.every(function (e) { return typeof e === 'object'; })) {

  631.                 propertyValue = Object.assign.apply(Object, __spreadArray([{}], propertyValue, false));

  632.             }

  633.             if (typeof propertyValue === 'string') {

  634.                 root.add(new Property(camelToDash(key), propertyValue));

  635.             }

  636.             else if (Array.isArray(propertyValue)) {

  637.                 propertyValue.map(function (i) { return root === null || root === void 0 ? void 0 : root.add(new Property(camelToDash(key), i)); });

  638.             }

  639.             else {

  640.                 var wrap = deepCopy(root);

  641.                 wrap.property = [];

  642.                 var child = void 0;

  643.                 if (key.startsWith('@')) {

  644.                     child = wrap.atRule(key, false);

  645.                 }

  646.                 else {

  647.                     if (wrap.selector === undefined) {

  648.                         wrap.selector = key;

  649.                         child = wrap;

  650.                     }

  651.                     else {

  652.                         if (/^[a-z]+$/.test(key) && !isTagName(key)) {

  653.                             wrap.wrapProperty(function (property) { return "".concat(key, "-").concat(property); });

  654.                             child = wrap;

  655.                         }

  656.                         else {

  657.                             var _hKey_1 = function (selector, key) { return (/&/.test(key) ? key : "& ".concat(key)).replace('&', selector); };

  658.                             wrap.wrapSelector(function (selector) {

  659.                                 return selector

  660.                                     .trim()

  661.                                     .split(/\s*,\s*/g)

  662.                                     .map(function (s) {

  663.                                     return key

  664.                                         .split(/\s*,\s*/g)

  665.                                         .map(function (i) { return _hKey_1(s, i); })

  666.                                         .join(', ');

  667.                                 })

  668.                                     .join(', ');

  669.                             });

  670.                             child = wrap;

  671.                         }

  672.                     }

  673.                 }

  674.                 output = output.concat(Style.generate(key.startsWith('@') ? undefined : key, propertyValue, child));

  675.             }

  676.         };

  677.         for (var _i = 0, _a = Object.entries(property !== null && property !== void 0 ? property : {}); _i < _a.length; _i++) {

  678.             var _b = _a[_i], key = _b[0], value = _b[1];

  679.             _loop_1(key, value);

  680.         }

  681.         if (root.property.length > 0)

  682.             output.unshift(root);

  683.         return output;

  684.     };

  685.     Style.prototype.atRule = function (atrule, append) {

  686.         if (append === void 0) { append = true; }

  687.         if (!atrule)

  688.             return this;

  689.         if (this.atRules) {

  690.             append ? this.atRules.push(atrule) : this.atRules.unshift(atrule);

  691.         }

  692.         else {

  693.             this.atRules = [atrule];

  694.         }

  695.         return this;

  696.     };

  697.     Style.prototype.pseudoClass = function (string) {

  698.         if (this._pseudoClasses) {

  699.             this._pseudoClasses.push(string);

  700.         }

  701.         else {

  702.             this._pseudoClasses = [string];

  703.         }

  704.         return this;

  705.     };

  706.     Style.prototype.pseudoElement = function (string) {

  707.         if (this._pseudoElements) {

  708.             this._pseudoElements.push(string);

  709.         }

  710.         else {

  711.             this._pseudoElements = [string];

  712.         }

  713.         return this;

  714.     };

  715.     Style.prototype.brother = function (string) {

  716.         if (this._brotherSelectors) {

  717.             this._brotherSelectors.push(string);

  718.         }

  719.         else {

  720.             this._brotherSelectors = [string];

  721.         }

  722.         return this;

  723.     };

  724.     Style.prototype.parent = function (string) {

  725.         if (this._parentSelectors) {

  726.             this._parentSelectors.push(string);

  727.         }

  728.         else {

  729.             this._parentSelectors = [string];

  730.         }

  731.         return this;

  732.     };

  733.     Style.prototype.child = function (string) {

  734.         if (this._childSelectors) {

  735.             this._childSelectors.push(string);

  736.         }

  737.         else {

  738.             this._childSelectors = [string];

  739.         }

  740.         return this;

  741.     };

  742.     Style.prototype.wrapProperty = function (func) {

  743.         if (this._wrapProperties) {

  744.             this._wrapProperties.push(func);

  745.         }

  746.         else {

  747.             this._wrapProperties = [func];

  748.         }

  749.         return this;

  750.     };

  751.     Style.prototype.wrapSelector = function (func) {

  752.         if (this._wrapSelectors) {

  753.             this._wrapSelectors.push(func);

  754.         }

  755.         else {

  756.             this._wrapSelectors = [func];

  757.         }

  758.         return this;

  759.     };

  760.     Style.prototype.wrapRule = function (func) {

  761.         if (this._wrapRules) {

  762.             this._wrapRules.push(func);

  763.         }

  764.         else {

  765.             this._wrapRules = [func];

  766.         }

  767.         return this;

  768.     };

  769.     Style.prototype.add = function (item) {

  770.         item = toArray(item);

  771.         if (this.important)

  772.             item.forEach(function (i) { return (i.important = true); });

  773.         this.property = __spreadArray(__spreadArray([], this.property, true), item, true);

  774.         return this;

  775.     };

  776.     Style.prototype.extend = function (item, onlyProperty, append) {

  777.         if (onlyProperty === void 0) { onlyProperty = false; }

  778.         if (append === void 0) { append = true; }

  779.         if (!item)

  780.             return this;

  781.         if (item.wrapProperties) {

  782.             var props_1 = [];

  783.             item.property.forEach(function (p) {

  784.                 var _a;

  785.                 var pc = new Property(p.name, p.value, p.comment);

  786.                 (_a = item.wrapProperties) === null || _a === void 0 ? void 0 : _a.forEach(function (wrap) {

  787.                     pc.name = Array.isArray(pc.name)

  788.                         ? pc.name.map(function (i) { return wrap(i); })

  789.                         : wrap(pc.name);

  790.                 });

  791.                 if (item.important)

  792.                     pc.important = true;

  793.                 props_1.push(pc);

  794.             });

  795.             this.property = connectList(this.property, props_1, append);

  796.         }

  797.         else {

  798.             if (item.important)

  799.                 item.property.forEach(function (i) { return (i.important = true); });

  800.             this.property = connectList(this.property, item.property, append);

  801.         }

  802.         if (onlyProperty)

  803.             return this;

  804.         item.selector && (this.selector = item.selector);

  805.         this.meta = item.meta;

  806.         item.atRules &&

  807.             (this.atRules = connectList(item.atRules, this.atRules, append)); // atrule is build in reverse

  808.         item._brotherSelectors &&

  809.             (this._brotherSelectors = connectList(this._brotherSelectors, item._brotherSelectors, append));

  810.         item._childSelectors &&

  811.             (this._childSelectors = connectList(this._childSelectors, item._childSelectors, append));

  812.         item._parentSelectors &&

  813.             (this._parentSelectors = connectList(this._parentSelectors, item._parentSelectors, append));

  814.         item._pseudoClasses &&

  815.             (this._pseudoClasses = connectList(this._pseudoClasses, item._pseudoClasses, append));

  816.         item._pseudoElements &&

  817.             (this._pseudoElements = connectList(this._pseudoElements, item._pseudoElements, append));

  818.         item._wrapRules &&

  819.             (this._wrapRules = connectList(this._wrapRules, item._wrapRules, append));

  820.         item._wrapSelectors &&

  821.             (this._wrapSelectors = connectList(this._wrapSelectors, item._wrapSelectors, append));

  822.         return this;

  823.     };

  824.     Style.prototype.clean = function () {

  825.         // remove duplicated property

  826.         var property = [];

  827.         var cache = [];

  828.         this.property.forEach(function (i) {

  829.             var inline = i.build();

  830.             if (!cache.includes(inline)) {

  831.                 cache.push(inline);

  832.                 property.push(i);

  833.             }

  834.         });

  835.         this.property = property;

  836.         return this;

  837.     };

  838.     Style.prototype.flat = function () {

  839.         var properties = [];

  840.         this.property.forEach(function (p) {

  841.             if (Array.isArray(p.name)) {

  842.                 p.name.forEach(function (i) {

  843.                     properties.push(new Property(i, p.value, p.comment));

  844.                 });

  845.             }

  846.             else {

  847.                 properties.push(p);

  848.             }

  849.         });

  850.         this.property = properties;

  851.         return this;

  852.     };

  853.     Style.prototype.clone = function (selector, property) {

  854.         var newStyle = deepCopy(this);

  855.         if (selector)

  856.             newStyle.selector = selector;

  857.         if (property)

  858.             newStyle.property = Array.isArray(property) ? property : [property];

  859.         return newStyle;

  860.     };

  861.     Style.prototype.sort = function () {

  862.         // sort property

  863.         this.property = this.property.sort(function (a, b) {

  864.             return "".concat(a.name).substring(0, 2) > "".concat(b.name).substring(0, 2) ? 1 : -1;

  865.         });

  866.         return this;

  867.     };

  868.     Style.prototype.build = function (minify, prefixer) {

  869.         var _this = this;

  870.         if (minify === void 0) { minify = false; }

  871.         if (prefixer === void 0) { prefixer = true; }

  872.         var properties = this.property;

  873.         if (!prefixer)

  874.             properties = properties.filter(function (p) {

  875.                 if (p.value && /-(webkit|ms|moz|o)-/.test(p.value))

  876.                     return false;

  877.                 if (Array.isArray(p.name)) {

  878.                     p.name = p.name.filter(function (i) { return !/^-(webkit|ms|moz|o)-/.test(i); });

  879.                     return true;

  880.                 }

  881.                 return !/^-(webkit|ms|moz|o)-/.test(p.name);

  882.             });

  883.         var result = properties.map(function (p) {

  884.             if (_this._wrapProperties) {

  885.                 var name_2 = p.name;

  886.                 _this._wrapProperties.forEach(function (w) { return (name_2 = Array.isArray(name_2) ? name_2.map(function (n) { return w(n); }) : w(name_2)); });

  887.                 return new Property(name_2, p.value, p.comment, _this.important ? true : p.important).build(minify);

  888.             }

  889.             return _this.important ? new Property(p.name, p.value, p.comment, true).build(minify) : p.build(minify);

  890.         }).join(minify ? '' : '\n');

  891.         if (!this.selector && !this.atRules)

  892.             return result.replace(/;}/g, '}');

  893.         if (this.selector)

  894.             result = (minify ? this.rule.replace(/,\s/g, ',') : this.rule + ' ') + wrapit(result, undefined, undefined, undefined, result !== '' ? minify : true);

  895.         if (this.atRules) {

  896.             for (var _i = 0, _a = this.atRules; _i < _a.length; _i++) {

  897.                 var rule = _a[_i];

  898.                 result = minify ? "".concat(rule.replace(/\s/g, '')).concat(wrapit(result, undefined, undefined, undefined, minify)) : "".concat(rule, " ").concat(wrapit(result, undefined, undefined, undefined, result !== '' ? minify : true));

  899.             }

  900.         }

  901.         return minify ? result.replace(/;}/g, '}') : result;

  902.     };

  903.     Style.prototype.updateMeta = function (type, group, order, offset, corePlugin, respectSelector) {

  904.         if (offset === void 0) { offset = 0; }

  905.         if (corePlugin === void 0) { corePlugin = false; }

  906.         if (respectSelector === void 0) { respectSelector = false; }

  907.         this.meta = {

  908.             type: type,

  909.             group: group,

  910.             order: order,

  911.             offset: offset,

  912.             corePlugin: corePlugin,

  913.             respectSelector: respectSelector,

  914.         };

  915.         return this;

  916.     };

  917.     return Style;

  918. }());

  919. /** @class */ ((function (_super) {

  920.     __extends(GlobalStyle, _super);

  921.     function GlobalStyle(selector, property, important) {

  922.         return _super.call(this, selector, property, important) || this;

  923.     }

  924.     return GlobalStyle;

  925. })(Style));

  926. /** @class */ ((function (_super) {

  927.     __extends(Keyframes, _super);

  928.     function Keyframes(selector, property, important) {

  929.         return _super.call(this, selector, property, important) || this;

  930.     }

  931.     // root param only for consist with style

  932.     // eslint-disable-next-line @typescript-eslint/no-unused-vars

  933.     Keyframes.generate = function (name, children, root, prefixer) {

  934.         if (prefixer === void 0) { prefixer = true; }

  935.         var styles = [];

  936.         var webkitStyles = [];

  937.         for (var _i = 0, _a = Object.entries(children); _i < _a.length; _i++) {

  938.             var _b = _a[_i], key = _b[0], value = _b[1];

  939.             var style = new Keyframes(key).atRule("@keyframes ".concat(name));

  940.             var webkitStyle = new Keyframes(key).atRule("@-webkit-keyframes ".concat(name));

  941.             for (var _c = 0, _d = Object.entries(value); _c < _d.length; _c++) {

  942.                 var _e = _d[_c], pkey = _e[0], pvalue = _e[1];

  943.                 var prop = pkey;

  944.                 if (pkey === 'transform') {

  945.                     prop = prefixer ? ['-webkit-transform', 'transform'] : 'transform';

  946.                 }

  947.                 else if (['animationTimingFunction', 'animation-timing-function'].includes(pkey)) {

  948.                     prop = prefixer ? [

  949.                         '-webkit-animation-timing-function',

  950.                         'animation-timing-function',

  951.                     ] : 'animation-timing-function';

  952.                 }

  953.                 style.add(new Property(prop, pvalue));

  954.                 webkitStyle.add(new Property(prop, pvalue));

  955.             }

  956.             styles.push(style);

  957.             if (prefixer)

  958.                 webkitStyles.push(webkitStyle);

  959.         }

  960.         return __spreadArray(__spreadArray([], styles, true), webkitStyles, true);

  961.     };

  962.     return Keyframes;

  963. })(Style));

  964. /** @class */ ((function (_super) {

  965.     __extends(Container, _super);

  966.     function Container(selector, property, important) {

  967.         return _super.call(this, selector, property, important) || this;

  968.     }

  969.     return Container;

  970. })(Style));

  971. 

  972. function isString(value) {

  973.     return typeof value === 'string';

  974. }

  975. function negative$1(scale) {

  976.     return Object.keys(scale)

  977.         .filter(function (key) { return scale[key] !== '0'; })

  978.         .reduce(function (negativeScale, key) {

  979.         var _a;

  980.         return (__assign(__assign({}, negativeScale), (_a = {}, _a["-".concat(key)] = negateValue(scale[key]), _a)));

  981.     }, {});

  982. }

  983. function breakpoints(screens) {

  984.     if (screens === void 0) { screens = {}; }

  985.     return Object.keys(screens)

  986.         .filter(function (key) { return typeof screens[key] === 'string'; })

  987.         .reduce(function (breakpoints, key) {

  988.         var _a;

  989.         return (__assign(__assign({}, breakpoints), (_a = {}, _a["screen-".concat(key)] = screens[key], _a)));

  990.     }, {});

  991. }

  992. function generateFontSize(font) {

  993.     if (typeof font === 'string')

  994.         return [new Property('font-size', font)];

  995.     var properties = [];

  996.     if (font[0])

  997.         properties.push(new Property('font-size', font[0]));

  998.     if (typeof font[1] === 'string') {

  999.         properties.push(new Property('line-height', font[1]));

  1000.     }

  1001.     else if (font[1]) {

  1002.         if (font[1].lineHeight)

  1003.             properties.push(new Property('line-height', font[1].lineHeight));

  1004.         if (font[1].letterSpacing)

  1005.             properties.push(new Property('letter-spacing', font[1].letterSpacing));

  1006.     }

  1007.     return properties;

  1008. }

  1009. function expandDirection(value, divide) {

  1010.     if (divide === void 0) { divide = false; }

  1011.     var map = {

  1012.         '': ['*'],

  1013.         y: ['top', 'bottom'],

  1014.         x: ['left', 'right'],

  1015.         t: divide ? ['top-left', 'top-right'] : ['top'],

  1016.         r: divide ? ['top-right', 'bottom-right'] : ['right'],

  1017.         b: divide ? ['bottom-right', 'bottom-left'] : ['bottom'],

  1018.         l: divide ? ['top-left', 'bottom-left'] : ['left'],

  1019.         tl: ['top-left'],

  1020.         tr: ['top-right'],

  1021.         br: ['bottom-right'],

  1022.         bl: ['bottom-left'],

  1023.     };

  1024.     if (value in map)

  1025.         return map[value];

  1026. }

  1027. function generatePlaceholder(selector, property, prefixer) {

  1028.     if (prefixer === void 0) { prefixer = false; }

  1029.     if (!prefixer)

  1030.         return [new Style(selector, property).pseudoElement('placeholder')];

  1031.     return [

  1032.         new Style(selector, property).pseudoElement('-webkit-input-placeholder'),

  1033.         new Style(selector, property).pseudoElement('-moz-placeholder'),

  1034.         new Style(selector, property).pseudoClass('-ms-input-placeholder'),

  1035.         new Style(selector, property).pseudoElement('-ms-input-placeholder'),

  1036.         new Style(selector, property).pseudoElement('placeholder'),

  1037.     ];

  1038. }

  1039. function toDarkStyle(style, mode) {

  1040.     if (!mode)

  1041.         return style;

  1042.     if (Array.isArray(style)) {

  1043.         if (mode === 'media')

  1044.             return style.map(function (i) { return new Style().atRule('@media (prefers-color-scheme: dark)').extend(i); });

  1045.         return style.map(function (i) { return new Style().parent('.dark').extend(i); });

  1046.     }

  1047.     if (mode === 'media')

  1048.         return new Style().atRule('@media (prefers-color-scheme: dark)').extend(style);

  1049.     return new Style().parent('.dark').extend(style);

  1050. }

  1051. 

  1052. var colorString$1 = {exports: {}};

  1053. 

  1054. var colorName = {

  1055. 	"aliceblue": [240, 248, 255],

  1056. 	"antiquewhite": [250, 235, 215],

  1057. 	"aqua": [0, 255, 255],

  1058. 	"aquamarine": [127, 255, 212],

  1059. 	"azure": [240, 255, 255],

  1060. 	"beige": [245, 245, 220],

  1061. 	"bisque": [255, 228, 196],

  1062. 	"black": [0, 0, 0],

  1063. 	"blanchedalmond": [255, 235, 205],

  1064. 	"blue": [0, 0, 255],

  1065. 	"blueviolet": [138, 43, 226],

  1066. 	"brown": [165, 42, 42],

  1067. 	"burlywood": [222, 184, 135],

  1068. 	"cadetblue": [95, 158, 160],

  1069. 	"chartreuse": [127, 255, 0],

  1070. 	"chocolate": [210, 105, 30],

  1071. 	"coral": [255, 127, 80],

  1072. 	"cornflowerblue": [100, 149, 237],

  1073. 	"cornsilk": [255, 248, 220],

  1074. 	"crimson": [220, 20, 60],

  1075. 	"cyan": [0, 255, 255],

  1076. 	"darkblue": [0, 0, 139],

  1077. 	"darkcyan": [0, 139, 139],

  1078. 	"darkgoldenrod": [184, 134, 11],

  1079. 	"darkgray": [169, 169, 169],

  1080. 	"darkgreen": [0, 100, 0],

  1081. 	"darkgrey": [169, 169, 169],

  1082. 	"darkkhaki": [189, 183, 107],

  1083. 	"darkmagenta": [139, 0, 139],

  1084. 	"darkolivegreen": [85, 107, 47],

  1085. 	"darkorange": [255, 140, 0],

  1086. 	"darkorchid": [153, 50, 204],

  1087. 	"darkred": [139, 0, 0],

  1088. 	"darksalmon": [233, 150, 122],

  1089. 	"darkseagreen": [143, 188, 143],

  1090. 	"darkslateblue": [72, 61, 139],

  1091. 	"darkslategray": [47, 79, 79],

  1092. 	"darkslategrey": [47, 79, 79],

  1093. 	"darkturquoise": [0, 206, 209],

  1094. 	"darkviolet": [148, 0, 211],

  1095. 	"deeppink": [255, 20, 147],

  1096. 	"deepskyblue": [0, 191, 255],

  1097. 	"dimgray": [105, 105, 105],

  1098. 	"dimgrey": [105, 105, 105],

  1099. 	"dodgerblue": [30, 144, 255],

  1100. 	"firebrick": [178, 34, 34],

  1101. 	"floralwhite": [255, 250, 240],

  1102. 	"forestgreen": [34, 139, 34],

  1103. 	"fuchsia": [255, 0, 255],

  1104. 	"gainsboro": [220, 220, 220],

  1105. 	"ghostwhite": [248, 248, 255],

  1106. 	"gold": [255, 215, 0],

  1107. 	"goldenrod": [218, 165, 32],

  1108. 	"gray": [128, 128, 128],

  1109. 	"green": [0, 128, 0],

  1110. 	"greenyellow": [173, 255, 47],

  1111. 	"grey": [128, 128, 128],

  1112. 	"honeydew": [240, 255, 240],

  1113. 	"hotpink": [255, 105, 180],

  1114. 	"indianred": [205, 92, 92],

  1115. 	"indigo": [75, 0, 130],

  1116. 	"ivory": [255, 255, 240],

  1117. 	"khaki": [240, 230, 140],

  1118. 	"lavender": [230, 230, 250],

  1119. 	"lavenderblush": [255, 240, 245],

  1120. 	"lawngreen": [124, 252, 0],

  1121. 	"lemonchiffon": [255, 250, 205],

  1122. 	"lightblue": [173, 216, 230],

  1123. 	"lightcoral": [240, 128, 128],

  1124. 	"lightcyan": [224, 255, 255],

  1125. 	"lightgoldenrodyellow": [250, 250, 210],

  1126. 	"lightgray": [211, 211, 211],

  1127. 	"lightgreen": [144, 238, 144],

  1128. 	"lightgrey": [211, 211, 211],

  1129. 	"lightpink": [255, 182, 193],

  1130. 	"lightsalmon": [255, 160, 122],

  1131. 	"lightseagreen": [32, 178, 170],

  1132. 	"lightskyblue": [135, 206, 250],

  1133. 	"lightslategray": [119, 136, 153],

  1134. 	"lightslategrey": [119, 136, 153],

  1135. 	"lightsteelblue": [176, 196, 222],

  1136. 	"lightyellow": [255, 255, 224],

  1137. 	"lime": [0, 255, 0],

  1138. 	"limegreen": [50, 205, 50],

  1139. 	"linen": [250, 240, 230],

  1140. 	"magenta": [255, 0, 255],

  1141. 	"maroon": [128, 0, 0],

  1142. 	"mediumaquamarine": [102, 205, 170],

  1143. 	"mediumblue": [0, 0, 205],

  1144. 	"mediumorchid": [186, 85, 211],

  1145. 	"mediumpurple": [147, 112, 219],

  1146. 	"mediumseagreen": [60, 179, 113],

  1147. 	"mediumslateblue": [123, 104, 238],

  1148. 	"mediumspringgreen": [0, 250, 154],

  1149. 	"mediumturquoise": [72, 209, 204],

  1150. 	"mediumvioletred": [199, 21, 133],

  1151. 	"midnightblue": [25, 25, 112],

  1152. 	"mintcream": [245, 255, 250],

  1153. 	"mistyrose": [255, 228, 225],

  1154. 	"moccasin": [255, 228, 181],

  1155. 	"navajowhite": [255, 222, 173],

  1156. 	"navy": [0, 0, 128],

  1157. 	"oldlace": [253, 245, 230],

  1158. 	"olive": [128, 128, 0],

  1159. 	"olivedrab": [107, 142, 35],

  1160. 	"orange": [255, 165, 0],

  1161. 	"orangered": [255, 69, 0],

  1162. 	"orchid": [218, 112, 214],

  1163. 	"palegoldenrod": [238, 232, 170],

  1164. 	"palegreen": [152, 251, 152],

  1165. 	"paleturquoise": [175, 238, 238],

  1166. 	"palevioletred": [219, 112, 147],

  1167. 	"papayawhip": [255, 239, 213],

  1168. 	"peachpuff": [255, 218, 185],

  1169. 	"peru": [205, 133, 63],

  1170. 	"pink": [255, 192, 203],

  1171. 	"plum": [221, 160, 221],

  1172. 	"powderblue": [176, 224, 230],

  1173. 	"purple": [128, 0, 128],

  1174. 	"rebeccapurple": [102, 51, 153],

  1175. 	"red": [255, 0, 0],

  1176. 	"rosybrown": [188, 143, 143],

  1177. 	"royalblue": [65, 105, 225],

  1178. 	"saddlebrown": [139, 69, 19],

  1179. 	"salmon": [250, 128, 114],

  1180. 	"sandybrown": [244, 164, 96],

  1181. 	"seagreen": [46, 139, 87],

  1182. 	"seashell": [255, 245, 238],

  1183. 	"sienna": [160, 82, 45],

  1184. 	"silver": [192, 192, 192],

  1185. 	"skyblue": [135, 206, 235],

  1186. 	"slateblue": [106, 90, 205],

  1187. 	"slategray": [112, 128, 144],

  1188. 	"slategrey": [112, 128, 144],

  1189. 	"snow": [255, 250, 250],

  1190. 	"springgreen": [0, 255, 127],

  1191. 	"steelblue": [70, 130, 180],

  1192. 	"tan": [210, 180, 140],

  1193. 	"teal": [0, 128, 128],

  1194. 	"thistle": [216, 191, 216],

  1195. 	"tomato": [255, 99, 71],

  1196. 	"turquoise": [64, 224, 208],

  1197. 	"violet": [238, 130, 238],

  1198. 	"wheat": [245, 222, 179],

  1199. 	"white": [255, 255, 255],

  1200. 	"whitesmoke": [245, 245, 245],

  1201. 	"yellow": [255, 255, 0],

  1202. 	"yellowgreen": [154, 205, 50]

  1203. };

  1204. 

  1205. var simpleSwizzle = {exports: {}};

  1206. 

  1207. var isArrayish$1 = function isArrayish(obj) {

  1208. 	if (!obj || typeof obj === 'string') {

  1209. 		return false;

  1210. 	}

  1211. 

  1212. 	return obj instanceof Array || Array.isArray(obj) ||

  1213. 		(obj.length >= 0 && (obj.splice instanceof Function ||

  1214. 			(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));

  1215. };

  1216. 

  1217. var isArrayish = isArrayish$1;

  1218. 

  1219. var concat = Array.prototype.concat;

  1220. var slice = Array.prototype.slice;

  1221. 

  1222. var swizzle$1 = simpleSwizzle.exports = function swizzle(args) {

  1223. 	var results = [];

  1224. 

  1225. 	for (var i = 0, len = args.length; i < len; i++) {

  1226. 		var arg = args[i];

  1227. 

  1228. 		if (isArrayish(arg)) {

  1229. 			// http://jsperf.com/javascript-array-concat-vs-push/98

  1230. 			results = concat.call(results, slice.call(arg));

  1231. 		} else {

  1232. 			results.push(arg);

  1233. 		}

  1234. 	}

  1235. 

  1236. 	return results;

  1237. };

  1238. 

  1239. swizzle$1.wrap = function (fn) {

  1240. 	return function () {

  1241. 		return fn(swizzle$1(arguments));

  1242. 	};

  1243. };

  1244. 

  1245. /* MIT license */

  1246. 

  1247. var colorNames = colorName;

  1248. var swizzle = simpleSwizzle.exports;

  1249. var hasOwnProperty = Object.hasOwnProperty;

  1250. 

  1251. var reverseNames = {};

  1252. 

  1253. // create a list of reverse color names

  1254. for (var name in colorNames) {

  1255. 	if (hasOwnProperty.call(colorNames, name)) {

  1256. 		reverseNames[colorNames[name]] = name;

  1257. 	}

  1258. }

  1259. 

  1260. var cs = colorString$1.exports = {

  1261. 	to: {},

  1262. 	get: {}

  1263. };

  1264. 

  1265. cs.get = function (string) {

  1266. 	var prefix = string.substring(0, 3).toLowerCase();

  1267. 	var val;

  1268. 	var model;

  1269. 	switch (prefix) {

  1270. 		case 'hsl':

  1271. 			val = cs.get.hsl(string);

  1272. 			model = 'hsl';

  1273. 			break;

  1274. 		case 'hwb':

  1275. 			val = cs.get.hwb(string);

  1276. 			model = 'hwb';

  1277. 			break;

  1278. 		default:

  1279. 			val = cs.get.rgb(string);

  1280. 			model = 'rgb';

  1281. 			break;

  1282. 	}

  1283. 

  1284. 	if (!val) {

  1285. 		return null;

  1286. 	}

  1287. 

  1288. 	return {model: model, value: val};

  1289. };

  1290. 

  1291. cs.get.rgb = function (string) {

  1292. 	if (!string) {

  1293. 		return null;

  1294. 	}

  1295. 

  1296. 	var abbr = /^#([a-f0-9]{3,4})$/i;

  1297. 	var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;

  1298. 	var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;

  1299. 	var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;

  1300. 	var keyword = /^(\w+)$/;

  1301. 

  1302. 	var rgb = [0, 0, 0, 1];

  1303. 	var match;

  1304. 	var i;

  1305. 	var hexAlpha;

  1306. 

  1307. 	if (match = string.match(hex)) {

  1308. 		hexAlpha = match[2];

  1309. 		match = match[1];

  1310. 

  1311. 		for (i = 0; i < 3; i++) {

  1312. 			// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19

  1313. 			var i2 = i * 2;

  1314. 			rgb[i] = parseInt(match.slice(i2, i2 + 2), 16);

  1315. 		}

  1316. 

  1317. 		if (hexAlpha) {

  1318. 			rgb[3] = parseInt(hexAlpha, 16) / 255;

  1319. 		}

  1320. 	} else if (match = string.match(abbr)) {

  1321. 		match = match[1];

  1322. 		hexAlpha = match[3];

  1323. 

  1324. 		for (i = 0; i < 3; i++) {

  1325. 			rgb[i] = parseInt(match[i] + match[i], 16);

  1326. 		}

  1327. 

  1328. 		if (hexAlpha) {

  1329. 			rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;

  1330. 		}

  1331. 	} else if (match = string.match(rgba)) {

  1332. 		for (i = 0; i < 3; i++) {

  1333. 			rgb[i] = parseInt(match[i + 1], 0);

  1334. 		}

  1335. 

  1336. 		if (match[4]) {

  1337. 			if (match[5]) {

  1338. 				rgb[3] = parseFloat(match[4]) * 0.01;

  1339. 			} else {

  1340. 				rgb[3] = parseFloat(match[4]);

  1341. 			}

  1342. 		}

  1343. 	} else if (match = string.match(per)) {

  1344. 		for (i = 0; i < 3; i++) {

  1345. 			rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);

  1346. 		}

  1347. 

  1348. 		if (match[4]) {

  1349. 			if (match[5]) {

  1350. 				rgb[3] = parseFloat(match[4]) * 0.01;

  1351. 			} else {

  1352. 				rgb[3] = parseFloat(match[4]);

  1353. 			}

  1354. 		}

  1355. 	} else if (match = string.match(keyword)) {

  1356. 		if (match[1] === 'transparent') {

  1357. 			return [0, 0, 0, 0];

  1358. 		}

  1359. 

  1360. 		if (!hasOwnProperty.call(colorNames, match[1])) {

  1361. 			return null;

  1362. 		}

  1363. 

  1364. 		rgb = colorNames[match[1]];

  1365. 		rgb[3] = 1;

  1366. 

  1367. 		return rgb;

  1368. 	} else {

  1369. 		return null;

  1370. 	}

  1371. 

  1372. 	for (i = 0; i < 3; i++) {

  1373. 		rgb[i] = clamp(rgb[i], 0, 255);

  1374. 	}

  1375. 	rgb[3] = clamp(rgb[3], 0, 1);

  1376. 

  1377. 	return rgb;

  1378. };

  1379. 

  1380. cs.get.hsl = function (string) {

  1381. 	if (!string) {

  1382. 		return null;

  1383. 	}

  1384. 

  1385. 	var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;

  1386. 	var match = string.match(hsl);

  1387. 

  1388. 	if (match) {

  1389. 		var alpha = parseFloat(match[4]);

  1390. 		var h = ((parseFloat(match[1]) % 360) + 360) % 360;

  1391. 		var s = clamp(parseFloat(match[2]), 0, 100);

  1392. 		var l = clamp(parseFloat(match[3]), 0, 100);

  1393. 		var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);

  1394. 

  1395. 		return [h, s, l, a];

  1396. 	}

  1397. 

  1398. 	return null;

  1399. };

  1400. 

  1401. cs.get.hwb = function (string) {

  1402. 	if (!string) {

  1403. 		return null;

  1404. 	}

  1405. 

  1406. 	var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;

  1407. 	var match = string.match(hwb);

  1408. 

  1409. 	if (match) {

  1410. 		var alpha = parseFloat(match[4]);

  1411. 		var h = ((parseFloat(match[1]) % 360) + 360) % 360;

  1412. 		var w = clamp(parseFloat(match[2]), 0, 100);

  1413. 		var b = clamp(parseFloat(match[3]), 0, 100);

  1414. 		var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);

  1415. 		return [h, w, b, a];

  1416. 	}

  1417. 

  1418. 	return null;

  1419. };

  1420. 

  1421. cs.to.hex = function () {

  1422. 	var rgba = swizzle(arguments);

  1423. 

  1424. 	return (

  1425. 		'#' +

  1426. 		hexDouble(rgba[0]) +

  1427. 		hexDouble(rgba[1]) +

  1428. 		hexDouble(rgba[2]) +

  1429. 		(rgba[3] < 1

  1430. 			? (hexDouble(Math.round(rgba[3] * 255)))

  1431. 			: '')

  1432. 	);

  1433. };

  1434. 

  1435. cs.to.rgb = function () {

  1436. 	var rgba = swizzle(arguments);

  1437. 

  1438. 	return rgba.length < 4 || rgba[3] === 1

  1439. 		? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'

  1440. 		: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';

  1441. };

  1442. 

  1443. cs.to.rgb.percent = function () {

  1444. 	var rgba = swizzle(arguments);

  1445. 

  1446. 	var r = Math.round(rgba[0] / 255 * 100);

  1447. 	var g = Math.round(rgba[1] / 255 * 100);

  1448. 	var b = Math.round(rgba[2] / 255 * 100);

  1449. 

  1450. 	return rgba.length < 4 || rgba[3] === 1

  1451. 		? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'

  1452. 		: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';

  1453. };

  1454. 

  1455. cs.to.hsl = function () {

  1456. 	var hsla = swizzle(arguments);

  1457. 	return hsla.length < 4 || hsla[3] === 1

  1458. 		? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'

  1459. 		: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';

  1460. };

  1461. 

  1462. // hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax

  1463. // (hwb have alpha optional & 1 is default value)

  1464. cs.to.hwb = function () {

  1465. 	var hwba = swizzle(arguments);

  1466. 

  1467. 	var a = '';

  1468. 	if (hwba.length >= 4 && hwba[3] !== 1) {

  1469. 		a = ', ' + hwba[3];

  1470. 	}

  1471. 

  1472. 	return 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';

  1473. };

  1474. 

  1475. cs.to.keyword = function (rgb) {

  1476. 	return reverseNames[rgb.slice(0, 3)];

  1477. };

  1478. 

  1479. // helpers

  1480. function clamp(num, min, max) {

  1481. 	return Math.min(Math.max(min, num), max);

  1482. }

  1483. 

  1484. function hexDouble(num) {

  1485. 	var str = Math.round(num).toString(16).toUpperCase();

  1486. 	return (str.length < 2) ? '0' + str : str;

  1487. }

  1488. 

  1489. var colorString = colorString$1.exports;

  1490. 

  1491. function hsl2rgb(h, s, l) {

  1492.     l /= 100;

  1493.     if (h >= 360)

  1494.         h %= 360;

  1495.     var c = (1 - Math.abs(2 * l - 1)) * (s / 100);

  1496.     var x = c * (1 - Math.abs((h / 60) % 2 - 1));

  1497.     var m = l - c / 2;

  1498.     var r = 0;

  1499.     var g = 0;

  1500.     var b = 0;

  1501.     if (0 <= h && h < 60) {

  1502.         r = c + m;

  1503.         g = x + m;

  1504.         b = m;

  1505.     }

  1506.     else if (60 <= h && h < 120) {

  1507.         r = x + m;

  1508.         g = c + m;

  1509.         b = m;

  1510.     }

  1511.     else if (120 <= h && h < 180) {

  1512.         r = m;

  1513.         g = c + m;

  1514.         b = x + m;

  1515.     }

  1516.     else if (180 <= h && h < 240) {

  1517.         r = m;

  1518.         g = x + m;

  1519.         b = c + m;

  1520.     }

  1521.     else if (240 <= h && h < 300) {

  1522.         r = x + m;

  1523.         g = m;

  1524.         b = c + m;

  1525.     }

  1526.     else if (300 <= h && h < 360) {

  1527.         r = c + m;

  1528.         g = m;

  1529.         b = x + m;

  1530.     }

  1531.     return [

  1532.         Math.round(r * 255),

  1533.         Math.round(g * 255),

  1534.         Math.round(b * 255),

  1535.     ];

  1536. }

  1537. function hwb2rgb(h, w, b) {

  1538.     var rgb = hsl2rgb(h, 100, 50);

  1539.     for (var i = 0; i < 3; ++i) {

  1540.         var c = rgb[i] / 255;

  1541.         c *= 1 - w / 100 - b / 100;

  1542.         c += w / 100;

  1543.         rgb[i] = Math.round(c * 255);

  1544.     }

  1545.     return rgb;

  1546. }

  1547. function toRGBA(color) {

  1548.     var _a;

  1549.     if (/^hsla?/.test(color)) {

  1550.         var color_array = colorString.get.hsl(color);

  1551.         if (!color_array)

  1552.             return;

  1553.         return __spreadArray(__spreadArray([], hsl2rgb(color_array[0], color_array[1], color_array[2]), true), [color_array[3]], false);

  1554.     }

  1555.     else if (/^rgba?/.test(color)) {

  1556.         var color_array = colorString.get.rgb(color);

  1557.         if (!color_array)

  1558.             return;

  1559.         return color_array;

  1560.     }

  1561.     else if (color.startsWith('hwb')) {

  1562.         var color_array = colorString.get.hwb(color);

  1563.         if (!color_array)

  1564.             return;

  1565.         return __spreadArray(__spreadArray([], hwb2rgb(color_array[0], color_array[1], color_array[2]), true), [color_array[3]], false);

  1566.     }

  1567.     return (_a = colorString.get(color)) === null || _a === void 0 ? void 0 : _a.value;

  1568. }

  1569. function toRGB(color) {

  1570.     var rgba = toRGBA(color);

  1571.     if (!rgba)

  1572.         return;

  1573.     rgba.pop();

  1574.     return rgba;

  1575. }

  1576. function toColor(color_string) {

  1577.     var rgba = toRGBA(color_string);

  1578.     var color = rgba ? rgba.slice(0, 3).join(', ') : color_string;

  1579.     var opacity = rgba ? rgba[3].toString() : '1';

  1580.     return { color: color, opacity: opacity };

  1581. }

  1582. 

  1583. var utilities = {

  1584.     // Layout

  1585.     columns: [

  1586.         'columns-${static}',

  1587.         'columns-${float}',

  1588.         'columns-${size}',

  1589.         'columns-${int}xl',

  1590.     ],

  1591.     container: [

  1592.         'container',

  1593.     ],

  1594.     objectPosition: [

  1595.         'object-${static}',

  1596.     ],

  1597.     inset: [

  1598.         'inset-${static}',

  1599.         'inset-${float}',

  1600.         'inset-${fraction}',

  1601.         'inset-${size}',

  1602.         'inset-y-${static}',

  1603.         'inset-y-${float}',

  1604.         'inset-y-${fraction}',

  1605.         'inset-y-${size}',

  1606.         'inset-x-${static}',

  1607.         'inset-x-${float}',

  1608.         'inset-x-${fraction}',

  1609.         'inset-x-${size}',

  1610.         'top-${static}',

  1611.         'top-${float}',

  1612.         'top-${fraction}',

  1613.         'top-${size}',

  1614.         'right-${static}',

  1615.         'right-${float}',

  1616.         'right-${fraction}',

  1617.         'right-${size}',

  1618.         'bottom-${static}',

  1619.         'bottom-${float}',

  1620.         'bottom-${fraction}',

  1621.         'bottom-${size}',

  1622.         'left-${static}',

  1623.         'left-${float}',

  1624.         'left-${fraction}',

  1625.         'left-${size}',

  1626.     ],

  1627.     zIndex: [

  1628.         'z-${static}',

  1629.         'z-${int}',

  1630.     ],

  1631.     // Flexbox

  1632.     flex: [

  1633.         'flex-${static}',

  1634.     ],

  1635.     flexGrow: [

  1636.         'flex-grow-${static}',

  1637.     ],

  1638.     flexShrink: [

  1639.         'flex-shrink-${static}',

  1640.     ],

  1641.     order: [

  1642.         'order-${static}',

  1643.         'order-${int}',

  1644.     ],

  1645.     // Grid

  1646.     gridTemplateColumns: [

  1647.         'grid-cols-${static}',

  1648.         'grid-cols-${int}',

  1649.     ],

  1650.     gridTemplateRows: [

  1651.         'grid-rows-${static}',

  1652.         'grid-rows-${int}',

  1653.     ],

  1654.     gridColumn: [

  1655.         'col-${static}',

  1656.         'col-span-${int}',

  1657.     ],

  1658.     gridColumnEnd: [

  1659.         'col-end-${static}',

  1660.         'col-end-${int}',

  1661.     ],

  1662.     gridColumnStart: [

  1663.         'col-start-${static}',

  1664.         'col-start-${int}',

  1665.     ],

  1666.     gridRow: [

  1667.         'row-${static}',

  1668.         'row-span-${int}',

  1669.     ],

  1670.     gridRowEnd: [

  1671.         'row-end-${static}',

  1672.         'row-end-${int}',

  1673.     ],

  1674.     gridRowStart: [

  1675.         'row-start-${static}',

  1676.         'row-start-${int}',

  1677.     ],

  1678.     gap: [

  1679.         'gap-${static}',

  1680.         'gap-x-${static}',

  1681.         'gap-y-${static}',

  1682.         'gap-${float}',

  1683.         'gap-x-${float}',

  1684.         'gap-y-${float}',

  1685.         'gap-${size}',

  1686.         'gap-x-${size}',

  1687.         'gap-y-${size}',

  1688.     ],

  1689.     // Box Alignment

  1690.     // Spacing

  1691.     padding: [

  1692.         'p-${static}',

  1693.         'py-${static}',

  1694.         'px-${static}',

  1695.         'pt-${static}',

  1696.         'pr-${static}',

  1697.         'pb-${static}',

  1698.         'pl-${static}',

  1699.         'p-${float}',

  1700.         'py-${float}',

  1701.         'px-${float}',

  1702.         'pt-${float}',

  1703.         'pr-${float}',

  1704.         'pb-${float}',

  1705.         'pl-${float}',

  1706.         'p-${size}',

  1707.         'py-${size}',

  1708.         'px-${size}',

  1709.         'pt-${size}',

  1710.         'pr-${size}',

  1711.         'pb-${size}',

  1712.         'pl-${size}',

  1713.     ],

  1714.     margin: [

  1715.         'm-${static}',

  1716.         'my-${static}',

  1717.         'mx-${static}',

  1718.         'mt-${static}',

  1719.         'mr-${static}',

  1720.         'mb-${static}',

  1721.         'ml-${static}',

  1722.         'm-${float}',

  1723.         'my-${float}',

  1724.         'mx-${float}',

  1725.         'mt-${float}',

  1726.         'mr-${float}',

  1727.         'mb-${float}',

  1728.         'ml-${float}',

  1729.         'm-${size}',

  1730.         'my-${size}',

  1731.         'mx-${size}',

  1732.         'mt-${size}',

  1733.         'mr-${size}',

  1734.         'mb-${size}',

  1735.         'ml-${size}',

  1736.     ],

  1737.     space: [

  1738.         'space-y-${static}',

  1739.         'space-y-reverse',

  1740.         'space-x-${static}',

  1741.         'space-x-reverse',

  1742.         'space-y-${float}',

  1743.         'space-x-${float}',

  1744.     ],

  1745.     width: [

  1746.         'w-${static}',

  1747.         'w-${float}',

  1748.         'w-${fraction}',

  1749.         'w-${int}xl',

  1750.         'w-${size}',

  1751.     ],

  1752.     minWidth: [

  1753.         'min-w-${static}',

  1754.         'min-w-${float}',

  1755.         'min-w-${fraction}',

  1756.         'min-w-${int}xl',

  1757.         'min-w-${size}',

  1758.     ],

  1759.     maxWidth: [

  1760.         'max-w-${static}',

  1761.         'max-w-${float}',

  1762.         'max-w-${fraction}',

  1763.         'max-w-${int}xl',

  1764.         'max-w-${size}',

  1765.     ],

  1766.     height: [

  1767.         'h-${static}',

  1768.         'h-${float}',

  1769.         'h-${fraction}',

  1770.         'h-${int}xl',

  1771.         'h-${size}',

  1772.     ],

  1773.     minHeight: [

  1774.         'min-h-${static}',

  1775.         'min-h-${float}',

  1776.         'min-h-${fraction}',

  1777.         'min-h-${int}xl',

  1778.         'min-h-${size}',

  1779.     ],

  1780.     maxHeight: [

  1781.         'max-h-${static}',

  1782.         'max-h-${float}',

  1783.         'max-h-${fraction}',

  1784.         'max-h-${int}xl',

  1785.         'max-h-${size}',

  1786.     ],

  1787.     // Typography

  1788.     fontSize: [

  1789.         'text-${static}',

  1790.         'text-${int}xl',

  1791.     ],

  1792.     textOpacity: [

  1793.         'text-opacity-${static}',

  1794.         'text-opacity-${int<=100}',

  1795.     ],

  1796.     textColor: [

  1797.         'text-${color}',

  1798.     ],

  1799.     fontFamily: [

  1800.         'font-${static}',

  1801.     ],

  1802.     fontWeight: [

  1803.         'font-${static}',

  1804.         'font-${int}',

  1805.     ],

  1806.     letterSpacing: [

  1807.         'tracking-${static}',

  1808.         'tracking-${size}',

  1809.     ],

  1810.     lineHeight: [

  1811.         'leading-${static}',

  1812.         'leading-${int}',

  1813.         'leading-${size}',

  1814.     ],

  1815.     listStyleType: [

  1816.         'list-${static}',

  1817.     ],

  1818.     placeholderColor: [

  1819.         'placeholder-${color}',

  1820.     ],

  1821.     placeholderOpacity: [

  1822.         'placeholder-opacity-${static}',

  1823.         'placeholder-opacity-${int<=100}',

  1824.     ],

  1825.     // Backgrounds

  1826.     backgroundColor: [

  1827.         'bg-${color}',

  1828.     ],

  1829.     backgroundOpacity: [

  1830.         'bg-opacity-${static}',

  1831.         'bg-opacity-${int<=100}',

  1832.     ],

  1833.     backgroundPosition: [

  1834.         'bg-${static}',

  1835.     ],

  1836.     backgroundSize: [

  1837.         'bg-${static}',

  1838.     ],

  1839.     backgroundImage: [

  1840.         'bg-${static}',

  1841.     ],

  1842.     gradientColorStops: [

  1843.         'from-${color}',

  1844.         'via-${color}',

  1845.         'to-${color}',

  1846.     ],

  1847.     // Borders

  1848.     borderRadius: [

  1849.         'rounded-${static}',

  1850.         'rounded-t-${static}',

  1851.         'rounded-l-${static}',

  1852.         'rounded-r-${static}',

  1853.         'rounded-b-${static}',

  1854.         'rounded-tl-${static}',

  1855.         'rounded-tr-${static}',

  1856.         'rounded-br-${static}',

  1857.         'rounded-bl-${static}',

  1858.         'rounded-${int}xl',

  1859.         'rounded-${size}',

  1860.         'rounded-t-${int}xl',

  1861.         'rounded-t-${size}',

  1862.         'rounded-l-${int}xl',

  1863.         'rounded-l-${size}',

  1864.         'rounded-r-${int}xl',

  1865.         'rounded-r-${size}',

  1866.         'rounded-b-${int}xl',

  1867.         'rounded-b-${size}',

  1868.         'rounded-tl-${int}xl',

  1869.         'rounded-tl-${size}',

  1870.         'rounded-tr-${int}xl',

  1871.         'rounded-tr-${size}',

  1872.         'rounded-br-${int}xl',

  1873.         'rounded-br-${size}',

  1874.         'rounded-bl-${int}xl',

  1875.         'rounded-bl-${size}',

  1876.     ],

  1877.     borderWidth: [

  1878.         'border-${static}',

  1879.         'border-${int}',

  1880.         'border-${size}',

  1881.         'border-t-${int}',

  1882.         'border-t-${size}',

  1883.         'border-r-${int}',

  1884.         'border-r-${size}',

  1885.         'border-b-${int}',

  1886.         'border-b-${size}',

  1887.         'border-l-${int}',

  1888.         'border-l-${size}',

  1889.         'border-x-${int}',

  1890.         'border-x-${size}',

  1891.         'border-y-${int}',

  1892.         'border-y-${size}',

  1893.     ],

  1894.     borderColor: [

  1895.         'border-${color}',

  1896.     ],

  1897.     borderOpacity: [

  1898.         'border-opacity-${static}',

  1899.         'border-opacity-${int<=100}',

  1900.     ],

  1901.     divideWidth: [

  1902.         'divide-y-reverse',

  1903.         'divide-x-reverse',

  1904.         'divide-y-${int}',

  1905.         'divide-x-${int}',

  1906.     ],

  1907.     divideColor: [

  1908.         'divide-${color}',

  1909.     ],

  1910.     divideOpacity: [

  1911.         'divide-${static}',

  1912.         'divide-opacity-${int<=100}',

  1913.     ],

  1914.     ringOffsetWidth: [

  1915.         'ring-offset-${static}',

  1916.         'ring-offset-${int}',

  1917.     ],

  1918.     ringOffsetColor: [

  1919.         'ring-offset-${color}',

  1920.     ],

  1921.     ringWidth: [

  1922.         'ring-${static}',

  1923.         'ring-${int}',

  1924.     ],

  1925.     ringColor: [

  1926.         'ring-${color}',

  1927.     ],

  1928.     ringOpacity: [

  1929.         'ring-${static}',

  1930.         'ring-opacity-${int<=100}',

  1931.     ],

  1932.     // Effects

  1933.     boxShadow: [

  1934.         'shadow-${static}',

  1935.     ],

  1936.     opacity: [

  1937.         'opacity-${static}',

  1938.         'opacity-${int<=100}',

  1939.     ],

  1940.     transition: [

  1941.         'transition-${static}',

  1942.     ],

  1943.     transitionDuration: [

  1944.         'duration-${static}',

  1945.         'duration-${int}',

  1946.     ],

  1947.     transitionTimingFunction: [

  1948.         'ease-${static}',

  1949.     ],

  1950.     transitionDelay: [

  1951.         'delay-${static}',

  1952.         'delay-${int}',

  1953.     ],

  1954.     animation: [

  1955.         'animate-${static}',

  1956.     ],

  1957.     // Transforms

  1958.     transformOrigin: [

  1959.         'origin-${static}',

  1960.     ],

  1961.     scale: [

  1962.         'scale-${static}',

  1963.         'scale-${int}',

  1964.         'scale-x-${static}',

  1965.         'scale-x-${int}',

  1966.         'scale-y-${static}',

  1967.         'scale-y-${int}',

  1968.     ],

  1969.     rotate: [

  1970.         'rotate-${static}',

  1971.         'rotate-${float}',

  1972.     ],

  1973.     translate: [

  1974.         'translate-${static}',

  1975.         'translate-x-${static}',

  1976.         'translate-y-${static}',

  1977.         'translate-x-${float}',

  1978.         'translate-x-${fraction}',

  1979.         'translate-x-${size}',

  1980.         'translate-y-${float}',

  1981.         'translate-y-${fraction}',

  1982.         'translate-y-${size}',

  1983.     ],

  1984.     skew: [

  1985.         'skew-x-${static}',

  1986.         'skew-x-${float}',

  1987.         'skew-y-${static}',

  1988.         'skew-y-${float}',

  1989.     ],

  1990.     cursor: [

  1991.         'cursor-${static}',

  1992.     ],

  1993.     // Interactivity

  1994.     outline: [

  1995.         'outline-${static}',

  1996.         'outline-${color}',

  1997.     ],

  1998.     // SVG

  1999.     fill: [

  2000.         'fill-${color}',

  2001.     ],

  2002.     // Stroke

  2003.     stroke: [

  2004.         'stroke-${color}',

  2005.     ],

  2006.     strokeWidth: [

  2007.         'stroke-${int}',

  2008.     ],

  2009.     // Plugins

  2010.     typography: [

  2011.         'prose-sm',

  2012.         'prose',

  2013.         'prose-lg',

  2014.         'prose-xl',

  2015.         'prose-2xl',

  2016.         'prose-red',

  2017.         'prose-yellow',

  2018.         'prose-green',

  2019.         'prose-blue',

  2020.         'prose-indigo',

  2021.         'prose-purple',

  2022.         'prose-pink',

  2023.     ],

  2024.     aspectRatio: [

  2025.         'aspect-none',

  2026.         'aspect-auto',

  2027.         'aspect-square',

  2028.         'aspect-video',

  2029.         'aspect-w-${float}',

  2030.         'aspect-h-${float}',

  2031.         'aspect-${fraction}',

  2032.     ],

  2033.     lineClamp: [

  2034.         'line-clamp-none',

  2035.         'line-clamp-${int}',

  2036.     ],

  2037.     filter: [

  2038.         'filter-${static}',

  2039.     ],

  2040.     backdropFilter: [

  2041.         'backdrop-${static}',

  2042.     ],

  2043.     basis: [

  2044.         'basis-${static}',

  2045.         'basis-${float}',

  2046.         'basis-${size}',

  2047.         'basis-${fraction}',

  2048.     ],

  2049.     blur: [

  2050.         'blur-${static}',

  2051.         'blur-${float}',

  2052.         'blur-${size}',

  2053.     ],

  2054.     willChange: [

  2055.         'will-change-auto',

  2056.         'will-change-scroll',

  2057.         'will-change-contents',

  2058.         'will-change-transform',

  2059.     ],

  2060.     touchAction: [

  2061.         'touch-auto',

  2062.         'touch-none',

  2063.         'touch-pan-x',

  2064.         'touch-pan-left',

  2065.         'touch-pan-right',

  2066.         'touch-pan-y',

  2067.         'touch-pan-up',

  2068.         'touch-pan-down',

  2069.         'touch-pinch-zoom',

  2070.         'touch-manipulation',

  2071.     ],

  2072.     scrollBehavior: [

  2073.         'scroll-auto',

  2074.         'scroll-smooth',

  2075.     ],

  2076.     shadow: [

  2077.         'shadow-${static}',

  2078.     ],

  2079. };

  2080. var negative = {

  2081.     inset: true,

  2082.     zIndex: true,

  2083.     order: true,

  2084.     margin: true,

  2085.     space: true,

  2086.     letterSpacing: true,

  2087.     rotate: true,

  2088.     translate: true,

  2089.     skew: true,

  2090. };

  2091. function generateCompletions(processor) {

  2092.     var completions = { static: [], color: [], dynamic: [] };

  2093.     var colors = flatColors(processor.theme('colors'));

  2094.     var _loop_1 = function (config, list) {

  2095.         list.forEach(function (utility) {

  2096.             var mark = utility.search(/\$/);

  2097.             if (mark === -1) {

  2098.                 completions.static.push(utility);

  2099.             }

  2100.             else {

  2101.                 var prefix_1 = utility.slice(0, mark - 1);

  2102.                 var suffix = utility.slice(mark);

  2103.                 switch (suffix) {

  2104.                     case '${static}':

  2105.                         completions.static = completions.static.concat(Object.keys(processor.theme(config, {})).map(function (i) { return i === 'DEFAULT' ? prefix_1 : i.charAt(0) === '-' ? "-".concat(prefix_1).concat(i) : "".concat(prefix_1, "-").concat(i); }));

  2106.                         break;

  2107.                     case '${color}':

  2108.                         for (var _i = 0, _a = Object.keys(flatColors(processor.theme(config, colors))); _i < _a.length; _i++) {

  2109.                             var key = _a[_i];

  2110.                             if (key !== 'DEFAULT')

  2111.                                 completions.color.push("".concat(prefix_1, "-").concat(key));

  2112.                         }

  2113.                         break;

  2114.                     default:

  2115.                         completions.dynamic.push(utility);

  2116.                         if (config in negative)

  2117.                             completions.dynamic.push("-".concat(utility));

  2118.                         break;

  2119.                 }

  2120.             }

  2121.         });

  2122.     };

  2123.     for (var _i = 0, _a = Object.entries(utilities); _i < _a.length; _i++) {

  2124.         var _b = _a[_i], config = _b[0], list = _b[1];

  2125.         _loop_1(config, list);

  2126.     }

  2127.     return completions;

  2128. }

  2129. 

  2130. export { Console, breakpoints, camelToDash, connectList, dashToCamel, deepCopy, expandDirection, flatColors, fracToPercent, generateCompletions, generateFontSize, generatePlaceholder, getNestedValue, guessClassName, hash, hex2RGB, hsl2rgb, hwb2rgb, increaseWithUnit, indent, isFraction, isNumber, isSize, isSpace, isString, isTagName, negateValue, negative$1 as negative, roundUp, searchFrom, searchNotEscape, searchPropEnd, splitColorGroup, splitSelectors, testRegexr, toArray, toColor, toDarkStyle, toRGB, toRGBA, toType, type, wrapit };