ash/printer-notifications
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: docker compose maybe

Browse Source
This commit is contained in:
Ashley Flanagan
2023-11-13 16:10:04 -05:00
parent 180b261e40
commit b625ccd8d6
8031 changed files with 2182966 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
node_modules/tailwindcss/lib/util/applyImportantSelector.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "applyImportantSelector", {
enumerable: true,
get: function() {
return applyImportantSelector;
}
});
const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
const _pseudoElements = require("./pseudoElements");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function applyImportantSelector(selector, important) {
let sel = (0, _postcssselectorparser.default)().astSync(selector);
sel.each((sel)=>{
// Wrap with :is if it's not already wrapped
let isWrapped = sel.nodes[0].type === "pseudo" && sel.nodes[0].value === ":is" && sel.nodes.every((node)=>node.type !== "combinator");
if (!isWrapped) {
sel.nodes = [
_postcssselectorparser.default.pseudo({
value: ":is",
nodes: [
sel.clone()
]
})
];
}
(0, _pseudoElements.movePseudos)(sel);
});
return `${important} ${sel.toString()}`;
}

13
node_modules/tailwindcss/lib/util/bigSign.js generated vendored Normal file
View File

@ -0,0 +1,13 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return bigSign;
}
});
function bigSign(bigIntValue) {
return (bigIntValue > 0n) - (bigIntValue < 0n);
}

27
node_modules/tailwindcss/lib/util/buildMediaQuery.js generated vendored Normal file
View File

@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return buildMediaQuery;
}
});
function buildMediaQuery(screens) {
screens = Array.isArray(screens) ? screens : [
screens
];
return screens.map((screen)=>{
let values = screen.values.map((screen)=>{
if (screen.raw !== undefined) {
return screen.raw;
}
return [
screen.min && `(min-width: ${screen.min})`,
screen.max && `(max-width: ${screen.max})`
].filter(Boolean).join(" and ");
});
return screen.not ? `not all and ${values}` : values;
}).join(", ");
}

22
node_modules/tailwindcss/lib/util/cloneDeep.js generated vendored Normal file
View File

@ -0,0 +1,22 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "cloneDeep", {
enumerable: true,
get: function() {
return cloneDeep;
}
});
function cloneDeep(value) {
if (Array.isArray(value)) {
return value.map((child)=>cloneDeep(child));
}
if (typeof value === "object" && value !== null) {
return Object.fromEntries(Object.entries(value).map(([k, v])=>[
k,
cloneDeep(v)
]));
}
return value;
}

34
node_modules/tailwindcss/lib/util/cloneNodes.js generated vendored Normal file
View File

@ -0,0 +1,34 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return cloneNodes;
}
});
function cloneNodes(nodes, source = undefined, raws = undefined) {
return nodes.map((node)=>{
var _node_raws_tailwind;
let cloned = node.clone();
// We always want override the source map
// except when explicitly told not to
let shouldOverwriteSource = ((_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.preserveSource) !== true || !cloned.source;
if (source !== undefined && shouldOverwriteSource) {
cloned.source = source;
if ("walk" in cloned) {
cloned.walk((child)=>{
child.source = source;
});
}
}
if (raws !== undefined) {
cloned.raws.tailwind = {
...cloned.raws.tailwind,
...raws
};
}
return cloned;
});
}

116
node_modules/tailwindcss/lib/util/color.js generated vendored Normal file
View File

@ -0,0 +1,116 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
parseColor: function() {
return parseColor;
},
formatColor: function() {
return formatColor;
}
});
const _colorNames = /*#__PURE__*/ _interop_require_default(require("./colorNames"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let HEX = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i;
let SHORT_HEX = /^#([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i;
let VALUE = /(?:\d+|\d*\.\d+)%?/;
let SEP = /(?:\s*,\s*|\s+)/;
let ALPHA_SEP = /\s*[,/]\s*/;
let CUSTOM_PROPERTY = /var\(--(?:[^ )]*?)(?:,(?:[^ )]*?|var\(--[^ )]*?\)))?\)/;
let RGB = new RegExp(`^(rgba?)\\(\\s*(${VALUE.source}|${CUSTOM_PROPERTY.source})(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${ALPHA_SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?\\s*\\)$`);
let HSL = new RegExp(`^(hsla?)\\(\\s*((?:${VALUE.source})(?:deg|rad|grad|turn)?|${CUSTOM_PROPERTY.source})(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?(?:${ALPHA_SEP.source}(${VALUE.source}|${CUSTOM_PROPERTY.source}))?\\s*\\)$`);
function parseColor(value, { loose =false } = {}) {
var _match_, _match__toString;
if (typeof value !== "string") {
return null;
}
value = value.trim();
if (value === "transparent") {
return {
mode: "rgb",
color: [
"0",
"0",
"0"
],
alpha: "0"
};
}
if (value in _colorNames.default) {
return {
mode: "rgb",
color: _colorNames.default[value].map((v)=>v.toString())
};
}
let hex = value.replace(SHORT_HEX, (_, r, g, b, a)=>[
"#",
r,
r,
g,
g,
b,
b,
a ? a + a : ""
].join("")).match(HEX);
if (hex !== null) {
return {
mode: "rgb",
color: [
parseInt(hex[1], 16),
parseInt(hex[2], 16),
parseInt(hex[3], 16)
].map((v)=>v.toString()),
alpha: hex[4] ? (parseInt(hex[4], 16) / 255).toString() : undefined
};
}
var _value_match;
let match = (_value_match = value.match(RGB)) !== null && _value_match !== void 0 ? _value_match : value.match(HSL);
if (match === null) {
return null;
}
let color = [
match[2],
match[3],
match[4]
].filter(Boolean).map((v)=>v.toString());
// rgba(var(--my-color), 0.1)
// hsla(var(--my-color), 0.1)
if (color.length === 2 && color[0].startsWith("var(")) {
return {
mode: match[1],
color: [
color[0]
],
alpha: color[1]
};
}
if (!loose && color.length !== 3) {
return null;
}
if (color.length < 3 && !color.some((part)=>/^var\(.*?\)$/.test(part))) {
return null;
}
return {
mode: match[1],
color,
alpha: (_match_ = match[5]) === null || _match_ === void 0 ? void 0 : (_match__toString = _match_.toString) === null || _match__toString === void 0 ? void 0 : _match__toString.call(_match_)
};
}
function formatColor({ mode , color , alpha }) {
let hasAlpha = alpha !== undefined;
if (mode === "rgba" || mode === "hsla") {
return `${mode}(${color.join(", ")}${hasAlpha ? `, ${alpha}` : ""})`;
}
return `${mode}(${color.join(" ")}${hasAlpha ? ` / ${alpha}` : ""})`;
}

752
node_modules/tailwindcss/lib/util/colorNames.js generated vendored Normal file
View File

@ -0,0 +1,752 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
const _default = {
aliceblue: [
240,
248,
255
],
antiquewhite: [
250,
235,
215
],
aqua: [
0,
255,
255
],
aquamarine: [
127,
255,
212
],
azure: [
240,
255,
255
],
beige: [
245,
245,
220
],
bisque: [
255,
228,
196
],
black: [
0,
0,
0
],
blanchedalmond: [
255,
235,
205
],
blue: [
0,
0,
255
],
blueviolet: [
138,
43,
226
],
brown: [
165,
42,
42
],
burlywood: [
222,
184,
135
],
cadetblue: [
95,
158,
160
],
chartreuse: [
127,
255,
0
],
chocolate: [
210,
105,
30
],
coral: [
255,
127,
80
],
cornflowerblue: [
100,
149,
237
],
cornsilk: [
255,
248,
220
],
crimson: [
220,
20,
60
],
cyan: [
0,
255,
255
],
darkblue: [
0,
0,
139
],
darkcyan: [
0,
139,
139
],
darkgoldenrod: [
184,
134,
11
],
darkgray: [
169,
169,
169
],
darkgreen: [
0,
100,
0
],
darkgrey: [
169,
169,
169
],
darkkhaki: [
189,
183,
107
],
darkmagenta: [
139,
0,
139
],
darkolivegreen: [
85,
107,
47
],
darkorange: [
255,
140,
0
],
darkorchid: [
153,
50,
204
],
darkred: [
139,
0,
0
],
darksalmon: [
233,
150,
122
],
darkseagreen: [
143,
188,
143
],
darkslateblue: [
72,
61,
139
],
darkslategray: [
47,
79,
79
],
darkslategrey: [
47,
79,
79
],
darkturquoise: [
0,
206,
209
],
darkviolet: [
148,
0,
211
],
deeppink: [
255,
20,
147
],
deepskyblue: [
0,
191,
255
],
dimgray: [
105,
105,
105
],
dimgrey: [
105,
105,
105
],
dodgerblue: [
30,
144,
255
],
firebrick: [
178,
34,
34
],
floralwhite: [
255,
250,
240
],
forestgreen: [
34,
139,
34
],
fuchsia: [
255,
0,
255
],
gainsboro: [
220,
220,
220
],
ghostwhite: [
248,
248,
255
],
gold: [
255,
215,
0
],
goldenrod: [
218,
165,
32
],
gray: [
128,
128,
128
],
green: [
0,
128,
0
],
greenyellow: [
173,
255,
47
],
grey: [
128,
128,
128
],
honeydew: [
240,
255,
240
],
hotpink: [
255,
105,
180
],
indianred: [
205,
92,
92
],
indigo: [
75,
0,
130
],
ivory: [
255,
255,
240
],
khaki: [
240,
230,
140
],
lavender: [
230,
230,
250
],
lavenderblush: [
255,
240,
245
],
lawngreen: [
124,
252,
0
],
lemonchiffon: [
255,
250,
205
],
lightblue: [
173,
216,
230
],
lightcoral: [
240,
128,
128
],
lightcyan: [
224,
255,
255
],
lightgoldenrodyellow: [
250,
250,
210
],
lightgray: [
211,
211,
211
],
lightgreen: [
144,
238,
144
],
lightgrey: [
211,
211,
211
],
lightpink: [
255,
182,
193
],
lightsalmon: [
255,
160,
122
],
lightseagreen: [
32,
178,
170
],
lightskyblue: [
135,
206,
250
],
lightslategray: [
119,
136,
153
],
lightslategrey: [
119,
136,
153
],
lightsteelblue: [
176,
196,
222
],
lightyellow: [
255,
255,
224
],
lime: [
0,
255,
0
],
limegreen: [
50,
205,
50
],
linen: [
250,
240,
230
],
magenta: [
255,
0,
255
],
maroon: [
128,
0,
0
],
mediumaquamarine: [
102,
205,
170
],
mediumblue: [
0,
0,
205
],
mediumorchid: [
186,
85,
211
],
mediumpurple: [
147,
112,
219
],
mediumseagreen: [
60,
179,
113
],
mediumslateblue: [
123,
104,
238
],
mediumspringgreen: [
0,
250,
154
],
mediumturquoise: [
72,
209,
204
],
mediumvioletred: [
199,
21,
133
],
midnightblue: [
25,
25,
112
],
mintcream: [
245,
255,
250
],
mistyrose: [
255,
228,
225
],
moccasin: [
255,
228,
181
],
navajowhite: [
255,
222,
173
],
navy: [
0,
0,
128
],
oldlace: [
253,
245,
230
],
olive: [
128,
128,
0
],
olivedrab: [
107,
142,
35
],
orange: [
255,
165,
0
],
orangered: [
255,
69,
0
],
orchid: [
218,
112,
214
],
palegoldenrod: [
238,
232,
170
],
palegreen: [
152,
251,
152
],
paleturquoise: [
175,
238,
238
],
palevioletred: [
219,
112,
147
],
papayawhip: [
255,
239,
213
],
peachpuff: [
255,
218,
185
],
peru: [
205,
133,
63
],
pink: [
255,
192,
203
],
plum: [
221,
160,
221
],
powderblue: [
176,
224,
230
],
purple: [
128,
0,
128
],
rebeccapurple: [
102,
51,
153
],
red: [
255,
0,
0
],
rosybrown: [
188,
143,
143
],
royalblue: [
65,
105,
225
],
saddlebrown: [
139,
69,
19
],
salmon: [
250,
128,
114
],
sandybrown: [
244,
164,
96
],
seagreen: [
46,
139,
87
],
seashell: [
255,
245,
238
],
sienna: [
160,
82,
45
],
silver: [
192,
192,
192
],
skyblue: [
135,
206,
235
],
slateblue: [
106,
90,
205
],
slategray: [
112,
128,
144
],
slategrey: [
112,
128,
144
],
snow: [
255,
250,
250
],
springgreen: [
0,
255,
127
],
steelblue: [
70,
130,
180
],
tan: [
210,
180,
140
],
teal: [
0,
128,
128
],
thistle: [
216,
191,
216
],
tomato: [
255,
99,
71
],
turquoise: [
64,
224,
208
],
violet: [
238,
130,
238
],
wheat: [
245,
222,
179
],
white: [
255,
255,
255
],
whitesmoke: [
245,
245,
245
],
yellow: [
255,
255,
0
],
yellowgreen: [
154,
205,
50
]
};

