Tailwind css added

This commit is contained in:
Aravind142857
2023-06-21 15:56:08 -05:00
parent 0d2619b9c0
commit cc421f40c6
1574 changed files with 277349 additions and 177 deletions

211
node_modules/postcss-less/lib/LessParser.js generated vendored Normal file
View File

@@ -0,0 +1,211 @@
/* eslint no-param-reassign: off */
const Comment = require('postcss/lib/comment');
const Parser = require('postcss/lib/parser');
const { isInlineComment } = require('./nodes/inline-comment');
const { interpolation } = require('./nodes/interpolation');
const { isMixinToken } = require('./nodes/mixin');
const importNode = require('./nodes/import');
const variableNode = require('./nodes/variable');
const importantPattern = /(!\s*important)$/i;
module.exports = class LessParser extends Parser {
constructor(...args) {
super(...args);
this.lastNode = null;
}
atrule(token) {
if (interpolation.bind(this)(token)) {
return;
}
super.atrule(token);
importNode(this.lastNode);
variableNode(this.lastNode);
}
decl(...args) {
super.decl(...args);
// #123: add `extend` decorator to nodes
const extendPattern = /extend\(.+\)/i;
if (extendPattern.test(this.lastNode.value)) {
this.lastNode.extend = true;
}
}
each(tokens) {
// prepend a space so the `name` will be parsed correctly
tokens[0][1] = ` ${tokens[0][1]}`;
const firstParenIndex = tokens.findIndex((t) => t[0] === '(');
const lastParen = tokens.reverse().find((t) => t[0] === ')');
const lastParenIndex = tokens.reverse().indexOf(lastParen);
const paramTokens = tokens.splice(firstParenIndex, lastParenIndex);
const params = paramTokens.map((t) => t[1]).join('');
for (const token of tokens.reverse()) {
this.tokenizer.back(token);
}
this.atrule(this.tokenizer.nextToken());
this.lastNode.function = true;
this.lastNode.params = params;
}
init(node, line, column) {
super.init(node, line, column);
this.lastNode = node;
}
inlineComment(token) {
const node = new Comment();
const text = token[1].slice(2);
this.init(node, token[2], token[3]);
node.source.end = { line: token[4], column: token[5] };
node.inline = true;
node.raws.begin = '//';
if (/^\s*$/.test(text)) {
node.text = '';
node.raws.left = text;
node.raws.right = '';
} else {
const match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
[, node.raws.left, node.text, node.raws.right] = match;
}
}
mixin(tokens) {
const [first] = tokens;
const identifier = first[1].slice(0, 1);
const bracketsIndex = tokens.findIndex((t) => t[0] === 'brackets');
const firstParenIndex = tokens.findIndex((t) => t[0] === '(');
let important = '';
// fix for #86. if rulesets are mixin params, they need to be converted to a brackets token
if ((bracketsIndex < 0 || bracketsIndex > 3) && firstParenIndex > 0) {
const lastParenIndex = tokens.reduce((last, t, i) => (t[0] === ')' ? i : last));
const contents = tokens.slice(firstParenIndex, lastParenIndex + firstParenIndex);
const brackets = contents.map((t) => t[1]).join('');
const [paren] = tokens.slice(firstParenIndex);
const start = [paren[2], paren[3]];
const [last] = tokens.slice(lastParenIndex, lastParenIndex + 1);
const end = [last[2], last[3]];
const newToken = ['brackets', brackets].concat(start, end);
const tokensBefore = tokens.slice(0, firstParenIndex);
const tokensAfter = tokens.slice(lastParenIndex + 1);
tokens = tokensBefore;
tokens.push(newToken);
tokens = tokens.concat(tokensAfter);
}
const importantTokens = [];
for (const token of tokens) {
if (token[1] === '!' || importantTokens.length) {
importantTokens.push(token);
}
if (token[1] === 'important') {
break;
}
}
if (importantTokens.length) {
const [bangToken] = importantTokens;
const bangIndex = tokens.indexOf(bangToken);
const last = importantTokens[importantTokens.length - 1];
const start = [bangToken[2], bangToken[3]];
const end = [last[4], last[5]];
const combined = importantTokens.map((t) => t[1]).join('');
const newToken = ['word', combined].concat(start, end);
tokens.splice(bangIndex, importantTokens.length, newToken);
}
const importantIndex = tokens.findIndex((t) => importantPattern.test(t[1]));
if (importantIndex > 0) {
[, important] = tokens[importantIndex];
tokens.splice(importantIndex, 1);
}
for (const token of tokens.reverse()) {
this.tokenizer.back(token);
}
this.atrule(this.tokenizer.nextToken());
this.lastNode.mixin = true;
this.lastNode.raws.identifier = identifier;
if (important) {
this.lastNode.important = true;
this.lastNode.raws.important = important;
}
}
other(token) {
if (!isInlineComment.bind(this)(token)) {
super.other(token);
}
}
rule(tokens) {
const last = tokens[tokens.length - 1];
const prev = tokens[tokens.length - 2];
if (prev[0] === 'at-word' && last[0] === '{') {
this.tokenizer.back(last);
if (interpolation.bind(this)(prev)) {
const newToken = this.tokenizer.nextToken();
tokens = tokens.slice(0, tokens.length - 2).concat([newToken]);
for (const tokn of tokens.reverse()) {
this.tokenizer.back(tokn);
}
return;
}
}
super.rule(tokens);
// #123: add `extend` decorator to nodes
const extendPattern = /:extend\(.+\)/i;
if (extendPattern.test(this.lastNode.selector)) {
this.lastNode.extend = true;
}
}
unknownWord(tokens) {
// NOTE: keep commented for examining unknown structures
// console.log('unknown', tokens);
const [first] = tokens;
// #121 support `each` - http://lesscss.org/functions/#list-functions-each
if (tokens[0][1] === 'each' && tokens[1][0] === '(') {
this.each(tokens);
return;
}
// TODO: move this into a util function/file
if (isMixinToken(first)) {
this.mixin(tokens);
return;
}
super.unknownWord(tokens);
}
};

