Tailwind css added

node_modules/postcss-less/lib/LessParser.js

@@ -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);
+  }
+};

node_modules/postcss-less/lib/LessStringifier.js

@@ -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);
+    }
+  }
+};

node_modules/postcss-less/lib/index.js

@@ -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;
+  }
+};

node_modules/postcss-less/lib/nodes/import.js

@@ -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;
+      }
+    }
+  }
+};

node_modules/postcss-less/lib/nodes/inline-comment.js

@@ -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;
+  }
+};

node_modules/postcss-less/lib/nodes/interpolation.js

@@ -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;
+  }
+};

node_modules/postcss-less/lib/nodes/mixin.js

@@ -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 };

node_modules/postcss-less/lib/nodes/variable.js

@@ -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;
+  }
+};