23
node_modules/tailwindcss/lib/util/configurePlugins.js generated vendored Normal file
View File

@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
function _default(pluginConfig, plugins) {
if (pluginConfig === undefined) {
return plugins;
}
const pluginNames = Array.isArray(pluginConfig) ? pluginConfig : [
...new Set(plugins.filter((pluginName)=>{
return pluginConfig !== false && pluginConfig[pluginName] !== false;
}).concat(Object.keys(pluginConfig).filter((pluginName)=>{
return pluginConfig[pluginName] !== false;
})))
];
return pluginNames;
}

32
node_modules/tailwindcss/lib/util/createPlugin.js generated vendored Normal file
View File

@ -0,0 +1,32 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
function createPlugin(plugin, config) {
return {
handler: plugin,
config
};
}
createPlugin.withOptions = function(pluginFunction, configFunction = ()=>({})) {
const optionsFunction = function(options) {
return {
__options: options,
handler: pluginFunction(options),
config: configFunction(options)
};
};
optionsFunction.__isOptionsFunction = true;
// Expose plugin dependencies so that `object-hash` returns a different
// value if anything here changes, to ensure a rebuild is triggered.
optionsFunction.__pluginFunction = pluginFunction;
optionsFunction.__configFunction = configFunction;
return optionsFunction;
};
const _default = createPlugin;

53
node_modules/tailwindcss/lib/util/createUtilityPlugin.js generated vendored Normal file
View File

@ -0,0 +1,53 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return createUtilityPlugin;
}
});
const _transformThemeValue = /*#__PURE__*/ _interop_require_default(require("./transformThemeValue"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function createUtilityPlugin(themeKey, utilityVariations = [
[
themeKey,
[
themeKey
]
]
], { filterDefault =false , ...options } = {}) {
let transformValue = (0, _transformThemeValue.default)(themeKey);
return function({ matchUtilities , theme }) {
for (let utilityVariation of utilityVariations){
let group = Array.isArray(utilityVariation[0]) ? utilityVariation : [
utilityVariation
];
var _theme;
matchUtilities(group.reduce((obj, [classPrefix, properties])=>{
return Object.assign(obj, {
[classPrefix]: (value)=>{
return properties.reduce((obj, name)=>{
if (Array.isArray(name)) {
return Object.assign(obj, {
[name[0]]: name[1]
});
}
return Object.assign(obj, {
[name]: transformValue(value)
});
}, {});
}
});
}, {}), {
...options,
values: filterDefault ? Object.fromEntries(Object.entries((_theme = theme(themeKey)) !== null && _theme !== void 0 ? _theme : {}).filter(([modifier])=>modifier !== "DEFAULT")) : theme(themeKey)
});
}
};
}

404
node_modules/tailwindcss/lib/util/dataTypes.js generated vendored Normal file
View File

@ -0,0 +1,404 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
normalize: function() {
return normalize;
},
url: function() {
return url;
},
number: function() {
return number;
},
percentage: function() {
return percentage;
},
length: function() {
return length;
},
lineWidth: function() {
return lineWidth;
},
shadow: function() {
return shadow;
},
color: function() {
return color;
},
image: function() {
return image;
},
gradient: function() {
return gradient;
},
position: function() {
return position;
},
familyName: function() {
return familyName;
},
genericName: function() {
return genericName;
},
absoluteSize: function() {
return absoluteSize;
},
relativeSize: function() {
return relativeSize;
}
});
const _color = require("./color");
const _parseBoxShadowValue = require("./parseBoxShadowValue");
const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
let cssFunctions = [
"min",
"max",
"clamp",
"calc"
];
// Ref: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Types
function isCSSFunction(value) {
return cssFunctions.some((fn)=>new RegExp(`^${fn}\\(.*\\)`).test(value));
}
// These properties accept a `<dashed-ident>` as one of the values. This means that you can use them
// as: `timeline-scope: --tl;`
//
// Without the `var(--tl)`, in these cases we don't want to normalize the value, and you should add
// the `var()` yourself.
//
// More info:
// - https://drafts.csswg.org/scroll-animations/#propdef-timeline-scope
// - https://developer.mozilla.org/en-US/docs/Web/CSS/timeline-scope#dashed-ident
//
const AUTO_VAR_INJECTION_EXCEPTIONS = new Set([
// Concrete properties
"scroll-timeline-name",
"timeline-scope",
"view-timeline-name",
"font-palette",
// Shorthand properties
"scroll-timeline",
"animation-timeline",
"view-timeline"
]);
function normalize(value, context = null, isRoot = true) {
let isVarException = context && AUTO_VAR_INJECTION_EXCEPTIONS.has(context.property);
if (value.startsWith("--") && !isVarException) {
return `var(${value})`;
}
// Keep raw strings if it starts with `url(`
if (value.includes("url(")) {
return value.split(/(url\(.*?\))/g).filter(Boolean).map((part)=>{
if (/^url\(.*?\)$/.test(part)) {
return part;
}
return normalize(part, context, false);
}).join("");
}
// Convert `_` to ` `, except for escaped underscores `\_`
value = value.replace(/([^\\])_+/g, (fullMatch, characterBefore)=>characterBefore + " ".repeat(fullMatch.length - 1)).replace(/^_/g, " ").replace(/\\_/g, "_");
// Remove leftover whitespace
if (isRoot) {
value = value.trim();
}
value = normalizeMathOperatorSpacing(value);
return value;
}
/**
* Add spaces around operators inside math functions
* like calc() that do not follow an operator or '('.
*
* @param {string} value
* @returns {string}
*/ function normalizeMathOperatorSpacing(value) {
let preventFormattingInFunctions = [
"theme"
];
let preventFormattingKeywords = [
"min-content",
"max-content",
"fit-content",
// Env
"safe-area-inset-top",
"safe-area-inset-right",
"safe-area-inset-bottom",
"safe-area-inset-left",
"titlebar-area-x",
"titlebar-area-y",
"titlebar-area-width",
"titlebar-area-height",
"keyboard-inset-top",
"keyboard-inset-right",
"keyboard-inset-bottom",
"keyboard-inset-left",
"keyboard-inset-width",
"keyboard-inset-height"
];
return value.replace(/(calc|min|max|clamp)\(.+\)/g, (match)=>{
let result = "";
function lastChar() {
let char = result.trimEnd();
return char[char.length - 1];
}
for(let i = 0; i < match.length; i++){
function peek(word) {
return word.split("").every((char, j)=>match[i + j] === char);
}
function consumeUntil(chars) {
let minIndex = Infinity;
for (let char of chars){
let index = match.indexOf(char, i);
if (index !== -1 && index < minIndex) {
minIndex = index;
}
}
let result = match.slice(i, minIndex);
i += result.length - 1;
return result;
}
let char = match[i];
// Handle `var(--variable)`
if (peek("var")) {
// When we consume until `)`, then we are dealing with this scenario:
// `var(--example)`
//
// When we consume until `,`, then we are dealing with this scenario:
// `var(--example, 1rem)`
//
// In this case we do want to "format", the default value as well
result += consumeUntil([
")",
","
]);
} else if (preventFormattingKeywords.some((keyword)=>peek(keyword))) {
let keyword = preventFormattingKeywords.find((keyword)=>peek(keyword));
result += keyword;
i += keyword.length - 1;
} else if (preventFormattingInFunctions.some((fn)=>peek(fn))) {
result += consumeUntil([
")"
]);
} else if ([
"+",
"-",
"*",
"/"
].includes(char) && ![
"(",
"+",
"-",
"*",
"/"
].includes(lastChar())) {
result += ` ${char} `;
} else {
result += char;
}
}
// Simplify multiple spaces
return result.replace(/\s+/g, " ");
});
}
function url(value) {
return value.startsWith("url(");
}
function number(value) {
return !isNaN(Number(value)) || isCSSFunction(value);
}
function percentage(value) {
return value.endsWith("%") && number(value.slice(0, -1)) || isCSSFunction(value);
}
// Please refer to MDN when updating this list:
// https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Values_and_units
// https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Container_Queries#container_query_length_units
let lengthUnits = [
"cm",
"mm",
"Q",
"in",
"pc",
"pt",
"px",
"em",
"ex",
"ch",
"rem",
"lh",
"rlh",
"vw",
"vh",
"vmin",
"vmax",
"vb",
"vi",
"svw",
"svh",
"lvw",
"lvh",
"dvw",
"dvh",
"cqw",
"cqh",
"cqi",
"cqb",
"cqmin",
"cqmax"
];
let lengthUnitsPattern = `(?:${lengthUnits.join("|")})`;
function length(value) {
return value === "0" || new RegExp(`^[+-]?[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`).test(value) || isCSSFunction(value);
}
let lineWidths = new Set([
"thin",
"medium",
"thick"
]);
function lineWidth(value) {
return lineWidths.has(value);
}
function shadow(value) {
let parsedShadows = (0, _parseBoxShadowValue.parseBoxShadowValue)(normalize(value));
for (let parsedShadow of parsedShadows){
if (!parsedShadow.valid) {
return false;
}
}
return true;
}
function color(value) {
let colors = 0;
let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, "_").every((part)=>{
part = normalize(part);
if (part.startsWith("var(")) return true;
if ((0, _color.parseColor)(part, {
loose: true
}) !== null) return colors++, true;
return false;
});
if (!result) return false;
return colors > 0;
}
function image(value) {
let images = 0;
let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
part = normalize(part);
if (part.startsWith("var(")) return true;
if (url(part) || gradient(part) || [
"element(",
"image(",
"cross-fade(",
"image-set("
].some((fn)=>part.startsWith(fn))) {
images++;
return true;
}
return false;
});
if (!result) return false;
return images > 0;
}
let gradientTypes = new Set([
"conic-gradient",
"linear-gradient",
"radial-gradient",
"repeating-conic-gradient",
"repeating-linear-gradient",
"repeating-radial-gradient"
]);
function gradient(value) {
value = normalize(value);
for (let type of gradientTypes){
if (value.startsWith(`${type}(`)) {
return true;
}
}
return false;
}
let validPositions = new Set([
"center",
"top",
"right",
"bottom",
"left"
]);
function position(value) {
let positions = 0;
let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, "_").every((part)=>{
part = normalize(part);
if (part.startsWith("var(")) return true;
if (validPositions.has(part) || length(part) || percentage(part)) {
positions++;
return true;
}
return false;
});
if (!result) return false;
return positions > 0;
}
function familyName(value) {
let fonts = 0;
let result = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
part = normalize(part);
if (part.startsWith("var(")) return true;
// If it contains spaces, then it should be quoted
if (part.includes(" ")) {
if (!/(['"])([^"']+)\1/g.test(part)) {
return false;
}
}
// If it starts with a number, it's invalid
if (/^\d/g.test(part)) {
return false;
}
fonts++;
return true;
});
if (!result) return false;
return fonts > 0;
}
let genericNames = new Set([
"serif",
"sans-serif",
"monospace",
"cursive",
"fantasy",
"system-ui",
"ui-serif",
"ui-sans-serif",
"ui-monospace",
"ui-rounded",
"math",
"emoji",
"fangsong"
]);
function genericName(value) {
return genericNames.has(value);
}
let absoluteSizes = new Set([
"xx-small",
"x-small",
"small",
"medium",
"large",
"x-large",
"x-large",
"xxx-large"
]);
function absoluteSize(value) {
return absoluteSizes.has(value);
}
let relativeSizes = new Set([
"larger",
"smaller"
]);
function relativeSize(value) {
return relativeSizes.has(value);
}

