diff options
Diffstat (limited to 'node_modules/tailwindcss/lib/util')
46 files changed, 4175 insertions, 0 deletions
diff --git a/node_modules/tailwindcss/lib/util/applyImportantSelector.js b/node_modules/tailwindcss/lib/util/applyImportantSelector.js new file mode 100644 index 0000000..c53729d --- /dev/null +++ b/node_modules/tailwindcss/lib/util/applyImportantSelector.js @@ -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()}`; +} diff --git a/node_modules/tailwindcss/lib/util/bigSign.js b/node_modules/tailwindcss/lib/util/bigSign.js new file mode 100644 index 0000000..d452fd2 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/bigSign.js @@ -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); +} diff --git a/node_modules/tailwindcss/lib/util/buildMediaQuery.js b/node_modules/tailwindcss/lib/util/buildMediaQuery.js new file mode 100644 index 0000000..e7e1cd0 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/buildMediaQuery.js @@ -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(", "); +} diff --git a/node_modules/tailwindcss/lib/util/cloneDeep.js b/node_modules/tailwindcss/lib/util/cloneDeep.js new file mode 100644 index 0000000..bc3b2f1 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/cloneDeep.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/cloneNodes.js b/node_modules/tailwindcss/lib/util/cloneNodes.js new file mode 100644 index 0000000..8433b84 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/cloneNodes.js @@ -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; + }); +} diff --git a/node_modules/tailwindcss/lib/util/color.js b/node_modules/tailwindcss/lib/util/color.js new file mode 100644 index 0000000..3228b6b --- /dev/null +++ b/node_modules/tailwindcss/lib/util/color.js @@ -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}` : ""})`; +} diff --git a/node_modules/tailwindcss/lib/util/colorNames.js b/node_modules/tailwindcss/lib/util/colorNames.js new file mode 100644 index 0000000..2eb4ff0 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/colorNames.js @@ -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 + ] +}; diff --git a/node_modules/tailwindcss/lib/util/configurePlugins.js b/node_modules/tailwindcss/lib/util/configurePlugins.js new file mode 100644 index 0000000..0da568a --- /dev/null +++ b/node_modules/tailwindcss/lib/util/configurePlugins.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/createPlugin.js b/node_modules/tailwindcss/lib/util/createPlugin.js new file mode 100644 index 0000000..1a3040f --- /dev/null +++ b/node_modules/tailwindcss/lib/util/createPlugin.js @@ -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; diff --git a/node_modules/tailwindcss/lib/util/createUtilityPlugin.js b/node_modules/tailwindcss/lib/util/createUtilityPlugin.js new file mode 100644 index 0000000..5483e13 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/createUtilityPlugin.js @@ -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) + }); + } + }; +} diff --git a/node_modules/tailwindcss/lib/util/dataTypes.js b/node_modules/tailwindcss/lib/util/dataTypes.js new file mode 100644 index 0000000..1facc6c --- /dev/null +++ b/node_modules/tailwindcss/lib/util/dataTypes.js @@ -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); +} diff --git a/node_modules/tailwindcss/lib/util/defaults.js b/node_modules/tailwindcss/lib/util/defaults.js new file mode 100644 index 0000000..06b5d37 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/defaults.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/escapeClassName.js b/node_modules/tailwindcss/lib/util/escapeClassName.js new file mode 100644 index 0000000..02d47e2 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/escapeClassName.js @@ -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); +} diff --git a/node_modules/tailwindcss/lib/util/escapeCommas.js b/node_modules/tailwindcss/lib/util/escapeCommas.js new file mode 100644 index 0000000..2a41dd7 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/escapeCommas.js @@ -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 "); +} diff --git a/node_modules/tailwindcss/lib/util/flattenColorPalette.js b/node_modules/tailwindcss/lib/util/flattenColorPalette.js new file mode 100644 index 0000000..f115685 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/flattenColorPalette.js @@ -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; diff --git a/node_modules/tailwindcss/lib/util/formatVariantSelector.js b/node_modules/tailwindcss/lib/util/formatVariantSelector.js new file mode 100644 index 0000000..8e778e8 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/formatVariantSelector.js @@ -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 + ]; +} diff --git a/node_modules/tailwindcss/lib/util/getAllConfigs.js b/node_modules/tailwindcss/lib/util/getAllConfigs.js new file mode 100644 index 0000000..82dbf93 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/getAllConfigs.js @@ -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 + ]; +} diff --git a/node_modules/tailwindcss/lib/util/hashConfig.js b/node_modules/tailwindcss/lib/util/hashConfig.js new file mode 100644 index 0000000..c737b26 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/hashConfig.js @@ -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 + }); +} diff --git a/node_modules/tailwindcss/lib/util/isKeyframeRule.js b/node_modules/tailwindcss/lib/util/isKeyframeRule.js new file mode 100644 index 0000000..264272e --- /dev/null +++ b/node_modules/tailwindcss/lib/util/isKeyframeRule.js @@ -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); +} diff --git a/node_modules/tailwindcss/lib/util/isPlainObject.js b/node_modules/tailwindcss/lib/util/isPlainObject.js new file mode 100644 index 0000000..d3ff144 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/isPlainObject.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/isSyntacticallyValidPropertyValue.js b/node_modules/tailwindcss/lib/util/isSyntacticallyValidPropertyValue.js new file mode 100644 index 0000000..2ad3917 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/isSyntacticallyValidPropertyValue.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/log.js b/node_modules/tailwindcss/lib/util/log.js new file mode 100644 index 0000000..9ffdfb7 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/log.js @@ -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 + ]); + } +}; diff --git a/node_modules/tailwindcss/lib/util/nameClass.js b/node_modules/tailwindcss/lib/util/nameClass.js new file mode 100644 index 0000000..b469071 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/nameClass.js @@ -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}`; +} diff --git a/node_modules/tailwindcss/lib/util/negateValue.js b/node_modules/tailwindcss/lib/util/negateValue.js new file mode 100644 index 0000000..2d96026 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/negateValue.js @@ -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)`; + } + } +} diff --git a/node_modules/tailwindcss/lib/util/normalizeConfig.js b/node_modules/tailwindcss/lib/util/normalizeConfig.js new file mode 100644 index 0000000..8c67f2c --- /dev/null +++ b/node_modules/tailwindcss/lib/util/normalizeConfig.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/normalizeScreens.js b/node_modules/tailwindcss/lib/util/normalizeScreens.js new file mode 100644 index 0000000..c21eb75 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/normalizeScreens.js @@ -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 + }; +} diff --git a/node_modules/tailwindcss/lib/util/parseAnimationValue.js b/node_modules/tailwindcss/lib/util/parseAnimationValue.js new file mode 100644 index 0000000..33370f7 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/parseAnimationValue.js @@ -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; + }); +} diff --git a/node_modules/tailwindcss/lib/util/parseBoxShadowValue.js b/node_modules/tailwindcss/lib/util/parseBoxShadowValue.js new file mode 100644 index 0000000..28f68c9 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/parseBoxShadowValue.js @@ -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(", "); +} diff --git a/node_modules/tailwindcss/lib/util/parseDependency.js b/node_modules/tailwindcss/lib/util/parseDependency.js new file mode 100644 index 0000000..9a98a5e --- /dev/null +++ b/node_modules/tailwindcss/lib/util/parseDependency.js @@ -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 + } + ]; +} diff --git a/node_modules/tailwindcss/lib/util/parseGlob.js b/node_modules/tailwindcss/lib/util/parseGlob.js new file mode 100644 index 0000000..f52720c --- /dev/null +++ b/node_modules/tailwindcss/lib/util/parseGlob.js @@ -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 + }; +} diff --git a/node_modules/tailwindcss/lib/util/parseObjectStyles.js b/node_modules/tailwindcss/lib/util/parseObjectStyles.js new file mode 100644 index 0000000..995d87d --- /dev/null +++ b/node_modules/tailwindcss/lib/util/parseObjectStyles.js @@ -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; + }); +} diff --git a/node_modules/tailwindcss/lib/util/pluginUtils.js b/node_modules/tailwindcss/lib/util/pluginUtils.js new file mode 100644 index 0000000..dcb8b51 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/pluginUtils.js @@ -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 + ]; + } +} diff --git a/node_modules/tailwindcss/lib/util/prefixSelector.js b/node_modules/tailwindcss/lib/util/prefixSelector.js new file mode 100644 index 0000000..ee2ce98 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/prefixSelector.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/pseudoElements.js b/node_modules/tailwindcss/lib/util/pseudoElements.js new file mode 100644 index 0000000..0baf114 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/pseudoElements.js @@ -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__; +} diff --git a/node_modules/tailwindcss/lib/util/removeAlphaVariables.js b/node_modules/tailwindcss/lib/util/removeAlphaVariables.js new file mode 100644 index 0000000..8f1196a --- /dev/null +++ b/node_modules/tailwindcss/lib/util/removeAlphaVariables.js @@ -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})`, ""); + } + } + }); +} diff --git a/node_modules/tailwindcss/lib/util/resolveConfig.js b/node_modules/tailwindcss/lib/util/resolveConfig.js new file mode 100644 index 0000000..a74d334 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/resolveConfig.js @@ -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)); +} diff --git a/node_modules/tailwindcss/lib/util/resolveConfigPath.js b/node_modules/tailwindcss/lib/util/resolveConfigPath.js new file mode 100644 index 0000000..56d1e3a --- /dev/null +++ b/node_modules/tailwindcss/lib/util/resolveConfigPath.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/responsive.js b/node_modules/tailwindcss/lib/util/responsive.js new file mode 100644 index 0000000..3ec8d34 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/responsive.js @@ -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 + ])); +} diff --git a/node_modules/tailwindcss/lib/util/splitAtTopLevelOnly.js b/node_modules/tailwindcss/lib/util/splitAtTopLevelOnly.js new file mode 100644 index 0000000..4b75cce --- /dev/null +++ b/node_modules/tailwindcss/lib/util/splitAtTopLevelOnly.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/tap.js b/node_modules/tailwindcss/lib/util/tap.js new file mode 100644 index 0000000..8acdbd6 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/tap.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/toColorValue.js b/node_modules/tailwindcss/lib/util/toColorValue.js new file mode 100644 index 0000000..db3ed9d --- /dev/null +++ b/node_modules/tailwindcss/lib/util/toColorValue.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/toPath.js b/node_modules/tailwindcss/lib/util/toPath.js new file mode 100644 index 0000000..ef4fd8b --- /dev/null +++ b/node_modules/tailwindcss/lib/util/toPath.js @@ -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); +} diff --git a/node_modules/tailwindcss/lib/util/transformThemeValue.js b/node_modules/tailwindcss/lib/util/transformThemeValue.js new file mode 100644 index 0000000..a7572e7 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/transformThemeValue.js @@ -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; + }; +} diff --git a/node_modules/tailwindcss/lib/util/validateConfig.js b/node_modules/tailwindcss/lib/util/validateConfig.js new file mode 100644 index 0000000..8624025 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/validateConfig.js @@ -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; +} diff --git a/node_modules/tailwindcss/lib/util/validateFormalSyntax.js b/node_modules/tailwindcss/lib/util/validateFormalSyntax.js new file mode 100644 index 0000000..cf03de4 --- /dev/null +++ b/node_modules/tailwindcss/lib/util/validateFormalSyntax.js @@ -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"); + }); +} diff --git a/node_modules/tailwindcss/lib/util/withAlphaVariable.js b/node_modules/tailwindcss/lib/util/withAlphaVariable.js new file mode 100644 index 0000000..f4b4e9c --- /dev/null +++ b/node_modules/tailwindcss/lib/util/withAlphaVariable.js @@ -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})` + }) + ]; + })) + }; +} |