42
node_modules/postcss-less/lib/LessStringifier.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
const Stringifier = require('postcss/lib/stringifier');
module.exports = class LessStringifier extends Stringifier {
atrule(node, semicolon) {
if (!node.mixin && !node.variable && !node.function) {
super.atrule(node, semicolon);
return;
}
const identifier = node.function ? '' : node.raws.identifier || '@';
let name = `${identifier}${node.name}`;
let params = node.params ? this.rawValue(node, 'params') : '';
const important = node.raws.important || '';
if (node.variable) {
params = node.value;
}
if (typeof node.raws.afterName !== 'undefined') {
name += node.raws.afterName;
} else if (params) {
name += ' ';
}
if (node.nodes) {
this.block(node, name + params + important);
} else {
const end = (node.raws.between || '') + important + (semicolon ? ';' : '');
this.builder(name + params + end, node);
}
}
comment(node) {
if (node.inline) {
const left = this.raw(node, 'left', 'commentLeft');
const right = this.raw(node, 'right', 'commentRight');
this.builder(`//${left}${node.text}${right}`, node);
} else {
super.comment(node);
}
}
};

30
node_modules/postcss-less/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
const Input = require('postcss/lib/input');
const LessParser = require('./LessParser');
const LessStringifier = require('./LessStringifier');
module.exports = {
parse(less, options) {
const input = new Input(less, options);
const parser = new LessParser(input);
parser.parse();
return parser.root;
},
stringify(node, builder) {
const stringifier = new LessStringifier(builder);
stringifier.stringify(node);
},
nodeToString(node) {
let result = '';
module.exports.stringify(node, (bit) => {
result += bit;
});
return result;
}
};

29
node_modules/postcss-less/lib/nodes/import.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
/* eslint no-param-reassign: off */
const tokenize = require('postcss/lib/tokenize');
const urlPattern = /^url\((.+)\)/;
module.exports = (node) => {
const { name, params = '' } = node;
if (name === 'import' && params.length) {
node.import = true;
const tokenizer = tokenize({ css: params });
node.filename = params.replace(urlPattern, '$1');
while (!tokenizer.endOfFile()) {
const [type, content] = tokenizer.nextToken();
if (type === 'word' && content === 'url') {
return;
} else if (type === 'brackets') {
node.options = content;
node.filename = params.replace(content, '').trim();
break;
}
}
}
};