27
node_modules/tailwindcss/lib/util/defaults.js generated vendored Normal file
View File

@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "defaults", {
enumerable: true,
get: function() {
return defaults;
}
});
function defaults(target, ...sources) {
for (let source of sources){
for(let k in source){
var _target_hasOwnProperty;
if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty = target.hasOwnProperty) === null || _target_hasOwnProperty === void 0 ? void 0 : _target_hasOwnProperty.call(target, k))) {
target[k] = source[k];
}
}
for (let k of Object.getOwnPropertySymbols(source)){
var _target_hasOwnProperty1;
if (!(target === null || target === void 0 ? void 0 : (_target_hasOwnProperty1 = target.hasOwnProperty) === null || _target_hasOwnProperty1 === void 0 ? void 0 : _target_hasOwnProperty1.call(target, k))) {
target[k] = source[k];
}
}
}
return target;
}

24
node_modules/tailwindcss/lib/util/escapeClassName.js generated vendored Normal file
View File

@ -0,0 +1,24 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return escapeClassName;
}
});
const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function escapeClassName(className) {
var _node_raws;
let node = _postcssselectorparser.default.className();
node.value = className;
var _node_raws_value;
return (0, _escapeCommas.default)((_node_raws_value = node === null || node === void 0 ? void 0 : (_node_raws = node.raws) === null || _node_raws === void 0 ? void 0 : _node_raws.value) !== null && _node_raws_value !== void 0 ? _node_raws_value : node.value);
}

13
node_modules/tailwindcss/lib/util/escapeCommas.js generated vendored Normal file
View File

@ -0,0 +1,13 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return escapeCommas;
}
});
function escapeCommas(className) {
return className.replace(/\\,/g, "\\2c ");
}

18
node_modules/tailwindcss/lib/util/flattenColorPalette.js generated vendored Normal file
View File

@ -0,0 +1,18 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
const flattenColorPalette = (colors)=>Object.assign({}, ...Object.entries(colors !== null && colors !== void 0 ? colors : {}).flatMap(([color, values])=>typeof values == "object" ? Object.entries(flattenColorPalette(values)).map(([number, hex])=>({
[color + (number === "DEFAULT" ? "" : `-${number}`)]: hex
})) : [
{
[`${color}`]: values
}
]));
const _default = flattenColorPalette;

270
node_modules/tailwindcss/lib/util/formatVariantSelector.js generated vendored Normal file
View File

@ -0,0 +1,270 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
formatVariantSelector: function() {
return formatVariantSelector;
},
eliminateIrrelevantSelectors: function() {
return eliminateIrrelevantSelectors;
},
finalizeSelector: function() {
return finalizeSelector;
},
handleMergePseudo: function() {
return handleMergePseudo;
}
});
const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
const _unesc = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser/dist/util/unesc"));
const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("../util/escapeClassName"));
const _prefixSelector = /*#__PURE__*/ _interop_require_default(require("../util/prefixSelector"));
const _pseudoElements = require("./pseudoElements");
const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ /** @typedef {{format: string, respectPrefix: boolean}[]} RawFormats */ /** @typedef {import('postcss-selector-parser').Root} ParsedFormats */ /** @typedef {RawFormats | ParsedFormats} AcceptedFormats */ let MERGE = ":merge";
function formatVariantSelector(formats, { context , candidate }) {
var _context_tailwindConfig_prefix;
let prefix = (_context_tailwindConfig_prefix = context === null || context === void 0 ? void 0 : context.tailwindConfig.prefix) !== null && _context_tailwindConfig_prefix !== void 0 ? _context_tailwindConfig_prefix : "";
// Parse the format selector into an AST
let parsedFormats = formats.map((format)=>{
let ast = (0, _postcssselectorparser.default)().astSync(format.format);
return {
...format,
ast: format.respectPrefix ? (0, _prefixSelector.default)(prefix, ast) : ast
};
});
// We start with the candidate selector
let formatAst = _postcssselectorparser.default.root({
nodes: [
_postcssselectorparser.default.selector({
nodes: [
_postcssselectorparser.default.className({
value: (0, _escapeClassName.default)(candidate)
})
]
})
]
});
// And iteratively merge each format selector into the candidate selector
for (let { ast } of parsedFormats){
[formatAst, ast] = handleMergePseudo(formatAst, ast);
// 2. Merge the format selector into the current selector AST
ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes));
// 3. Keep going!
formatAst = ast;
}
return formatAst;
}
/**
* Given any node in a selector this gets the "simple" selector it's a part of
* A simple selector is just a list of nodes without any combinators
* Technically :is(), :not(), :has(), etc… can have combinators but those are nested
* inside the relevant node and won't be picked up so they're fine to ignore
*
* @param {Node} node
* @returns {Node[]}
**/ function simpleSelectorForNode(node) {
/** @type {Node[]} */ let nodes = [];
// Walk backwards until we hit a combinator node (or the start)
while(node.prev() && node.prev().type !== "combinator"){
node = node.prev();
}
// Now record all non-combinator nodes until we hit one (or the end)
while(node && node.type !== "combinator"){
nodes.push(node);
node = node.next();
}
return nodes;
}
/**
* Resorts the nodes in a selector to ensure they're in the correct order
* Tags go before classes, and pseudo classes go after classes
*
* @param {Selector} sel
* @returns {Selector}
**/ function resortSelector(sel) {
sel.sort((a, b)=>{
if (a.type === "tag" && b.type === "class") {
return -1;
} else if (a.type === "class" && b.type === "tag") {
return 1;
} else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
return -1;
} else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
return 1;
}
return sel.index(a) - sel.index(b);
});
return sel;
}
function eliminateIrrelevantSelectors(sel, base) {
let hasClassesMatchingCandidate = false;
sel.walk((child)=>{
if (child.type === "class" && child.value === base) {
hasClassesMatchingCandidate = true;
return false // Stop walking
;
}
});
if (!hasClassesMatchingCandidate) {
sel.remove();
}
// We do NOT recursively eliminate sub selectors that don't have the base class
// as this is NOT a safe operation. For example, if we have:
// `.space-x-2 > :not([hidden]) ~ :not([hidden])`
// We cannot remove the [hidden] from the :not() because it would change the
// meaning of the selector.
// TODO: Can we do this for :matches, :is, and :where?
}
function finalizeSelector(current, formats, { context , candidate , base }) {
var _context_tailwindConfig;
var _context_tailwindConfig_separator;
let separator = (_context_tailwindConfig_separator = context === null || context === void 0 ? void 0 : (_context_tailwindConfig = context.tailwindConfig) === null || _context_tailwindConfig === void 0 ? void 0 : _context_tailwindConfig.separator) !== null && _context_tailwindConfig_separator !== void 0 ? _context_tailwindConfig_separator : ":";
// Split by the separator, but ignore the separator inside square brackets:
//
// E.g.: dark:lg:hover:[paint-order:markers]
// ┬ ┬ ┬ ┬
// │ │ │ ╰── We will not split here
// ╰──┴─────┴─────────────── We will split here
//
base = base !== null && base !== void 0 ? base : (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(candidate, separator).pop();
// Parse the selector into an AST
let selector = (0, _postcssselectorparser.default)().astSync(current);
// Normalize escaped classes, e.g.:
//
// The idea would be to replace the escaped `base` in the selector with the
// `format`. However, in css you can escape the same selector in a few
// different ways. This would result in different strings and therefore we
// can't replace it properly.
//
// base: bg-[rgb(255,0,0)]
// base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
// escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
//
selector.walkClasses((node)=>{
if (node.raws && node.value.includes(base)) {
node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
}
});
// Remove extraneous selectors that do not include the base candidate
selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
// If ffter eliminating irrelevant selectors, we end up with nothing
// Then the whole "rule" this is associated with does not need to exist
// We use `null` as a marker value for that case
if (selector.length === 0) {
return null;
}
// If there are no formats that means there were no variants added to the candidate
// so we can just return the selector as-is
let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {
context,
candidate
}) : formats;
if (formatAst === null) {
return selector.toString();
}
let simpleStart = _postcssselectorparser.default.comment({
value: "/*__simple__*/"
});
let simpleEnd = _postcssselectorparser.default.comment({
value: "/*__simple__*/"
});
// We can safely replace the escaped base now, since the `base` section is
// now in a normalized escaped value.
selector.walkClasses((node)=>{
if (node.value !== base) {
return;
}
let parent = node.parent;
let formatNodes = formatAst.nodes[0].nodes;
// Perf optimization: if the parent is a single class we can just replace it and be done
if (parent.nodes.length === 1) {
node.replaceWith(...formatNodes);
return;
}
let simpleSelector = simpleSelectorForNode(node);
parent.insertBefore(simpleSelector[0], simpleStart);
parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
for (let child of formatNodes){
parent.insertBefore(simpleSelector[0], child.clone());
}
node.remove();
// Re-sort the simple selector to ensure it's in the correct order
simpleSelector = simpleSelectorForNode(simpleStart);
let firstNode = parent.index(simpleStart);
parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssselectorparser.default.selector({
nodes: simpleSelector
})).nodes);
simpleStart.remove();
simpleEnd.remove();
});
// Remove unnecessary pseudo selectors that we used as placeholders
selector.walkPseudos((p)=>{
if (p.value === MERGE) {
p.replaceWith(p.nodes);
}
});
// Move pseudo elements to the end of the selector (if necessary)
selector.each((sel)=>(0, _pseudoElements.movePseudos)(sel));
return selector.toString();
}
function handleMergePseudo(selector, format) {
/** @type {{pseudo: Pseudo, value: string}[]} */ let merges = [];
// Find all :merge() pseudo-classes in `selector`
selector.walkPseudos((pseudo)=>{
if (pseudo.value === MERGE) {
merges.push({
pseudo,
value: pseudo.nodes[0].toString()
});
}
});
// Find all :merge() "attachments" in `format` and attach them to the matching selector in `selector`
format.walkPseudos((pseudo)=>{
if (pseudo.value !== MERGE) {
return;
}
let value = pseudo.nodes[0].toString();
// Does `selector` contain a :merge() pseudo-class with the same value?
let existing = merges.find((merge)=>merge.value === value);
// Nope so there's nothing to do
if (!existing) {
return;
}
// Everything after `:merge()` up to the next combinator is what is attached to the merged selector
let attachments = [];
let next = pseudo.next();
while(next && next.type !== "combinator"){
attachments.push(next);
next = next.next();
}
let combinator = next;
existing.pseudo.parent.insertAfter(existing.pseudo, _postcssselectorparser.default.selector({
nodes: attachments.map((node)=>node.clone())
}));
pseudo.remove();
attachments.forEach((node)=>node.remove());
// What about this case:
// :merge(.group):focus > &
// :merge(.group):hover &
if (combinator && combinator.type === "combinator") {
combinator.remove();
}
});
return [
selector,
format
];
}

50
node_modules/tailwindcss/lib/util/getAllConfigs.js generated vendored Normal file
View File

@ -0,0 +1,50 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return getAllConfigs;
}
});
const _configfull = /*#__PURE__*/ _interop_require_default(require("../../stubs/config.full.js"));
const _featureFlags = require("../featureFlags");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function getAllConfigs(config) {
var _config_presets;
const configs = ((_config_presets = config === null || config === void 0 ? void 0 : config.presets) !== null && _config_presets !== void 0 ? _config_presets : [
_configfull.default
]).slice().reverse().flatMap((preset)=>getAllConfigs(preset instanceof Function ? preset() : preset));
const features = {
// Add experimental configs here...
respectDefaultRingColorOpacity: {
theme: {
ringColor: ({ theme })=>({
DEFAULT: "#3b82f67f",
...theme("colors")
})
}
},
disableColorOpacityUtilitiesByDefault: {
corePlugins: {
backgroundOpacity: false,
borderOpacity: false,
divideOpacity: false,
placeholderOpacity: false,
ringOpacity: false,
textOpacity: false
}
}
};
const experimentals = Object.keys(features).filter((feature)=>(0, _featureFlags.flagEnabled)(config, feature)).map((feature)=>features[feature]);
return [
config,
...experimentals,
...configs
];
}

21
node_modules/tailwindcss/lib/util/hashConfig.js generated vendored Normal file
View File

@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return hashConfig;
}
});
const _objecthash = /*#__PURE__*/ _interop_require_default(require("object-hash"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function hashConfig(config) {
return (0, _objecthash.default)(config, {
ignoreUnknown: true
});
}

13
node_modules/tailwindcss/lib/util/isKeyframeRule.js generated vendored Normal file
View File

@ -0,0 +1,13 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return isKeyframeRule;
}
});
function isKeyframeRule(rule) {
return rule.parent && rule.parent.type === "atrule" && /keyframes$/.test(rule.parent.name);
}

17
node_modules/tailwindcss/lib/util/isPlainObject.js generated vendored Normal file
View File

@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return isPlainObject;
}
});
function isPlainObject(value) {
if (Object.prototype.toString.call(value) !== "[object Object]") {
return false;
}
const prototype = Object.getPrototypeOf(value);
return prototype === null || Object.getPrototypeOf(prototype) === null;
}

74
node_modules/tailwindcss/lib/util/isSyntacticallyValidPropertyValue.js generated vendored Normal file
View File

@ -0,0 +1,74 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, // Arbitrary values must contain balanced brackets (), [] and {}. Escaped
// values don't count, and brackets inside quotes also don't count.
//
// E.g.: w-[this-is]w-[weird-and-invalid]
// E.g.: w-[this-is\\]w-\\[weird-but-valid]
// E.g.: content-['this-is-also-valid]-weirdly-enough']
"default", {
enumerable: true,
get: function() {
return isSyntacticallyValidPropertyValue;
}
});
let matchingBrackets = new Map([
[
"{",
"}"
],
[
"[",
"]"
],
[
"(",
")"
]
]);
let inverseMatchingBrackets = new Map(Array.from(matchingBrackets.entries()).map(([k, v])=>[
v,
k
]));
let quotes = new Set([
'"',
"'",
"`"
]);
function isSyntacticallyValidPropertyValue(value) {
let stack = [];
let inQuotes = false;
for(let i = 0; i < value.length; i++){
let char = value[i];
if (char === ":" && !inQuotes && stack.length === 0) {
return false;
}
// Non-escaped quotes allow us to "allow" anything in between
if (quotes.has(char) && value[i - 1] !== "\\") {
inQuotes = !inQuotes;
}
if (inQuotes) continue;
if (value[i - 1] === "\\") continue; // Escaped
if (matchingBrackets.has(char)) {
stack.push(char);
} else if (inverseMatchingBrackets.has(char)) {
let inverse = inverseMatchingBrackets.get(char);
// Nothing to pop from, therefore it is unbalanced
if (stack.length <= 0) {
return false;
}
// Popped value must match the inverse value, otherwise it is unbalanced
if (stack.pop() !== inverse) {
return false;
}
}
}
// If there is still something on the stack, it is also unbalanced
if (stack.length > 0) {
return false;
}
// All good, totally balanced!
return true;
}

61
node_modules/tailwindcss/lib/util/log.js generated vendored Normal file
View File

@ -0,0 +1,61 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
dim: function() {
return dim;
},
default: function() {
return _default;
}
});
const _picocolors = /*#__PURE__*/ _interop_require_default(require("picocolors"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let alreadyShown = new Set();
function log(type, messages, key) {
if (typeof process !== "undefined" && process.env.JEST_WORKER_ID) return;
if (key && alreadyShown.has(key)) return;
if (key) alreadyShown.add(key);
console.warn("");
messages.forEach((message)=>console.warn(type, "-", message));
}
function dim(input) {
return _picocolors.default.dim(input);
}
const _default = {
info (key, messages) {
log(_picocolors.default.bold(_picocolors.default.cyan("info")), ...Array.isArray(key) ? [
key
] : [
messages,
key
]);
},
warn (key, messages) {
log(_picocolors.default.bold(_picocolors.default.yellow("warn")), ...Array.isArray(key) ? [
key
] : [
messages,
key
]);
},
risk (key, messages) {
log(_picocolors.default.bold(_picocolors.default.magenta("risk")), ...Array.isArray(key) ? [
key
] : [
messages,
key
]);
}
};

49
node_modules/tailwindcss/lib/util/nameClass.js generated vendored Normal file
View File

@ -0,0 +1,49 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
asClass: function() {
return asClass;
},
default: function() {
return nameClass;
},
formatClass: function() {
return formatClass;
}
});
const _escapeClassName = /*#__PURE__*/ _interop_require_default(require("./escapeClassName"));
const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function asClass(name) {
return (0, _escapeCommas.default)(`.${(0, _escapeClassName.default)(name)}`);
}
function nameClass(classPrefix, key) {
return asClass(formatClass(classPrefix, key));
}
function formatClass(classPrefix, key) {
if (key === "DEFAULT") {
return classPrefix;
}
if (key === "-" || key === "-DEFAULT") {
return `-${classPrefix}`;
}
if (key.startsWith("-")) {
return `-${classPrefix}${key}`;
}
if (key.startsWith("/")) {
return `${classPrefix}${key}`;
}
return `${classPrefix}-${key}`;
}

36
node_modules/tailwindcss/lib/util/negateValue.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return negateValue;
}
});
function negateValue(value) {
value = `${value}`;
if (value === "0") {
return "0";
}
// Flip sign of numbers
if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(value)) {
return value.replace(/^[+-]?/, (sign)=>sign === "-" ? "" : "-");
}
// What functions we support negating numeric values for
// var() isn't inherently a numeric function but we support it anyway
// The trigonometric functions are omitted because you'll need to use calc(…) with them _anyway_
// to produce generally useful results and that will be covered already
let numericFunctions = [
"var",
"calc",
"min",
"max",
"clamp"
];
for (const fn of numericFunctions){
if (value.includes(`${fn}(`)) {
return `calc(${value} * -1)`;
}
}
}

282
node_modules/tailwindcss/lib/util/normalizeConfig.js generated vendored Normal file
View File

@ -0,0 +1,282 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "normalizeConfig", {
enumerable: true,
get: function() {
return normalizeConfig;
}
});
const _featureFlags = require("../featureFlags");
const _log = /*#__PURE__*/ _interop_require_wildcard(require("./log"));
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
function normalizeConfig(config) {
// Quick structure validation
/**
* type FilePath = string
* type RawFile = { raw: string, extension?: string }
* type ExtractorFn = (content: string) => Array<string>
* type TransformerFn = (content: string) => string
*
* type Content =
* | Array<FilePath | RawFile>
* | {
* files: Array<FilePath | RawFile>,
* extract?: ExtractorFn | { [extension: string]: ExtractorFn }
* transform?: TransformerFn | { [extension: string]: TransformerFn }
* }
*/ let valid = (()=>{
// `config.purge` should not exist anymore
if (config.purge) {
return false;
}
// `config.content` should exist
if (!config.content) {
return false;
}
// `config.content` should be an object or an array
if (!Array.isArray(config.content) && !(typeof config.content === "object" && config.content !== null)) {
return false;
}
// When `config.content` is an array, it should consist of FilePaths or RawFiles
if (Array.isArray(config.content)) {
return config.content.every((path)=>{
// `path` can be a string
if (typeof path === "string") return true;
// `path` can be an object { raw: string, extension?: string }
// `raw` must be a string
if (typeof (path === null || path === void 0 ? void 0 : path.raw) !== "string") return false;
// `extension` (if provided) should also be a string
if ((path === null || path === void 0 ? void 0 : path.extension) && typeof (path === null || path === void 0 ? void 0 : path.extension) !== "string") {
return false;
}
return true;
});
}
// When `config.content` is an object
if (typeof config.content === "object" && config.content !== null) {
// Only `files`, `relative`, `extract`, and `transform` can exist in `config.content`
if (Object.keys(config.content).some((key)=>![
"files",
"relative",
"extract",
"transform"
].includes(key))) {
return false;
}
// `config.content.files` should exist of FilePaths or RawFiles
if (Array.isArray(config.content.files)) {
if (!config.content.files.every((path)=>{
// `path` can be a string
if (typeof path === "string") return true;
// `path` can be an object { raw: string, extension?: string }
// `raw` must be a string
if (typeof (path === null || path === void 0 ? void 0 : path.raw) !== "string") return false;
// `extension` (if provided) should also be a string
if ((path === null || path === void 0 ? void 0 : path.extension) && typeof (path === null || path === void 0 ? void 0 : path.extension) !== "string") {
return false;
}
return true;
})) {
return false;
}
// `config.content.extract` is optional, and can be a Function or a Record<String, Function>
if (typeof config.content.extract === "object") {
for (let value of Object.values(config.content.extract)){
if (typeof value !== "function") {
return false;
}
}
} else if (!(config.content.extract === undefined || typeof config.content.extract === "function")) {
return false;
}
// `config.content.transform` is optional, and can be a Function or a Record<String, Function>
if (typeof config.content.transform === "object") {
for (let value of Object.values(config.content.transform)){
if (typeof value !== "function") {
return false;
}
}
} else if (!(config.content.transform === undefined || typeof config.content.transform === "function")) {
return false;
}
// `config.content.relative` is optional and can be a boolean
if (typeof config.content.relative !== "boolean" && typeof config.content.relative !== "undefined") {
return false;
}
}
return true;
}
return false;
})();
if (!valid) {
_log.default.warn("purge-deprecation", [
"The `purge`/`content` options have changed in Tailwind CSS v3.0.",
"Update your configuration file to eliminate this warning.",
"https://tailwindcss.com/docs/upgrade-guide#configure-content-sources"
]);
}
// Normalize the `safelist`
config.safelist = (()=>{
var _purge_options;
let { content , purge , safelist } = config;
if (Array.isArray(safelist)) return safelist;
if (Array.isArray(content === null || content === void 0 ? void 0 : content.safelist)) return content.safelist;
if (Array.isArray(purge === null || purge === void 0 ? void 0 : purge.safelist)) return purge.safelist;
if (Array.isArray(purge === null || purge === void 0 ? void 0 : (_purge_options = purge.options) === null || _purge_options === void 0 ? void 0 : _purge_options.safelist)) return purge.options.safelist;
return [];
})();
// Normalize the `blocklist`
config.blocklist = (()=>{
let { blocklist } = config;
if (Array.isArray(blocklist)) {
if (blocklist.every((item)=>typeof item === "string")) {
return blocklist;
}
_log.default.warn("blocklist-invalid", [
"The `blocklist` option must be an array of strings.",
"https://tailwindcss.com/docs/content-configuration#discarding-classes"
]);
}
return [];
})();
// Normalize prefix option
if (typeof config.prefix === "function") {
_log.default.warn("prefix-function", [
"As of Tailwind CSS v3.0, `prefix` cannot be a function.",
"Update `prefix` in your configuration to be a string to eliminate this warning.",
"https://tailwindcss.com/docs/upgrade-guide#prefix-cannot-be-a-function"
]);
config.prefix = "";
} else {
var _config_prefix;
config.prefix = (_config_prefix = config.prefix) !== null && _config_prefix !== void 0 ? _config_prefix : "";
}
// Normalize the `content`
config.content = {
relative: (()=>{
let { content } = config;
if (content === null || content === void 0 ? void 0 : content.relative) {
return content.relative;
}
return (0, _featureFlags.flagEnabled)(config, "relativeContentPathsByDefault");
})(),
files: (()=>{
let { content , purge } = config;
if (Array.isArray(purge)) return purge;
if (Array.isArray(purge === null || purge === void 0 ? void 0 : purge.content)) return purge.content;
if (Array.isArray(content)) return content;
if (Array.isArray(content === null || content === void 0 ? void 0 : content.content)) return content.content;
if (Array.isArray(content === null || content === void 0 ? void 0 : content.files)) return content.files;
return [];
})(),
extract: (()=>{
let extract = (()=>{
var _config_purge, _config_content, _config_purge1, _config_purge_extract, _config_content1, _config_content_extract, _config_purge2, _config_purge_options, _config_content2, _config_content_options;
if ((_config_purge = config.purge) === null || _config_purge === void 0 ? void 0 : _config_purge.extract) return config.purge.extract;
if ((_config_content = config.content) === null || _config_content === void 0 ? void 0 : _config_content.extract) return config.content.extract;
if ((_config_purge1 = config.purge) === null || _config_purge1 === void 0 ? void 0 : (_config_purge_extract = _config_purge1.extract) === null || _config_purge_extract === void 0 ? void 0 : _config_purge_extract.DEFAULT) return config.purge.extract.DEFAULT;
if ((_config_content1 = config.content) === null || _config_content1 === void 0 ? void 0 : (_config_content_extract = _config_content1.extract) === null || _config_content_extract === void 0 ? void 0 : _config_content_extract.DEFAULT) return config.content.extract.DEFAULT;
if ((_config_purge2 = config.purge) === null || _config_purge2 === void 0 ? void 0 : (_config_purge_options = _config_purge2.options) === null || _config_purge_options === void 0 ? void 0 : _config_purge_options.extractors) return config.purge.options.extractors;
if ((_config_content2 = config.content) === null || _config_content2 === void 0 ? void 0 : (_config_content_options = _config_content2.options) === null || _config_content_options === void 0 ? void 0 : _config_content_options.extractors) return config.content.options.extractors;
return {};
})();
let extractors = {};
let defaultExtractor = (()=>{
var _config_purge, _config_purge_options, _config_content, _config_content_options;
if ((_config_purge = config.purge) === null || _config_purge === void 0 ? void 0 : (_config_purge_options = _config_purge.options) === null || _config_purge_options === void 0 ? void 0 : _config_purge_options.defaultExtractor) {
return config.purge.options.defaultExtractor;
}
if ((_config_content = config.content) === null || _config_content === void 0 ? void 0 : (_config_content_options = _config_content.options) === null || _config_content_options === void 0 ? void 0 : _config_content_options.defaultExtractor) {
return config.content.options.defaultExtractor;
}
return undefined;
})();
if (defaultExtractor !== undefined) {
extractors.DEFAULT = defaultExtractor;
}
// Functions
if (typeof extract === "function") {
extractors.DEFAULT = extract;
} else if (Array.isArray(extract)) {
for (let { extensions , extractor } of extract !== null && extract !== void 0 ? extract : []){
for (let extension of extensions){
extractors[extension] = extractor;
}
}
} else if (typeof extract === "object" && extract !== null) {
Object.assign(extractors, extract);
}
return extractors;
})(),
transform: (()=>{
let transform = (()=>{
var _config_purge, _config_content, _config_purge1, _config_purge_transform, _config_content1, _config_content_transform;
if ((_config_purge = config.purge) === null || _config_purge === void 0 ? void 0 : _config_purge.transform) return config.purge.transform;
if ((_config_content = config.content) === null || _config_content === void 0 ? void 0 : _config_content.transform) return config.content.transform;
if ((_config_purge1 = config.purge) === null || _config_purge1 === void 0 ? void 0 : (_config_purge_transform = _config_purge1.transform) === null || _config_purge_transform === void 0 ? void 0 : _config_purge_transform.DEFAULT) return config.purge.transform.DEFAULT;
if ((_config_content1 = config.content) === null || _config_content1 === void 0 ? void 0 : (_config_content_transform = _config_content1.transform) === null || _config_content_transform === void 0 ? void 0 : _config_content_transform.DEFAULT) return config.content.transform.DEFAULT;
return {};
})();
let transformers = {};
if (typeof transform === "function") {
transformers.DEFAULT = transform;
}
if (typeof transform === "object" && transform !== null) {
Object.assign(transformers, transform);
}
return transformers;
})()
};
// Validate globs to prevent bogus globs.
// E.g.: `./src/*.{html}` is invalid, the `{html}` should just be `html`
for (let file of config.content.files){
if (typeof file === "string" && /{([^,]*?)}/g.test(file)) {
_log.default.warn("invalid-glob-braces", [
`The glob pattern ${(0, _log.dim)(file)} in your Tailwind CSS configuration is invalid.`,
`Update it to ${(0, _log.dim)(file.replace(/{([^,]*?)}/g, "$1"))} to silence this warning.`
]);
break;
}
}
return config;
}