58
node_modules/postcss-less/lib/nodes/inline-comment.js generated vendored Normal file
View File

@@ -0,0 +1,58 @@
/* eslint-disable no-param-reassign */
const tokenizer = require('postcss/lib/tokenize');
const Input = require('postcss/lib/input');
module.exports = {
isInlineComment(token) {
if (token[0] === 'word' && token[1].slice(0, 2) === '//') {
const first = token;
const bits = [];
let last;
while (token) {
if (/\r?\n/.test(token[1])) {
// If there are quotes, fix tokenizer creating one token from start quote to end quote
if (/['"].*\r?\n/.test(token[1])) {
// Add string before newline to inline comment token
bits.push(token[1].substring(0, token[1].indexOf('\n')));
// Get remaining input and retokenize
let remainingInput = token[1].substring(token[1].indexOf('\n'));
remainingInput += this.input.css.valueOf().substring(this.tokenizer.position());
// Replace tokenizer to retokenize the rest of the string
this.input = new Input(remainingInput);
this.tokenizer = tokenizer(this.input);
} else {
// If the tokenizer went to the next line go back
this.tokenizer.back(token);
}
break;
}
bits.push(token[1]);
last = token;
token = this.tokenizer.nextToken({ ignoreUnclosed: true });
}
const newToken = ['comment', bits.join(''), first[2], first[3], last[2], last[3]];
this.inlineComment(newToken);
return true;
} else if (token[1] === '/') {
// issue #135
const next = this.tokenizer.nextToken({ ignoreUnclosed: true });
if (next[0] === 'comment' && /^\/\*/.test(next[1])) {
next[0] = 'word';
next[1] = next[1].slice(1);
token[1] = '//';
this.tokenizer.back(next);
return module.exports.isInlineComment.bind(this)(token);
}
}
return false;
}
};

34
node_modules/postcss-less/lib/nodes/interpolation.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
/* eslint no-param-reassign: off */
module.exports = {
interpolation(token) {
let first = token;
const tokens = [token];
const validTypes = ['word', '{', '}'];
token = this.tokenizer.nextToken();
// look for @{ but not @[word]{
if (first[1].length > 1 || token[0] !== '{') {
this.tokenizer.back(token);
return false;
}
while (token && validTypes.includes(token[0])) {
tokens.push(token);
token = this.tokenizer.nextToken();
}
const words = tokens.map((tokn) => tokn[1]);
[first] = tokens;
const last = tokens.pop();
const start = [first[2], first[3]];
const end = [last[4] || last[2], last[5] || last[3]];
const newToken = ['word', words.join('')].concat(start, end);
this.tokenizer.back(token);
this.tokenizer.back(newToken);
return true;
}
};

17
node_modules/postcss-less/lib/nodes/mixin.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
const hashColorPattern = /^#[0-9a-fA-F]{6}$|^#[0-9a-fA-F]{3}$/;
const unpaddedFractionalNumbersPattern = /\.[0-9]/;
const isMixinToken = (token) => {
const [, symbol] = token;
const [char] = symbol;
return (
(char === '.' || char === '#') &&
// ignore hashes used for colors
hashColorPattern.test(symbol) === false &&
// ignore dots used for unpadded fractional numbers
unpaddedFractionalNumbersPattern.test(symbol) === false
);
};
module.exports = { isMixinToken };

34
node_modules/postcss-less/lib/nodes/variable.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
/* eslint no-param-reassign: off */
const afterPattern = /:$/;
const beforePattern = /^:(\s+)?/;
// const bracketsPattern = /\{/;
module.exports = (node) => {
const { name, params = '' } = node;
// situations like @page :last { color: red } should default to the built-in AtRule
// LESS variables are @name : value; < note that for them to be valid LESS vars, they must end in
// a semicolon.
if (node.name.slice(-1) !== ':') {
return;
}
if (afterPattern.test(name)) {
const [match] = name.match(afterPattern);
node.name = name.replace(match, '');
node.raws.afterName = match + (node.raws.afterName || '');
node.variable = true;
node.value = node.params;
}
if (beforePattern.test(params)) {
const [match] = params.match(beforePattern);
node.value = params.replace(match, '');
node.raws.afterName = (node.raws.afterName || '') + match;
node.variable = true;
}
};