178
node_modules/tailwindcss/lib/util/normalizeScreens.js generated vendored Normal file
View File

@ -0,0 +1,178 @@
/**
* @typedef {object} ScreenValue
* @property {number|undefined} min
* @property {number|undefined} max
* @property {string|undefined} raw
*/ /**
* @typedef {object} Screen
* @property {string} name
* @property {boolean} not
* @property {ScreenValue[]} values
*/ /**
* A function that normalizes the various forms that the screens object can be
* provided in.
*
* Input(s):
* - ['100px', '200px'] // Raw strings
* - { sm: '100px', md: '200px' } // Object with string values
* - { sm: { min: '100px' }, md: { max: '100px' } } // Object with object values
* - { sm: [{ min: '100px' }, { max: '200px' }] } // Object with object array (multiple values)
*
* Output(s):
* - [{ name: 'sm', values: [{ min: '100px', max: '200px' }] }] // List of objects, that contains multiple values
*
* @returns {Screen[]}
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
normalizeScreens: function() {
return normalizeScreens;
},
isScreenSortable: function() {
return isScreenSortable;
},
compareScreens: function() {
return compareScreens;
},
toScreen: function() {
return toScreen;
}
});
function normalizeScreens(screens, root = true) {
if (Array.isArray(screens)) {
return screens.map((screen)=>{
if (root && Array.isArray(screen)) {
throw new Error("The tuple syntax is not supported for `screens`.");
}
if (typeof screen === "string") {
return {
name: screen.toString(),
not: false,
values: [
{
min: screen,
max: undefined
}
]
};
}
let [name, options] = screen;
name = name.toString();
if (typeof options === "string") {
return {
name,
not: false,
values: [
{
min: options,
max: undefined
}
]
};
}
if (Array.isArray(options)) {
return {
name,
not: false,
values: options.map((option)=>resolveValue(option))
};
}
return {
name,
not: false,
values: [
resolveValue(options)
]
};
});
}
return normalizeScreens(Object.entries(screens !== null && screens !== void 0 ? screens : {}), false);
}
function isScreenSortable(screen) {
if (screen.values.length !== 1) {
return {
result: false,
reason: "multiple-values"
};
} else if (screen.values[0].raw !== undefined) {
return {
result: false,
reason: "raw-values"
};
} else if (screen.values[0].min !== undefined && screen.values[0].max !== undefined) {
return {
result: false,
reason: "min-and-max"
};
}
return {
result: true,
reason: null
};
}
function compareScreens(type, a, z) {
let aScreen = toScreen(a, type);
let zScreen = toScreen(z, type);
let aSorting = isScreenSortable(aScreen);
let bSorting = isScreenSortable(zScreen);
// These cases should never happen and indicate a bug in Tailwind CSS itself
if (aSorting.reason === "multiple-values" || bSorting.reason === "multiple-values") {
throw new Error("Attempted to sort a screen with multiple values. This should never happen. Please open a bug report.");
} else if (aSorting.reason === "raw-values" || bSorting.reason === "raw-values") {
throw new Error("Attempted to sort a screen with raw values. This should never happen. Please open a bug report.");
} else if (aSorting.reason === "min-and-max" || bSorting.reason === "min-and-max") {
throw new Error("Attempted to sort a screen with both min and max values. This should never happen. Please open a bug report.");
}
// Let the sorting begin
let { min: aMin , max: aMax } = aScreen.values[0];
let { min: zMin , max: zMax } = zScreen.values[0];
// Negating screens flip their behavior. Basically `not min-width` is `max-width`
if (a.not) [aMin, aMax] = [
aMax,
aMin
];
if (z.not) [zMin, zMax] = [
zMax,
zMin
];
aMin = aMin === undefined ? aMin : parseFloat(aMin);
aMax = aMax === undefined ? aMax : parseFloat(aMax);
zMin = zMin === undefined ? zMin : parseFloat(zMin);
zMax = zMax === undefined ? zMax : parseFloat(zMax);
let [aValue, zValue] = type === "min" ? [
aMin,
zMin
] : [
zMax,
aMax
];
return aValue - zValue;
}
function toScreen(value, type) {
if (typeof value === "object") {
return value;
}
return {
name: "arbitrary-screen",
values: [
{
[type]: value
}
]
};
}
function resolveValue({ "min-width": _minWidth , min =_minWidth , max , raw } = {}) {
return {
min,
max,
raw
};
}

93
node_modules/tailwindcss/lib/util/parseAnimationValue.js generated vendored Normal file
View File

@ -0,0 +1,93 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return parseAnimationValue;
}
});
const DIRECTIONS = new Set([
"normal",
"reverse",
"alternate",
"alternate-reverse"
]);
const PLAY_STATES = new Set([
"running",
"paused"
]);
const FILL_MODES = new Set([
"none",
"forwards",
"backwards",
"both"
]);
const ITERATION_COUNTS = new Set([
"infinite"
]);
const TIMINGS = new Set([
"linear",
"ease",
"ease-in",
"ease-out",
"ease-in-out",
"step-start",
"step-end"
]);
const TIMING_FNS = [
"cubic-bezier",
"steps"
];
const COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
;
const SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
;
const TIME = /^(-?[\d.]+m?s)$/;
const DIGIT = /^(\d+)$/;
function parseAnimationValue(input) {
let animations = input.split(COMMA);
return animations.map((animation)=>{
let value = animation.trim();
let result = {
value
};
let parts = value.split(SPACE);
let seen = new Set();
for (let part of parts){
if (!seen.has("DIRECTIONS") && DIRECTIONS.has(part)) {
result.direction = part;
seen.add("DIRECTIONS");
} else if (!seen.has("PLAY_STATES") && PLAY_STATES.has(part)) {
result.playState = part;
seen.add("PLAY_STATES");
} else if (!seen.has("FILL_MODES") && FILL_MODES.has(part)) {
result.fillMode = part;
seen.add("FILL_MODES");
} else if (!seen.has("ITERATION_COUNTS") && (ITERATION_COUNTS.has(part) || DIGIT.test(part))) {
result.iterationCount = part;
seen.add("ITERATION_COUNTS");
} else if (!seen.has("TIMING_FUNCTION") && TIMINGS.has(part)) {
result.timingFunction = part;
seen.add("TIMING_FUNCTION");
} else if (!seen.has("TIMING_FUNCTION") && TIMING_FNS.some((f)=>part.startsWith(`${f}(`))) {
result.timingFunction = part;
seen.add("TIMING_FUNCTION");
} else if (!seen.has("DURATION") && TIME.test(part)) {
result.duration = part;
seen.add("DURATION");
} else if (!seen.has("DELAY") && TIME.test(part)) {
result.delay = part;
seen.add("DELAY");
} else if (!seen.has("NAME")) {
result.name = part;
seen.add("NAME");
} else {
if (!result.unknown) result.unknown = [];
result.unknown.push(part);
}
}
return result;
});
}

88
node_modules/tailwindcss/lib/util/parseBoxShadowValue.js generated vendored Normal file
View File

@ -0,0 +1,88 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
parseBoxShadowValue: function() {
return parseBoxShadowValue;
},
formatBoxShadowValue: function() {
return formatBoxShadowValue;
}
});
const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
let KEYWORDS = new Set([
"inset",
"inherit",
"initial",
"revert",
"unset"
]);
let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
;
let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g;
function parseBoxShadowValue(input) {
let shadows = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(input, ",");
return shadows.map((shadow)=>{
let value = shadow.trim();
let result = {
raw: value
};
let parts = value.split(SPACE);
let seen = new Set();
for (let part of parts){
// Reset index, since the regex is stateful.
LENGTH.lastIndex = 0;
// Keyword
if (!seen.has("KEYWORD") && KEYWORDS.has(part)) {
result.keyword = part;
seen.add("KEYWORD");
} else if (LENGTH.test(part)) {
if (!seen.has("X")) {
result.x = part;
seen.add("X");
} else if (!seen.has("Y")) {
result.y = part;
seen.add("Y");
} else if (!seen.has("BLUR")) {
result.blur = part;
seen.add("BLUR");
} else if (!seen.has("SPREAD")) {
result.spread = part;
seen.add("SPREAD");
}
} else {
if (!result.color) {
result.color = part;
} else {
if (!result.unknown) result.unknown = [];
result.unknown.push(part);
}
}
}
// Check if valid
result.valid = result.x !== undefined && result.y !== undefined;
return result;
});
}
function formatBoxShadowValue(shadows) {
return shadows.map((shadow)=>{
if (!shadow.valid) {
return shadow.raw;
}
return [
shadow.keyword,
shadow.x,
shadow.y,
shadow.blur,
shadow.spread,
shadow.color
].filter(Boolean).join(" ");
}).join(", ");
}

47
node_modules/tailwindcss/lib/util/parseDependency.js generated vendored Normal file
View File

@ -0,0 +1,47 @@
// @ts-check
/**
* @typedef {{type: 'dependency', file: string} | {type: 'dir-dependency', dir: string, glob: string}} Dependency
*/ /**
*
* @param {import('../lib/content.js').ContentPath} contentPath
* @returns {Dependency[]}
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return parseDependency;
}
});
function parseDependency(contentPath) {
if (contentPath.ignore) {
return [];
}
if (!contentPath.glob) {
return [
{
type: "dependency",
file: contentPath.base
}
];
}
if (process.env.ROLLUP_WATCH === "true") {
// rollup-plugin-postcss does not support dir-dependency messages
// but directories can be watched in the same way as files
return [
{
type: "dependency",
file: contentPath.base
}
];
}
return [
{
type: "dir-dependency",
dir: contentPath.base,
glob: contentPath.glob
}
];
}

36
node_modules/tailwindcss/lib/util/parseGlob.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "parseGlob", {
enumerable: true,
get: function() {
return parseGlob;
}
});
const _globparent = /*#__PURE__*/ _interop_require_default(require("glob-parent"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function parseGlob(pattern) {
let glob = pattern;
let base = (0, _globparent.default)(pattern);
if (base !== ".") {
glob = pattern.substr(base.length);
if (glob.charAt(0) === "/") {
glob = glob.substr(1);
}
}
if (glob.substr(0, 2) === "./") {
glob = glob.substr(2);
}
if (glob.charAt(0) === "/") {
glob = glob.substr(1);
}
return {
base,
glob
};
}

36
node_modules/tailwindcss/lib/util/parseObjectStyles.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return parseObjectStyles;
}
});
const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
const _postcssnested = /*#__PURE__*/ _interop_require_default(require("postcss-nested"));
const _postcssjs = /*#__PURE__*/ _interop_require_default(require("postcss-js"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function parseObjectStyles(styles) {
if (!Array.isArray(styles)) {
return parseObjectStyles([
styles
]);
}
return styles.flatMap((style)=>{
return (0, _postcss.default)([
(0, _postcssnested.default)({
bubble: [
"screen"
]
})
]).process(style, {
parser: _postcssjs.default
}).root.nodes;
});
}

276
node_modules/tailwindcss/lib/util/pluginUtils.js generated vendored Normal file
View File

@ -0,0 +1,276 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
updateAllClasses: function() {
return updateAllClasses;
},
asValue: function() {
return asValue;
},
parseColorFormat: function() {
return parseColorFormat;
},
asColor: function() {
return asColor;
},
asLookupValue: function() {
return asLookupValue;
},
typeMap: function() {
return typeMap;
},
coerceValue: function() {
return coerceValue;
},
getMatchingTypes: function() {
return getMatchingTypes;
}
});
const _escapeCommas = /*#__PURE__*/ _interop_require_default(require("./escapeCommas"));
const _withAlphaVariable = require("./withAlphaVariable");
const _dataTypes = require("./dataTypes");
const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
const _validateFormalSyntax = require("./validateFormalSyntax");
const _featureFlags = require("../featureFlags.js");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function updateAllClasses(selectors, updateClass) {
selectors.walkClasses((sel)=>{
sel.value = updateClass(sel.value);
if (sel.raws && sel.raws.value) {
sel.raws.value = (0, _escapeCommas.default)(sel.raws.value);
}
});
}
function resolveArbitraryValue(modifier, validate) {
if (!isArbitraryValue(modifier)) {
return undefined;
}
let value = modifier.slice(1, -1);
if (!validate(value)) {
return undefined;
}
return (0, _dataTypes.normalize)(value);
}
function asNegativeValue(modifier, lookup = {}, validate) {
let positiveValue = lookup[modifier];
if (positiveValue !== undefined) {
return (0, _negateValue.default)(positiveValue);
}
if (isArbitraryValue(modifier)) {
let resolved = resolveArbitraryValue(modifier, validate);
if (resolved === undefined) {
return undefined;
}
return (0, _negateValue.default)(resolved);
}
}
function asValue(modifier, options = {}, { validate =()=>true } = {}) {
var _options_values;
let value = (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[modifier];
if (value !== undefined) {
return value;
}
if (options.supportsNegativeValues && modifier.startsWith("-")) {
return asNegativeValue(modifier.slice(1), options.values, validate);
}
return resolveArbitraryValue(modifier, validate);
}
function isArbitraryValue(input) {
return input.startsWith("[") && input.endsWith("]");
}
function splitUtilityModifier(modifier) {
let slashIdx = modifier.lastIndexOf("/");
if (slashIdx === -1 || slashIdx === modifier.length - 1) {
return [
modifier,
undefined
];
}
let arbitrary = isArbitraryValue(modifier);
// The modifier could be of the form `[foo]/[bar]`
// We want to handle this case properly
// without affecting `[foo/bar]`
if (arbitrary && !modifier.includes("]/[")) {
return [
modifier,
undefined
];
}
return [
modifier.slice(0, slashIdx),
modifier.slice(slashIdx + 1)
];
}
function parseColorFormat(value) {
if (typeof value === "string" && value.includes("<alpha-value>")) {
let oldValue = value;
return ({ opacityValue =1 })=>oldValue.replace("<alpha-value>", opacityValue);
}
return value;
}
function unwrapArbitraryModifier(modifier) {
return (0, _dataTypes.normalize)(modifier.slice(1, -1));
}
function asColor(modifier, options = {}, { tailwindConfig ={} } = {}) {
var _options_values;
if (((_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[modifier]) !== undefined) {
var _options_values1;
return parseColorFormat((_options_values1 = options.values) === null || _options_values1 === void 0 ? void 0 : _options_values1[modifier]);
}
// TODO: Hoist this up to getMatchingTypes or something
// We do this here because we need the alpha value (if any)
let [color, alpha] = splitUtilityModifier(modifier);
if (alpha !== undefined) {
var _options_values2, _tailwindConfig_theme, _tailwindConfig_theme_opacity;
var _options_values_color;
let normalizedColor = (_options_values_color = (_options_values2 = options.values) === null || _options_values2 === void 0 ? void 0 : _options_values2[color]) !== null && _options_values_color !== void 0 ? _options_values_color : isArbitraryValue(color) ? color.slice(1, -1) : undefined;
if (normalizedColor === undefined) {
return undefined;
}
normalizedColor = parseColorFormat(normalizedColor);
if (isArbitraryValue(alpha)) {
return (0, _withAlphaVariable.withAlphaValue)(normalizedColor, unwrapArbitraryModifier(alpha));
}
if (((_tailwindConfig_theme = tailwindConfig.theme) === null || _tailwindConfig_theme === void 0 ? void 0 : (_tailwindConfig_theme_opacity = _tailwindConfig_theme.opacity) === null || _tailwindConfig_theme_opacity === void 0 ? void 0 : _tailwindConfig_theme_opacity[alpha]) === undefined) {
return undefined;
}
return (0, _withAlphaVariable.withAlphaValue)(normalizedColor, tailwindConfig.theme.opacity[alpha]);
}
return asValue(modifier, options, {
validate: _dataTypes.color
});
}
function asLookupValue(modifier, options = {}) {
var _options_values;
return (_options_values = options.values) === null || _options_values === void 0 ? void 0 : _options_values[modifier];
}
function guess(validate) {
return (modifier, options)=>{
return asValue(modifier, options, {
validate
});
};
}
let typeMap = {
any: asValue,
color: asColor,
url: guess(_dataTypes.url),
image: guess(_dataTypes.image),
length: guess(_dataTypes.length),
percentage: guess(_dataTypes.percentage),
position: guess(_dataTypes.position),
lookup: asLookupValue,
"generic-name": guess(_dataTypes.genericName),
"family-name": guess(_dataTypes.familyName),
number: guess(_dataTypes.number),
"line-width": guess(_dataTypes.lineWidth),
"absolute-size": guess(_dataTypes.absoluteSize),
"relative-size": guess(_dataTypes.relativeSize),
shadow: guess(_dataTypes.shadow),
size: guess(_validateFormalSyntax.backgroundSize)
};
let supportedTypes = Object.keys(typeMap);
function splitAtFirst(input, delim) {
let idx = input.indexOf(delim);
if (idx === -1) return [
undefined,
input
];
return [
input.slice(0, idx),
input.slice(idx + 1)
];
}
function coerceValue(types, modifier, options, tailwindConfig) {
if (options.values && modifier in options.values) {
for (let { type } of types !== null && types !== void 0 ? types : []){
let result = typeMap[type](modifier, options, {
tailwindConfig
});
if (result === undefined) {
continue;
}
return [
result,
type,
null
];
}
}
if (isArbitraryValue(modifier)) {
let arbitraryValue = modifier.slice(1, -1);
let [explicitType, value] = splitAtFirst(arbitraryValue, ":");
// It could be that this resolves to `url(https` which is not a valid
// identifier. We currently only support "simple" words with dashes or
// underscores. E.g.: family-name
if (!/^[\w-_]+$/g.test(explicitType)) {
value = arbitraryValue;
} else if (explicitType !== undefined && !supportedTypes.includes(explicitType)) {
return [];
}
if (value.length > 0 && supportedTypes.includes(explicitType)) {
return [
asValue(`[${value}]`, options),
explicitType,
null
];
}
}
let matches = getMatchingTypes(types, modifier, options, tailwindConfig);
// Find first matching type
for (let match of matches){
return match;
}
return [];
}
function* getMatchingTypes(types, rawModifier, options, tailwindConfig) {
let modifiersEnabled = (0, _featureFlags.flagEnabled)(tailwindConfig, "generalizedModifiers");
let [modifier, utilityModifier] = splitUtilityModifier(rawModifier);
let canUseUtilityModifier = modifiersEnabled && options.modifiers != null && (options.modifiers === "any" || typeof options.modifiers === "object" && (utilityModifier && isArbitraryValue(utilityModifier) || utilityModifier in options.modifiers));
if (!canUseUtilityModifier) {
modifier = rawModifier;
utilityModifier = undefined;
}
if (utilityModifier !== undefined && modifier === "") {
modifier = "DEFAULT";
}
// Check the full value first
// TODO: Move to asValue… somehow
if (utilityModifier !== undefined) {
if (typeof options.modifiers === "object") {
var _options_modifiers;
var _options_modifiers_utilityModifier;
let configValue = (_options_modifiers_utilityModifier = (_options_modifiers = options.modifiers) === null || _options_modifiers === void 0 ? void 0 : _options_modifiers[utilityModifier]) !== null && _options_modifiers_utilityModifier !== void 0 ? _options_modifiers_utilityModifier : null;
if (configValue !== null) {
utilityModifier = configValue;
} else if (isArbitraryValue(utilityModifier)) {
utilityModifier = unwrapArbitraryModifier(utilityModifier);
}
}
}
for (let { type } of types !== null && types !== void 0 ? types : []){
let result = typeMap[type](modifier, options, {
tailwindConfig
});
if (result === undefined) {
continue;
}
yield [
result,
type,
utilityModifier !== null && utilityModifier !== void 0 ? utilityModifier : null
];
}
}

39
node_modules/tailwindcss/lib/util/prefixSelector.js generated vendored Normal file
View File

@ -0,0 +1,39 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, /**
* @template {string | import('postcss-selector-parser').Root} T
*
* Prefix all classes in the selector with the given prefix
*
* It can take either a string or a selector AST and will return the same type
*
* @param {string} prefix
* @param {T} selector
* @param {boolean} prependNegative
* @returns {T}
*/ "default", {
enumerable: true,
get: function() {
return _default;
}
});
const _postcssselectorparser = /*#__PURE__*/ _interop_require_default(require("postcss-selector-parser"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function _default(prefix, selector, prependNegative = false) {
if (prefix === "") {
return selector;
}
/** @type {import('postcss-selector-parser').Root} */ let ast = typeof selector === "string" ? (0, _postcssselectorparser.default)().astSync(selector) : selector;
ast.walkClasses((classSelector)=>{
let baseClass = classSelector.value;
let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith("-");
classSelector.value = shouldPlaceNegativeBeforePrefix ? `-${prefix}${baseClass.slice(1)}` : `${prefix}${baseClass}`;
});
return typeof selector === "string" ? ast.toString() : ast;
}

209
node_modules/tailwindcss/lib/util/pseudoElements.js generated vendored Normal file
View File

@ -0,0 +1,209 @@
/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ // There are some pseudo-elements that may or may not be:
// **Actionable**
// Zero or more user-action pseudo-classes may be attached to the pseudo-element itself
// structural-pseudo-classes are NOT allowed but we don't make
// The spec is not clear on whether this is allowed or not — but in practice it is.
// **Terminal**
// It MUST be placed at the end of a selector
//
// This is the required in the spec. However, some pseudo elements are not "terminal" because
// they represent a "boundary piercing" that is compiled out by a build step.
// **Jumpable**
// Any terminal element may "jump" over combinators when moving to the end of the selector
//
// This is a backwards-compat quirk of pseudo element variants from earlier versions of Tailwind CSS.
/** @typedef {'terminal' | 'actionable' | 'jumpable'} PseudoProperty */ /** @type {Record<string, PseudoProperty[]>} */ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "movePseudos", {
enumerable: true,
get: function() {
return movePseudos;
}
});
let elementProperties = {
// Pseudo elements from the spec
"::after": [
"terminal",
"jumpable"
],
"::backdrop": [
"terminal",
"jumpable"
],
"::before": [
"terminal",
"jumpable"
],
"::cue": [
"terminal"
],
"::cue-region": [
"terminal"
],
"::first-letter": [
"terminal",
"jumpable"
],
"::first-line": [
"terminal",
"jumpable"
],
"::grammar-error": [
"terminal"
],
"::marker": [
"terminal",
"jumpable"
],
"::part": [
"terminal",
"actionable"
],
"::placeholder": [
"terminal",
"jumpable"
],
"::selection": [
"terminal",
"jumpable"
],
"::slotted": [
"terminal"
],
"::spelling-error": [
"terminal"
],
"::target-text": [
"terminal"
],
// Pseudo elements from the spec with special rules
"::file-selector-button": [
"terminal",
"actionable"
],
// Library-specific pseudo elements used by component libraries
// These are Shadow DOM-like
"::deep": [
"actionable"
],
"::v-deep": [
"actionable"
],
"::ng-deep": [
"actionable"
],
// Note: As a rule, double colons (::) should be used instead of a single colon
// (:). This distinguishes pseudo-classes from pseudo-elements. However, since
// this distinction was not present in older versions of the W3C spec, most
// browsers support both syntaxes for the original pseudo-elements.
":after": [
"terminal",
"jumpable"
],
":before": [
"terminal",
"jumpable"
],
":first-letter": [
"terminal",
"jumpable"
],
":first-line": [
"terminal",
"jumpable"
],
// The default value is used when the pseudo-element is not recognized
// Because it's not recognized, we don't know if it's terminal or not
// So we assume it can be moved AND can have user-action pseudo classes attached to it
__default__: [
"terminal",
"actionable"
]
};
function movePseudos(sel) {
let [pseudos] = movablePseudos(sel);
// Remove all pseudo elements from their respective selectors
pseudos.forEach(([sel, pseudo])=>sel.removeChild(pseudo));
// Re-add them to the end of the selector in the correct order.
// This moves terminal pseudo elements to the end of the
// selector otherwise the selector will not be valid.
//
// Examples:
// - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
// - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
//
// The selector `::before:hover` does not work but we
// can make it work for you by flipping the order.
sel.nodes.push(...pseudos.map(([, pseudo])=>pseudo));
return sel;
}
/** @typedef {[sel: Selector, pseudo: Pseudo, attachedTo: Pseudo | null]} MovablePseudo */ /** @typedef {[pseudos: MovablePseudo[], lastSeenElement: Pseudo | null]} MovablePseudosResult */ /**
* @param {Selector} sel
* @returns {MovablePseudosResult}
*/ function movablePseudos(sel) {
/** @type {MovablePseudo[]} */ let buffer = [];
/** @type {Pseudo | null} */ let lastSeenElement = null;
for (let node of sel.nodes){
if (node.type === "combinator") {
buffer = buffer.filter(([, node])=>propertiesForPseudo(node).includes("jumpable"));
lastSeenElement = null;
} else if (node.type === "pseudo") {
if (isMovablePseudoElement(node)) {
lastSeenElement = node;
buffer.push([
sel,
node,
null
]);
} else if (lastSeenElement && isAttachablePseudoClass(node, lastSeenElement)) {
buffer.push([
sel,
node,
lastSeenElement
]);
} else {
lastSeenElement = null;
}
var _node_nodes;
for (let sub of (_node_nodes = node.nodes) !== null && _node_nodes !== void 0 ? _node_nodes : []){
let [movable, lastSeenElementInSub] = movablePseudos(sub);
lastSeenElement = lastSeenElementInSub || lastSeenElement;
buffer.push(...movable);
}
}
}
return [
buffer,
lastSeenElement
];
}
/**
* @param {Node} node
* @returns {boolean}
*/ function isPseudoElement(node) {
return node.value.startsWith("::") || elementProperties[node.value] !== undefined;
}
/**
* @param {Node} node
* @returns {boolean}
*/ function isMovablePseudoElement(node) {
return isPseudoElement(node) && propertiesForPseudo(node).includes("terminal");
}
/**
* @param {Node} node
* @param {Pseudo} pseudo
* @returns {boolean}
*/ function isAttachablePseudoClass(node, pseudo) {
if (node.type !== "pseudo") return false;
if (isPseudoElement(node)) return false;
return propertiesForPseudo(pseudo).includes("actionable");
}
/**
* @param {Pseudo} pseudo
* @returns {PseudoProperty[]}
*/ function propertiesForPseudo(pseudo) {
var _elementProperties_pseudo_value;
return (_elementProperties_pseudo_value = elementProperties[pseudo.value]) !== null && _elementProperties_pseudo_value !== void 0 ? _elementProperties_pseudo_value : elementProperties.__default__;
}

31
node_modules/tailwindcss/lib/util/removeAlphaVariables.js generated vendored Normal file
View File

@ -0,0 +1,31 @@
/**
* This function removes any uses of CSS variables used as an alpha channel
*
* This is required for selectors like `:visited` which do not allow
* changes in opacity or external control using CSS variables.
*
* @param {import('postcss').Container} container
* @param {string[]} toRemove
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "removeAlphaVariables", {
enumerable: true,
get: function() {
return removeAlphaVariables;
}
});
function removeAlphaVariables(container, toRemove) {
container.walkDecls((decl)=>{
if (toRemove.includes(decl.prop)) {
decl.remove();
return;
}
for (let varName of toRemove){
if (decl.value.includes(`/ var(${varName})`)) {
decl.value = decl.value.replace(`/ var(${varName})`, "");
}
}
});
}

256
node_modules/tailwindcss/lib/util/resolveConfig.js generated vendored Normal file
View File

@ -0,0 +1,256 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return resolveConfig;
}
});
const _negateValue = /*#__PURE__*/ _interop_require_default(require("./negateValue"));
const _corePluginList = /*#__PURE__*/ _interop_require_default(require("../corePluginList"));
const _configurePlugins = /*#__PURE__*/ _interop_require_default(require("./configurePlugins"));
const _colors = /*#__PURE__*/ _interop_require_default(require("../public/colors"));
const _defaults = require("./defaults");
const _toPath = require("./toPath");
const _normalizeConfig = require("./normalizeConfig");
const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
const _cloneDeep = require("./cloneDeep");
const _pluginUtils = require("./pluginUtils");
const _withAlphaVariable = require("./withAlphaVariable");
const _toColorValue = /*#__PURE__*/ _interop_require_default(require("./toColorValue"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function isFunction(input) {
return typeof input === "function";
}
function mergeWith(target, ...sources) {
let customizer = sources.pop();
for (let source of sources){
for(let k in source){
let merged = customizer(target[k], source[k]);
if (merged === undefined) {
if ((0, _isPlainObject.default)(target[k]) && (0, _isPlainObject.default)(source[k])) {
target[k] = mergeWith({}, target[k], source[k], customizer);
} else {
target[k] = source[k];
}
} else {
target[k] = merged;
}
}
}
return target;
}
const configUtils = {
colors: _colors.default,
negative (scale) {
// TODO: Log that this function isn't really needed anymore?
return Object.keys(scale).filter((key)=>scale[key] !== "0").reduce((negativeScale, key)=>{
let negativeValue = (0, _negateValue.default)(scale[key]);
if (negativeValue !== undefined) {
negativeScale[`-${key}`] = negativeValue;
}
return negativeScale;
}, {});
},
breakpoints (screens) {
return Object.keys(screens).filter((key)=>typeof screens[key] === "string").reduce((breakpoints, key)=>({
...breakpoints,
[`screen-${key}`]: screens[key]
}), {});
}
};
function value(valueToResolve, ...args) {
return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve;
}
function collectExtends(items) {
return items.reduce((merged, { extend })=>{
return mergeWith(merged, extend, (mergedValue, extendValue)=>{
if (mergedValue === undefined) {
return [
extendValue
];
}
if (Array.isArray(mergedValue)) {
return [
extendValue,
...mergedValue
];
}
return [
extendValue,
mergedValue
];
});
}, {});
}
function mergeThemes(themes) {
return {
...themes.reduce((merged, theme)=>(0, _defaults.defaults)(merged, theme), {}),
// In order to resolve n config objects, we combine all of their `extend` properties
// into arrays instead of objects so they aren't overridden.
extend: collectExtends(themes)
};
}
function mergeExtensionCustomizer(merged, value) {
// When we have an array of objects, we do want to merge it
if (Array.isArray(merged) && (0, _isPlainObject.default)(merged[0])) {
return merged.concat(value);
}
// When the incoming value is an array, and the existing config is an object, prepend the existing object
if (Array.isArray(value) && (0, _isPlainObject.default)(value[0]) && (0, _isPlainObject.default)(merged)) {
return [
merged,
...value
];
}
// Override arrays (for example for font-families, box-shadows, ...)
if (Array.isArray(value)) {
return value;
}
// Execute default behaviour
return undefined;
}
function mergeExtensions({ extend , ...theme }) {
return mergeWith(theme, extend, (themeValue, extensions)=>{
// The `extend` property is an array, so we need to check if it contains any functions
if (!isFunction(themeValue) && !extensions.some(isFunction)) {
return mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer);
}
return (resolveThemePath, utils)=>mergeWith({}, ...[
themeValue,
...extensions
].map((e)=>value(e, resolveThemePath, utils)), mergeExtensionCustomizer);
});
}
/**
*
* @param {string} key
* @return {Iterable<string[] & {alpha: string | undefined}>}
*/ function* toPaths(key) {
let path = (0, _toPath.toPath)(key);
if (path.length === 0) {
return;
}
yield path;
if (Array.isArray(key)) {
return;
}
let pattern = /^(.*?)\s*\/\s*([^/]+)$/;
let matches = key.match(pattern);
if (matches !== null) {
let [, prefix, alpha] = matches;
let newPath = (0, _toPath.toPath)(prefix);
newPath.alpha = alpha;
yield newPath;
}
}
function resolveFunctionKeys(object) {
// theme('colors.red.500 / 0.5') -> ['colors', 'red', '500 / 0', '5]
const resolvePath = (key, defaultValue)=>{
for (const path of toPaths(key)){
let index = 0;
let val = object;
while(val !== undefined && val !== null && index < path.length){
val = val[path[index++]];
let shouldResolveAsFn = isFunction(val) && (path.alpha === undefined || index <= path.length - 1);
val = shouldResolveAsFn ? val(resolvePath, configUtils) : val;
}
if (val !== undefined) {
if (path.alpha !== undefined) {
let normalized = (0, _pluginUtils.parseColorFormat)(val);
return (0, _withAlphaVariable.withAlphaValue)(normalized, path.alpha, (0, _toColorValue.default)(normalized));
}
if ((0, _isPlainObject.default)(val)) {
return (0, _cloneDeep.cloneDeep)(val);
}
return val;
}
}
return defaultValue;
};
Object.assign(resolvePath, {
theme: resolvePath,
...configUtils
});
return Object.keys(object).reduce((resolved, key)=>{
resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key];
return resolved;
}, {});
}
function extractPluginConfigs(configs) {
let allConfigs = [];
configs.forEach((config)=>{
allConfigs = [
...allConfigs,
config
];
var _config_plugins;
const plugins = (_config_plugins = config === null || config === void 0 ? void 0 : config.plugins) !== null && _config_plugins !== void 0 ? _config_plugins : [];
if (plugins.length === 0) {
return;
}
plugins.forEach((plugin)=>{
if (plugin.__isOptionsFunction) {
plugin = plugin();
}
var _plugin_config;
allConfigs = [
...allConfigs,
...extractPluginConfigs([
(_plugin_config = plugin === null || plugin === void 0 ? void 0 : plugin.config) !== null && _plugin_config !== void 0 ? _plugin_config : {}
])
];
});
});
return allConfigs;
}
function resolveCorePlugins(corePluginConfigs) {
const result = [
...corePluginConfigs
].reduceRight((resolved, corePluginConfig)=>{
if (isFunction(corePluginConfig)) {
return corePluginConfig({
corePlugins: resolved
});
}
return (0, _configurePlugins.default)(corePluginConfig, resolved);
}, _corePluginList.default);
return result;
}
function resolvePluginLists(pluginLists) {
const result = [
...pluginLists
].reduceRight((resolved, pluginList)=>{
return [
...resolved,
...pluginList
];
}, []);
return result;
}
function resolveConfig(configs) {
let allConfigs = [
...extractPluginConfigs(configs),
{
prefix: "",
important: false,
separator: ":"
}
];
var _t_theme, _c_plugins;
return (0, _normalizeConfig.normalizeConfig)((0, _defaults.defaults)({
theme: resolveFunctionKeys(mergeExtensions(mergeThemes(allConfigs.map((t)=>{
return (_t_theme = t === null || t === void 0 ? void 0 : t.theme) !== null && _t_theme !== void 0 ? _t_theme : {};
})))),
corePlugins: resolveCorePlugins(allConfigs.map((c)=>c.corePlugins)),
plugins: resolvePluginLists(configs.map((c)=>{
return (_c_plugins = c === null || c === void 0 ? void 0 : c.plugins) !== null && _c_plugins !== void 0 ? _c_plugins : [];
}))
}, ...allConfigs));
}

70
node_modules/tailwindcss/lib/util/resolveConfigPath.js generated vendored Normal file
View File

@ -0,0 +1,70 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
default: function() {
return resolveConfigPath;
},
resolveDefaultConfigPath: function() {
return resolveDefaultConfigPath;
}
});
const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
const defaultConfigFiles = [
"./tailwind.config.js",
"./tailwind.config.cjs",
"./tailwind.config.mjs",
"./tailwind.config.ts"
];
function isObject(value) {
return typeof value === "object" && value !== null;
}
function isEmpty(obj) {
return Object.keys(obj).length === 0;
}
function isString(value) {
return typeof value === "string" || value instanceof String;
}
function resolveConfigPath(pathOrConfig) {
// require('tailwindcss')({ theme: ..., variants: ... })
if (isObject(pathOrConfig) && pathOrConfig.config === undefined && !isEmpty(pathOrConfig)) {
return null;
}
// require('tailwindcss')({ config: 'custom-config.js' })
if (isObject(pathOrConfig) && pathOrConfig.config !== undefined && isString(pathOrConfig.config)) {
return _path.default.resolve(pathOrConfig.config);
}
// require('tailwindcss')({ config: { theme: ..., variants: ... } })
if (isObject(pathOrConfig) && pathOrConfig.config !== undefined && isObject(pathOrConfig.config)) {
return null;
}
// require('tailwindcss')('custom-config.js')
if (isString(pathOrConfig)) {
return _path.default.resolve(pathOrConfig);
}
// require('tailwindcss')
return resolveDefaultConfigPath();
}
function resolveDefaultConfigPath() {
for (const configFile of defaultConfigFiles){
try {
const configPath = _path.default.resolve(configFile);
_fs.default.accessSync(configPath);
return configPath;
} catch (err) {}
}
return null;
}

24
node_modules/tailwindcss/lib/util/responsive.js generated vendored Normal file
View File

@ -0,0 +1,24 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return responsive;
}
});
const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
const _cloneNodes = /*#__PURE__*/ _interop_require_default(require("./cloneNodes"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function responsive(rules) {
return _postcss.default.atRule({
name: "responsive"
}).append((0, _cloneNodes.default)(Array.isArray(rules) ? rules : [
rules
]));
}

51
node_modules/tailwindcss/lib/util/splitAtTopLevelOnly.js generated vendored Normal file
View File

@ -0,0 +1,51 @@
/**
* This splits a string on a top-level character.
*
* Regex doesn't support recursion (at least not the JS-flavored version).
* So we have to use a tiny state machine to keep track of paren placement.
*
* Expected behavior using commas:
* var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
* ─┬─ ┬ ┬ ┬
* x x x ╰──────── Split because top-level
* ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
*
* @param {string} input
* @param {string} separator
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "splitAtTopLevelOnly", {
enumerable: true,
get: function() {
return splitAtTopLevelOnly;
}
});
function splitAtTopLevelOnly(input, separator) {
let stack = [];
let parts = [];
let lastPos = 0;
let isEscaped = false;
for(let idx = 0; idx < input.length; idx++){
let char = input[idx];
if (stack.length === 0 && char === separator[0] && !isEscaped) {
if (separator.length === 1 || input.slice(idx, idx + separator.length) === separator) {
parts.push(input.slice(lastPos, idx));
lastPos = idx + separator.length;
}
}
if (isEscaped) {
isEscaped = false;
} else if (char === "\\") {
isEscaped = true;
}
if (char === "(" || char === "[" || char === "{") {
stack.push(char);
} else if (char === ")" && stack[stack.length - 1] === "(" || char === "]" && stack[stack.length - 1] === "[" || char === "}" && stack[stack.length - 1] === "{") {
stack.pop();
}
}
parts.push(input.slice(lastPos));
return parts;
}

14
node_modules/tailwindcss/lib/util/tap.js generated vendored Normal file
View File

@ -0,0 +1,14 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "tap", {
enumerable: true,
get: function() {
return tap;
}
});
function tap(value, mutator) {
mutator(value);
return value;
}

13
node_modules/tailwindcss/lib/util/toColorValue.js generated vendored Normal file
View File

@ -0,0 +1,13 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return toColorValue;
}
});
function toColorValue(maybeFunction) {
return typeof maybeFunction === "function" ? maybeFunction({}) : maybeFunction;
}

32
node_modules/tailwindcss/lib/util/toPath.js generated vendored Normal file
View File

@ -0,0 +1,32 @@
/**
* Parse a path string into an array of path segments.
*
* Square bracket notation `a[b]` may be used to "escape" dots that would otherwise be interpreted as path separators.
*
* Example:
* a -> ['a']
* a.b.c -> ['a', 'b', 'c']
* a[b].c -> ['a', 'b', 'c']
* a[b.c].e.f -> ['a', 'b.c', 'e', 'f']
* a[b][c][d] -> ['a', 'b', 'c', 'd']
*
* @param {string|string[]} path
**/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "toPath", {
enumerable: true,
get: function() {
return toPath;
}
});
function toPath(path) {
if (Array.isArray(path)) return path;
let openBrackets = path.split("[").length - 1;
let closedBrackets = path.split("]").length - 1;
if (openBrackets !== closedBrackets) {
throw new Error(`Path is invalid. Has unbalanced brackets: ${path}`);
}
return path.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean);
}

73
node_modules/tailwindcss/lib/util/transformThemeValue.js generated vendored Normal file
View File

@ -0,0 +1,73 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return transformThemeValue;
}
});
const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
const _isPlainObject = /*#__PURE__*/ _interop_require_default(require("./isPlainObject"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function transformThemeValue(themeSection) {
if ([
"fontSize",
"outline"
].includes(themeSection)) {
return (value)=>{
if (typeof value === "function") value = value({});
if (Array.isArray(value)) value = value[0];
return value;
};
}
if (themeSection === "fontFamily") {
return (value)=>{
if (typeof value === "function") value = value({});
let families = Array.isArray(value) && (0, _isPlainObject.default)(value[1]) ? value[0] : value;
return Array.isArray(families) ? families.join(", ") : families;
};
}
if ([
"boxShadow",
"transitionProperty",
"transitionDuration",
"transitionDelay",
"transitionTimingFunction",
"backgroundImage",
"backgroundSize",
"backgroundColor",
"cursor",
"animation"
].includes(themeSection)) {
return (value)=>{
if (typeof value === "function") value = value({});
if (Array.isArray(value)) value = value.join(", ");
return value;
};
}
// For backwards compatibility reasons, before we switched to underscores
// instead of commas for arbitrary values.
if ([
"gridTemplateColumns",
"gridTemplateRows",
"objectPosition"
].includes(themeSection)) {
return (value)=>{
if (typeof value === "function") value = value({});
if (typeof value === "string") value = _postcss.default.list.comma(value).join(" ");
return value;
};
}
return (value, opts = {})=>{
if (typeof value === "function") {
value = value(opts);
}
return value;
};
}

37
node_modules/tailwindcss/lib/util/validateConfig.js generated vendored Normal file
View File

@ -0,0 +1,37 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "validateConfig", {
enumerable: true,
get: function() {
return validateConfig;
}
});
const _log = /*#__PURE__*/ _interop_require_default(require("./log"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function validateConfig(config) {
if (config.content.files.length === 0) {
_log.default.warn("content-problems", [
"The `content` option in your Tailwind CSS configuration is missing or empty.",
"Configure your content sources or your generated CSS will be missing styles.",
"https://tailwindcss.com/docs/content-configuration"
]);
}
// Warn if the line-clamp plugin is installed
try {
let plugin = require("@tailwindcss/line-clamp");
if (config.plugins.includes(plugin)) {
_log.default.warn("line-clamp-in-core", [
"As of Tailwind CSS v3.3, the `@tailwindcss/line-clamp` plugin is now included by default.",
"Remove it from the `plugins` array in your configuration to eliminate this warning."
]);
config.plugins = config.plugins.filter((p)=>p !== plugin);
}
} catch {}
return config;
}

26
node_modules/tailwindcss/lib/util/validateFormalSyntax.js generated vendored Normal file
View File

@ -0,0 +1,26 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "backgroundSize", {
enumerable: true,
get: function() {
return backgroundSize;
}
});
const _dataTypes = require("./dataTypes");
const _splitAtTopLevelOnly = require("./splitAtTopLevelOnly");
function backgroundSize(value) {
let keywordValues = [
"cover",
"contain"
];
// the <length-percentage> type will probably be a css function
// so we have to use `splitAtTopLevelOnly`
return (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(value, ",").every((part)=>{
let sizes = (0, _splitAtTopLevelOnly.splitAtTopLevelOnly)(part, "_").filter(Boolean);
if (sizes.length === 1 && keywordValues.includes(sizes[0])) return true;
if (sizes.length !== 1 && sizes.length !== 2) return false;
return sizes.every((size)=>(0, _dataTypes.length)(size) || (0, _dataTypes.percentage)(size) || size === "auto");
});
}

79
node_modules/tailwindcss/lib/util/withAlphaVariable.js generated vendored Normal file
View File

@ -0,0 +1,79 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
withAlphaValue: function() {
return withAlphaValue;
},
default: function() {
return withAlphaVariable;
}
});
const _color = require("./color");
function withAlphaValue(color, alphaValue, defaultValue) {
if (typeof color === "function") {
return color({
opacityValue: alphaValue
});
}
let parsed = (0, _color.parseColor)(color, {
loose: true
});
if (parsed === null) {
return defaultValue;
}
return (0, _color.formatColor)({
...parsed,
alpha: alphaValue
});
}
function withAlphaVariable({ color , property , variable }) {
let properties = [].concat(property);
if (typeof color === "function") {
return {
[variable]: "1",
...Object.fromEntries(properties.map((p)=>{
return [
p,
color({
opacityVariable: variable,
opacityValue: `var(${variable})`
})
];
}))
};
}
const parsed = (0, _color.parseColor)(color);
if (parsed === null) {
return Object.fromEntries(properties.map((p)=>[
p,
color
]));
}
if (parsed.alpha !== undefined) {
// Has an alpha value, return color as-is
return Object.fromEntries(properties.map((p)=>[
p,
color
]));
}
return {
[variable]: "1",
...Object.fromEntries(properties.map((p)=>{
return [
p,
(0, _color.formatColor)({
...parsed,
alpha: `var(${variable})`
})
];
}))
};
}